From 4fb1577d39c91eb49f10686a9f07bcc7cac26cde Mon Sep 17 00:00:00 2001
From: Amit Kumar <ak.nitrr13@gmail.com>
Date: Mon, 25 May 2026 12:05:06 +0000
Subject: [PATCH 1/2] feat(protocol): expose analyzer quick fixes in scan
 output
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

Engine.Issue has carried quickFixes() since sonarlint-core 11.x and the
sonar-plugin-api has shipped the NewIssue.addQuickFix(...) builder for
several major versions. Until now the daemon silently dropped them at
the protocol-DTO boundary, leaving downstream consumers (the agent
pipeline and the JSON CLI users) to guess at remediations.

This change carries quick fixes end-to-end:

Protocol DTOs (new)
  - TextEdit(startLine, startColumn, endLine, endColumn, replacement) —
    a single in-file replacement edit
  - FileEdit(filePath, edits) — all TextEdits a quick fix applies to one
    file; null-normalised and defensively copied
  - QuickFix(message, fileEdits) — an analyzer-supplied remediation,
    possibly spanning multiple files

Issue DTO
  - Added List<QuickFix> quickFixes field (compact ctor null-normalises
    and copies). A backwards-compatible 9-arg constructor delegates with
    List.of(), so the ~15 existing test call sites keep compiling.

IssueMapper
  - mapQuickFixes(List<engine.QuickFix>, baseDir) translates the engine's
    QuickFix / ClientInputFileEdit / TextEdit tree into our DTOs,
    resolving each edit's target file path through the same
    resolveFilePath() the primary issue uses (so quick-fix paths share
    the baseDir-relative, '/'-separated convention).
  - The original 5-arg map(...) overload is preserved and delegates to a
    new 6-arg overload that takes the quickFixes list.

Test coverage (356/356 pass, +20 new):
  - Per-DTO Jackson roundtrip + null-normalisation + defensive-copy
    contracts (TextEditTest x3, FileEditTest x5, QuickFixTest x5,
    IssueTest +3).
  - IssueMapperTest +3: single-edit roundtrip, empty list, multi-file.
  - AnalysisServiceTest +1: the existing UtilityClass.java fixture
    raises java:S1118; assert the resulting protocol Issue carries at
    least one QuickFix with one FileEdit + TextEdit, and that the
    quick-fix file path matches the issue's file path. This is the
    canary that proves the full daemon -> JSON pipeline emits real
    analyzer-supplied edits, not just the schema.

JSON shape is additive: existing consumers that don't read .quickFixes
remain unaffected; new consumers gain a per-issue remediation list.

Targeting 0.3.0-SNAPSHOT (0.2.0 was tagged at HEAD of main).
---
 pom.xml                                       |  2 +-
 .../sonarpredict/daemon/IssueMapper.java      | 63 +++++++++++++--
 .../sonarpredict/protocol/dto/FileEdit.java   | 23 ++++++
 .../sonarpredict/protocol/dto/Issue.java      | 40 +++++++++-
 .../sonarpredict/protocol/dto/QuickFix.java   | 27 +++++++
 .../sonarpredict/protocol/dto/TextEdit.java   | 24 ++++++
 .../daemon/AnalysisServiceTest.java           | 27 +++++++
 .../sonarpredict/daemon/IssueMapperTest.java  | 80 +++++++++++++++++++
 .../protocol/dto/FileEditTest.java            | 59 ++++++++++++++
 .../sonarpredict/protocol/dto/IssueTest.java  | 36 +++++++++
 .../protocol/dto/QuickFixTest.java            | 59 ++++++++++++++
 .../protocol/dto/TextEditTest.java            | 36 +++++++++
 12 files changed, 465 insertions(+), 11 deletions(-)
 create mode 100644 src/main/java/io/github/randomcodespace/sonarpredict/protocol/dto/FileEdit.java
 create mode 100644 src/main/java/io/github/randomcodespace/sonarpredict/protocol/dto/QuickFix.java
 create mode 100644 src/main/java/io/github/randomcodespace/sonarpredict/protocol/dto/TextEdit.java
 create mode 100644 src/test/java/io/github/randomcodespace/sonarpredict/protocol/dto/FileEditTest.java
 create mode 100644 src/test/java/io/github/randomcodespace/sonarpredict/protocol/dto/QuickFixTest.java
 create mode 100644 src/test/java/io/github/randomcodespace/sonarpredict/protocol/dto/TextEditTest.java

diff --git a/pom.xml b/pom.xml
index 135a623..1fa3a28 100644
--- a/pom.xml
+++ b/pom.xml
@@ -6,7 +6,7 @@
 
     <groupId>io.github.randomcodespace.sonarpredict</groupId>
     <artifactId>sonar-predictor</artifactId>
-    <version>0.2.0-SNAPSHOT</version>
+    <version>0.3.0-SNAPSHOT</version>
     <!--
       Packaging is jar so the default Maven lifecycle binds compile, test,
       and jar plugins automatically. The "primary" jar this produces is
diff --git a/src/main/java/io/github/randomcodespace/sonarpredict/daemon/IssueMapper.java b/src/main/java/io/github/randomcodespace/sonarpredict/daemon/IssueMapper.java
index 5ca3042..0a7fae2 100644
--- a/src/main/java/io/github/randomcodespace/sonarpredict/daemon/IssueMapper.java
+++ b/src/main/java/io/github/randomcodespace/sonarpredict/daemon/IssueMapper.java
@@ -1,12 +1,17 @@
 package io.github.randomcodespace.sonarpredict.daemon;
 
 import java.nio.file.Path;
+import java.util.List;
 
 import org.sonarsource.sonarlint.core.analysis.api.ClientInputFile;
+import org.sonarsource.sonarlint.core.analysis.api.ClientInputFileEdit;
 import org.sonarsource.sonarlint.core.analysis.api.Issue;
 import org.sonarsource.sonarlint.core.commons.api.TextRange;
 
+import io.github.randomcodespace.sonarpredict.protocol.dto.FileEdit;
+import io.github.randomcodespace.sonarpredict.protocol.dto.QuickFix;
 import io.github.randomcodespace.sonarpredict.protocol.dto.RuleMetadata;
+import io.github.randomcodespace.sonarpredict.protocol.dto.TextEdit;
 
 /**
  * Maps an engine {@link Issue} to the protocol {@link io.github.randomcodespace.sonarpredict.protocol.dto.Issue}.
@@ -45,18 +50,32 @@ public static io.github.randomcodespace.sonarpredict.protocol.dto.Issue toDto(
                 resolveFilePath(engineIssue.getInputFile(), baseDir),
                 engineIssue.getTextRange(),
                 engineIssue.getMessage(),
-                catalog);
+                catalog,
+                mapQuickFixes(engineIssue.quickFixes(), baseDir));
     }
 
     /**
-     * Pure mapping from primitive issue fields to a protocol DTO. A {@code null}
-     * {@code range} (file-level issue) yields zero positions. Severity and type
-     * are resolved from {@code catalog} by {@code ruleKey}, falling back to
-     * {@link #DEFAULT_SEVERITY}/{@link #DEFAULT_TYPE} for unknown rules.
+     * Pure mapping from primitive issue fields to a protocol DTO with no quick
+     * fixes. A {@code null} {@code range} (file-level issue) yields zero
+     * positions. Severity and type are resolved from {@code catalog} by
+     * {@code ruleKey}, falling back to {@link #DEFAULT_SEVERITY}/{@link #DEFAULT_TYPE}
+     * for unknown rules.
      */
     static io.github.randomcodespace.sonarpredict.protocol.dto.Issue map(
             String ruleKey, String filePath, TextRange range, String message,
             RuleCatalog catalog) {
+        return map(ruleKey, filePath, range, message, catalog, List.of());
+    }
+
+    /**
+     * Pure mapping from primitive issue fields to a protocol DTO with the
+     * supplied {@code quickFixes}. Used by {@link #toDto} after extracting
+     * the engine's quick fixes; tests can call this overload directly to
+     * exercise the full DTO shape without spinning up the engine.
+     */
+    static io.github.randomcodespace.sonarpredict.protocol.dto.Issue map(
+            String ruleKey, String filePath, TextRange range, String message,
+            RuleCatalog catalog, List<QuickFix> quickFixes) {
         int startLine = range != null ? range.getStartLine() : 0;
         int startColumn = range != null ? range.getStartLineOffset() : 0;
         int endLine = range != null ? range.getEndLine() : 0;
@@ -79,7 +98,39 @@ static io.github.randomcodespace.sonarpredict.protocol.dto.Issue map(
                 endColumn,
                 severity,
                 type,
-                message);
+                message,
+                quickFixes);
+    }
+
+    /**
+     * Maps the engine's {@link org.sonarsource.sonarlint.core.analysis.api.QuickFix}
+     * list to the protocol's {@link QuickFix} DTOs.
+     *
+     * <p>Engine {@code QuickFix.message()} is preserved verbatim. Each
+     * {@link ClientInputFileEdit}'s target is path-resolved the same way the
+     * primary issue's input file is (via {@link #resolveFilePath}), so quick-fix
+     * targets share the {@code baseDir}-relative, '/'-separated convention with
+     * {@link io.github.randomcodespace.sonarpredict.protocol.dto.Issue#filePath}.
+     */
+    static List<QuickFix> mapQuickFixes(
+            List<org.sonarsource.sonarlint.core.analysis.api.QuickFix> engineQuickFixes,
+            Path baseDir) {
+        return engineQuickFixes.stream()
+                .map(qf -> new QuickFix(
+                        qf.message(),
+                        qf.inputFileEdits().stream()
+                                .map(ife -> new FileEdit(
+                                        resolveFilePath(ife.target(), baseDir),
+                                        ife.textEdits().stream()
+                                                .map(te -> new TextEdit(
+                                                        te.range().getStartLine(),
+                                                        te.range().getStartLineOffset(),
+                                                        te.range().getEndLine(),
+                                                        te.range().getEndLineOffset(),
+                                                        te.newText()))
+                                                .toList()))
+                                .toList()))
+                .toList();
     }
 
     private static String resolveFilePath(ClientInputFile inputFile, Path baseDir) {
diff --git a/src/main/java/io/github/randomcodespace/sonarpredict/protocol/dto/FileEdit.java b/src/main/java/io/github/randomcodespace/sonarpredict/protocol/dto/FileEdit.java
new file mode 100644
index 0000000..b575c1b
--- /dev/null
+++ b/src/main/java/io/github/randomcodespace/sonarpredict/protocol/dto/FileEdit.java
@@ -0,0 +1,23 @@
+package io.github.randomcodespace.sonarpredict.protocol.dto;
+
+import java.util.List;
+
+/**
+ * All {@link TextEdit}s a {@link QuickFix} applies to one specific file.
+ *
+ * <p>The compact constructor null-normalises and defensively copies {@code edits}
+ * so the record stays immutable regardless of how callers (Jackson, tests,
+ * direct construction) hand it in.
+ *
+ * @param filePath path relative to the analysis base directory, matching the
+ *                 convention used by {@link Issue#filePath}
+ * @param edits    the in-file edits to apply; never {@code null}
+ */
+public record FileEdit(
+        String filePath,
+        List<TextEdit> edits
+) {
+    public FileEdit {
+        edits = edits == null ? List.of() : List.copyOf(edits);
+    }
+}
diff --git a/src/main/java/io/github/randomcodespace/sonarpredict/protocol/dto/Issue.java b/src/main/java/io/github/randomcodespace/sonarpredict/protocol/dto/Issue.java
index 80a1258..3e4f156 100644
--- a/src/main/java/io/github/randomcodespace/sonarpredict/protocol/dto/Issue.java
+++ b/src/main/java/io/github/randomcodespace/sonarpredict/protocol/dto/Issue.java
@@ -1,11 +1,21 @@
 package io.github.randomcodespace.sonarpredict.protocol.dto;
 
+import java.util.List;
+
 /**
  * A single analysis finding.
  *
- * @param filePath path relative to the analysis base directory
- * @param severity one of BLOCKER, CRITICAL, MAJOR, MINOR, INFO
- * @param type     one of BUG, CODE_SMELL, VULNERABILITY, SECURITY_HOTSPOT
+ * @param ruleKey    rule identifier, e.g. {@code java:S1118}
+ * @param filePath   path relative to the analysis base directory
+ * @param startLine  1-indexed inclusive
+ * @param startColumn 0-indexed inclusive
+ * @param endLine    1-indexed inclusive
+ * @param endColumn  0-indexed exclusive
+ * @param severity   one of BLOCKER, CRITICAL, MAJOR, MINOR, INFO
+ * @param type       one of BUG, CODE_SMELL, VULNERABILITY, SECURITY_HOTSPOT
+ * @param message    human-readable, often imperative ("Use isEmpty() to check…")
+ * @param quickFixes analyzer-supplied machine-applicable remediations; never
+ *                   {@code null} — empty list when none are attached
  */
 public record Issue(
         String ruleKey,
@@ -16,6 +26,28 @@ public record Issue(
         int endColumn,
         String severity,
         String type,
-        String message
+        String message,
+        List<QuickFix> quickFixes
 ) {
+    public Issue {
+        quickFixes = quickFixes == null ? List.of() : List.copyOf(quickFixes);
+    }
+
+    /**
+     * Backwards-compatible 9-arg constructor used by call sites that pre-date
+     * the {@code quickFixes} field. Defaults the new field to an empty list.
+     */
+    public Issue(
+            String ruleKey,
+            String filePath,
+            int startLine,
+            int startColumn,
+            int endLine,
+            int endColumn,
+            String severity,
+            String type,
+            String message) {
+        this(ruleKey, filePath, startLine, startColumn, endLine, endColumn,
+                severity, type, message, List.of());
+    }
 }
diff --git a/src/main/java/io/github/randomcodespace/sonarpredict/protocol/dto/QuickFix.java b/src/main/java/io/github/randomcodespace/sonarpredict/protocol/dto/QuickFix.java
new file mode 100644
index 0000000..2bb673a
--- /dev/null
+++ b/src/main/java/io/github/randomcodespace/sonarpredict/protocol/dto/QuickFix.java
@@ -0,0 +1,27 @@
+package io.github.randomcodespace.sonarpredict.protocol.dto;
+
+import java.util.List;
+
+/**
+ * An analyzer-supplied, machine-applicable remediation for an {@link Issue}.
+ *
+ * <p>A quick fix carries a human-readable {@code message} describing the change
+ * and a list of {@link FileEdit}s — usually one file, but multi-file edits are
+ * permitted by the SonarSource analyzer contract.
+ *
+ * <p>Not every issue has quick fixes — rule coverage is uneven across
+ * analyzers. {@link Issue#quickFixes()} returns an empty list when none are
+ * attached, so consumers can iterate uniformly.
+ *
+ * @param message    short, imperative remediation description (e.g.
+ *                   "Add a private constructor")
+ * @param fileEdits  per-file edits this fix applies; never {@code null}
+ */
+public record QuickFix(
+        String message,
+        List<FileEdit> fileEdits
+) {
+    public QuickFix {
+        fileEdits = fileEdits == null ? List.of() : List.copyOf(fileEdits);
+    }
+}
diff --git a/src/main/java/io/github/randomcodespace/sonarpredict/protocol/dto/TextEdit.java b/src/main/java/io/github/randomcodespace/sonarpredict/protocol/dto/TextEdit.java
new file mode 100644
index 0000000..35aefec
--- /dev/null
+++ b/src/main/java/io/github/randomcodespace/sonarpredict/protocol/dto/TextEdit.java
@@ -0,0 +1,24 @@
+package io.github.randomcodespace.sonarpredict.protocol.dto;
+
+/**
+ * A single replacement edit inside one file — the smallest unit of a {@link QuickFix}.
+ *
+ * <p>Positions are 1-indexed lines and 0-indexed columns to match the convention
+ * used by {@link Issue#startLine}/{@link Issue#startColumn} so consumers that
+ * already render issue positions can render edits the same way.
+ *
+ * @param startLine    1-indexed inclusive start line
+ * @param startColumn  0-indexed inclusive start column on {@code startLine}
+ * @param endLine      1-indexed inclusive end line
+ * @param endColumn    0-indexed exclusive end column on {@code endLine}
+ * @param replacement  the text to substitute for the range; the empty string
+ *                     means "delete the range"
+ */
+public record TextEdit(
+        int startLine,
+        int startColumn,
+        int endLine,
+        int endColumn,
+        String replacement
+) {
+}
diff --git a/src/test/java/io/github/randomcodespace/sonarpredict/daemon/AnalysisServiceTest.java b/src/test/java/io/github/randomcodespace/sonarpredict/daemon/AnalysisServiceTest.java
index bc94f55..b0d9836 100644
--- a/src/test/java/io/github/randomcodespace/sonarpredict/daemon/AnalysisServiceTest.java
+++ b/src/test/java/io/github/randomcodespace/sonarpredict/daemon/AnalysisServiceTest.java
@@ -1,5 +1,6 @@
 package io.github.randomcodespace.sonarpredict.daemon;
 
+import static org.junit.jupiter.api.Assertions.assertEquals;
 import static org.junit.jupiter.api.Assertions.assertFalse;
 import static org.junit.jupiter.api.Assertions.assertNotNull;
 import static org.junit.jupiter.api.Assertions.assertTrue;
@@ -46,6 +47,32 @@ void analyze_java_stillWorks() {
         }
     }
 
+    @Test
+    @DisplayName("java:S1118 on UtilityClass.java carries an analyzer-supplied quick fix")
+    void analyze_java_s1118_carriesQuickFix() {
+        try (AnalysisService service = new AnalysisService()) {
+            AnalyzeResponse response = service.analyze(request("java/UtilityClass.java"));
+
+            Issue s1118 = response.issues().stream()
+                    .filter(i -> "java:S1118".equals(i.ruleKey()))
+                    .findFirst()
+                    .orElseThrow(() -> new AssertionError(
+                            "expected java:S1118 in: " + response.issues()));
+            assertFalse(s1118.quickFixes().isEmpty(),
+                    "java:S1118 must surface at least one analyzer-supplied quick fix; got: "
+                            + s1118);
+            assertFalse(s1118.quickFixes().get(0).fileEdits().isEmpty(),
+                    "quick-fix must have at least one file edit; got: " + s1118.quickFixes());
+            assertFalse(
+                    s1118.quickFixes().get(0).fileEdits().get(0).edits().isEmpty(),
+                    "file edit must have at least one text edit; got: " + s1118.quickFixes());
+            // The edit's path must match the issue's path (relative to baseDir).
+            assertEquals(s1118.filePath(),
+                    s1118.quickFixes().get(0).fileEdits().get(0).filePath(),
+                    "quick-fix file path must match the issue's file path");
+        }
+    }
+
     @Test
     @DisplayName("a warm AnalysisService is constructed once and reused across many analyze() calls")
     void analyze_warmServiceReusedAcrossCalls() {
diff --git a/src/test/java/io/github/randomcodespace/sonarpredict/daemon/IssueMapperTest.java b/src/test/java/io/github/randomcodespace/sonarpredict/daemon/IssueMapperTest.java
index 7471c52..4ae42f2 100644
--- a/src/test/java/io/github/randomcodespace/sonarpredict/daemon/IssueMapperTest.java
+++ b/src/test/java/io/github/randomcodespace/sonarpredict/daemon/IssueMapperTest.java
@@ -2,14 +2,23 @@
 
 import static org.junit.jupiter.api.Assertions.assertEquals;
 
+import java.nio.file.Files;
 import java.nio.file.Path;
 import java.nio.file.Paths;
+import java.util.List;
 
 import org.junit.jupiter.api.BeforeAll;
 import org.junit.jupiter.api.DisplayName;
 import org.junit.jupiter.api.Test;
+import org.junit.jupiter.api.io.TempDir;
+import org.sonarsource.sonarlint.core.analysis.api.ClientInputFileEdit;
+import org.sonarsource.sonarlint.core.commons.api.SonarLanguage;
 import org.sonarsource.sonarlint.core.commons.api.TextRange;
 
+import io.github.randomcodespace.sonarpredict.protocol.dto.FileEdit;
+import io.github.randomcodespace.sonarpredict.protocol.dto.QuickFix;
+import io.github.randomcodespace.sonarpredict.protocol.dto.TextEdit;
+
 class IssueMapperTest {
 
     private static final Path PLUGINS_DIR = Paths.get("plugins");
@@ -75,4 +84,75 @@ void map_withoutRange_usesZeroPositions() {
         assertEquals(0, dto.endColumn());
         assertEquals("java:S1118", dto.ruleKey());
     }
+
+    @Test
+    @DisplayName("mapQuickFixes() preserves message, target path and text-edit positions")
+    void mapQuickFixes_singleEditRoundtrip(@TempDir Path baseDir) throws Exception {
+        Path pkgDir = Files.createDirectories(baseDir.resolve("com/example"));
+        Path src = pkgDir.resolve("UtilityClass.java");
+        Files.writeString(src, "package com.example;\npublic class UtilityClass {}\n");
+        FileInputFile input = new FileInputFile(src, baseDir, SonarLanguage.JAVA, false);
+
+        org.sonarsource.sonarlint.core.analysis.api.TextEdit engineEdit =
+                new org.sonarsource.sonarlint.core.analysis.api.TextEdit(
+                        new TextRange(3, 0, 3, 0),
+                        "    private UtilityClass() {}\n");
+        ClientInputFileEdit fileEdit = new ClientInputFileEdit(input, List.of(engineEdit));
+        org.sonarsource.sonarlint.core.analysis.api.QuickFix engineQf =
+                new org.sonarsource.sonarlint.core.analysis.api.QuickFix(
+                        List.of(fileEdit), "Add a private constructor");
+
+        List<QuickFix> mapped = IssueMapper.mapQuickFixes(List.of(engineQf), baseDir);
+
+        assertEquals(1, mapped.size());
+        QuickFix qf = mapped.get(0);
+        assertEquals("Add a private constructor", qf.message());
+        assertEquals(1, qf.fileEdits().size());
+        FileEdit fe = qf.fileEdits().get(0);
+        assertEquals("com/example/UtilityClass.java", fe.filePath());
+        assertEquals(1, fe.edits().size());
+        TextEdit te = fe.edits().get(0);
+        assertEquals(3, te.startLine());
+        assertEquals(0, te.startColumn());
+        assertEquals(3, te.endLine());
+        assertEquals(0, te.endColumn());
+        assertEquals("    private UtilityClass() {}\n", te.replacement());
+    }
+
+    @Test
+    @DisplayName("an empty engine quick-fix list maps to an empty DTO list")
+    void mapQuickFixes_emptyList(@TempDir Path baseDir) {
+        assertEquals(List.of(), IssueMapper.mapQuickFixes(List.of(), baseDir));
+    }
+
+    @Test
+    @DisplayName("a multi-file quick-fix preserves both files in order")
+    void mapQuickFixes_multiFile(@TempDir Path baseDir) throws Exception {
+        Path a = baseDir.resolve("A.java");
+        Path b = baseDir.resolve("B.java");
+        Files.writeString(a, "class A {}\n");
+        Files.writeString(b, "class B {}\n");
+        FileInputFile inA = new FileInputFile(a, baseDir, SonarLanguage.JAVA, false);
+        FileInputFile inB = new FileInputFile(b, baseDir, SonarLanguage.JAVA, false);
+
+        org.sonarsource.sonarlint.core.analysis.api.QuickFix qf =
+                new org.sonarsource.sonarlint.core.analysis.api.QuickFix(
+                        List.of(
+                                new ClientInputFileEdit(inA, List.of(
+                                        new org.sonarsource.sonarlint.core.analysis.api.TextEdit(
+                                                new TextRange(1, 6, 1, 7), "X"))),
+                                new ClientInputFileEdit(inB, List.of(
+                                        new org.sonarsource.sonarlint.core.analysis.api.TextEdit(
+                                                new TextRange(1, 6, 1, 7), "Y")))),
+                        "Rename across two files");
+
+        List<QuickFix> mapped = IssueMapper.mapQuickFixes(List.of(qf), baseDir);
+
+        assertEquals(1, mapped.size());
+        assertEquals(2, mapped.get(0).fileEdits().size());
+        assertEquals("A.java", mapped.get(0).fileEdits().get(0).filePath());
+        assertEquals("B.java", mapped.get(0).fileEdits().get(1).filePath());
+        assertEquals("X", mapped.get(0).fileEdits().get(0).edits().get(0).replacement());
+        assertEquals("Y", mapped.get(0).fileEdits().get(1).edits().get(0).replacement());
+    }
 }
diff --git a/src/test/java/io/github/randomcodespace/sonarpredict/protocol/dto/FileEditTest.java b/src/test/java/io/github/randomcodespace/sonarpredict/protocol/dto/FileEditTest.java
new file mode 100644
index 0000000..3fae917
--- /dev/null
+++ b/src/test/java/io/github/randomcodespace/sonarpredict/protocol/dto/FileEditTest.java
@@ -0,0 +1,59 @@
+package io.github.randomcodespace.sonarpredict.protocol.dto;
+
+import static org.junit.jupiter.api.Assertions.assertEquals;
+import static org.junit.jupiter.api.Assertions.assertNotSame;
+import static org.junit.jupiter.api.Assertions.assertThrows;
+import static org.junit.jupiter.api.Assertions.assertTrue;
+
+import io.github.randomcodespace.sonarpredict.protocol.Json;
+import java.util.ArrayList;
+import java.util.List;
+import org.junit.jupiter.api.Test;
+
+class FileEditTest {
+
+    @Test
+    void serializesAndDeserializes() throws Exception {
+        FileEdit original = new FileEdit(
+                "src/main/java/Util.java",
+                List.of(new TextEdit(1, 0, 1, 0, "package com.example;\n")));
+        String json = Json.mapper().writeValueAsString(original);
+        FileEdit restored = Json.mapper().readValue(json, FileEdit.class);
+        assertEquals(original, restored);
+    }
+
+    @Test
+    void nullEditsBecomeEmptyList() {
+        FileEdit fileEdit = new FileEdit("x.java", null);
+        assertTrue(fileEdit.edits().isEmpty());
+    }
+
+    @Test
+    void editsAreDefensivelyCopied() {
+        List<TextEdit> mutable = new ArrayList<>();
+        mutable.add(new TextEdit(1, 0, 1, 5, "hello"));
+        FileEdit fileEdit = new FileEdit("x.java", mutable);
+        mutable.add(new TextEdit(2, 0, 2, 5, "world"));
+        assertEquals(1, fileEdit.edits().size());
+    }
+
+    @Test
+    void editsListIsUnmodifiable() {
+        FileEdit fileEdit = new FileEdit("x.java", List.of());
+        assertThrows(UnsupportedOperationException.class,
+                () -> fileEdit.edits().add(new TextEdit(1, 0, 1, 0, "x")));
+    }
+
+    @Test
+    void roundtripPreservesIdentity() throws Exception {
+        FileEdit original = new FileEdit(
+                "src/Bad.java",
+                List.of(
+                        new TextEdit(3, 11, 3, 30, "Optional.empty()"),
+                        new TextEdit(5, 0, 5, 4, "// fixed: ")));
+        String json = Json.mapper().writeValueAsString(original);
+        FileEdit restored = Json.mapper().readValue(json, FileEdit.class);
+        assertEquals(original, restored);
+        assertNotSame(original.edits(), restored.edits());
+    }
+}
diff --git a/src/test/java/io/github/randomcodespace/sonarpredict/protocol/dto/IssueTest.java b/src/test/java/io/github/randomcodespace/sonarpredict/protocol/dto/IssueTest.java
index 8aeda48..e86dae4 100644
--- a/src/test/java/io/github/randomcodespace/sonarpredict/protocol/dto/IssueTest.java
+++ b/src/test/java/io/github/randomcodespace/sonarpredict/protocol/dto/IssueTest.java
@@ -4,6 +4,7 @@
 import static org.junit.jupiter.api.Assertions.assertTrue;
 
 import io.github.randomcodespace.sonarpredict.protocol.Json;
+import java.util.List;
 import org.junit.jupiter.api.Test;
 
 class IssueTest {
@@ -18,4 +19,39 @@ void serializesAndDeserializes() throws Exception {
         Issue restored = Json.mapper().readValue(json, Issue.class);
         assertEquals(original, restored);
     }
+
+    @Test
+    void nineArgConstructorDefaultsQuickFixesToEmpty() {
+        Issue issue = new Issue(
+                "java:S1118", "x", 1, 0, 1, 5, "MAJOR", "CODE_SMELL", "m");
+        assertTrue(issue.quickFixes().isEmpty());
+    }
+
+    @Test
+    void roundtripsWithQuickFixes() throws Exception {
+        List<QuickFix> qfs = List.of(
+                new QuickFix(
+                        "Add a private constructor",
+                        List.of(new FileEdit(
+                                "src/Main.java",
+                                List.of(new TextEdit(3, 0, 3, 0,
+                                        "    private Main() {}\n"))))));
+        Issue original = new Issue(
+                "java:S1118", "src/Main.java", 1, 0, 1, 4,
+                "MAJOR", "CODE_SMELL", "Add a private constructor.", qfs);
+        String json = Json.mapper().writeValueAsString(original);
+        assertTrue(json.contains("quickFixes"), json);
+        Issue restored = Json.mapper().readValue(json, Issue.class);
+        assertEquals(original, restored);
+        assertEquals(1, restored.quickFixes().size());
+        assertEquals("Add a private constructor",
+                restored.quickFixes().get(0).message());
+    }
+
+    @Test
+    void nullQuickFixesNormalizedToEmpty() {
+        Issue issue = new Issue(
+                "k", "f", 1, 0, 1, 0, "MAJOR", "CODE_SMELL", "m", null);
+        assertTrue(issue.quickFixes().isEmpty());
+    }
 }
diff --git a/src/test/java/io/github/randomcodespace/sonarpredict/protocol/dto/QuickFixTest.java b/src/test/java/io/github/randomcodespace/sonarpredict/protocol/dto/QuickFixTest.java
new file mode 100644
index 0000000..7e4925c
--- /dev/null
+++ b/src/test/java/io/github/randomcodespace/sonarpredict/protocol/dto/QuickFixTest.java
@@ -0,0 +1,59 @@
+package io.github.randomcodespace.sonarpredict.protocol.dto;
+
+import static org.junit.jupiter.api.Assertions.assertEquals;
+import static org.junit.jupiter.api.Assertions.assertThrows;
+import static org.junit.jupiter.api.Assertions.assertTrue;
+
+import io.github.randomcodespace.sonarpredict.protocol.Json;
+import java.util.ArrayList;
+import java.util.List;
+import org.junit.jupiter.api.Test;
+
+class QuickFixTest {
+
+    @Test
+    void serializesAndDeserializesSingleFileQuickFix() throws Exception {
+        QuickFix original = new QuickFix(
+                "Add a private constructor",
+                List.of(new FileEdit(
+                        "src/main/java/Constants.java",
+                        List.of(new TextEdit(3, 0, 3, 0,
+                                "    private Constants() { /* utility class */ }\n")))));
+        String json = Json.mapper().writeValueAsString(original);
+        QuickFix restored = Json.mapper().readValue(json, QuickFix.class);
+        assertEquals(original, restored);
+    }
+
+    @Test
+    void serializesMultiFileQuickFix() throws Exception {
+        QuickFix original = new QuickFix(
+                "Rename across two files",
+                List.of(
+                        new FileEdit("A.java", List.of(new TextEdit(1, 6, 1, 13, "Renamed"))),
+                        new FileEdit("B.java", List.of(new TextEdit(7, 12, 7, 19, "Renamed")))));
+        String json = Json.mapper().writeValueAsString(original);
+        assertEquals(original, Json.mapper().readValue(json, QuickFix.class));
+    }
+
+    @Test
+    void nullFileEditsBecomeEmptyList() {
+        QuickFix qf = new QuickFix("noop", null);
+        assertTrue(qf.fileEdits().isEmpty());
+    }
+
+    @Test
+    void fileEditsAreDefensivelyCopied() {
+        List<FileEdit> mutable = new ArrayList<>();
+        mutable.add(new FileEdit("a.java", List.of()));
+        QuickFix qf = new QuickFix("x", mutable);
+        mutable.add(new FileEdit("b.java", List.of()));
+        assertEquals(1, qf.fileEdits().size());
+    }
+
+    @Test
+    void fileEditsListIsUnmodifiable() {
+        QuickFix qf = new QuickFix("x", List.of());
+        assertThrows(UnsupportedOperationException.class,
+                () -> qf.fileEdits().add(new FileEdit("a.java", List.of())));
+    }
+}
diff --git a/src/test/java/io/github/randomcodespace/sonarpredict/protocol/dto/TextEditTest.java b/src/test/java/io/github/randomcodespace/sonarpredict/protocol/dto/TextEditTest.java
new file mode 100644
index 0000000..e9258e7
--- /dev/null
+++ b/src/test/java/io/github/randomcodespace/sonarpredict/protocol/dto/TextEditTest.java
@@ -0,0 +1,36 @@
+package io.github.randomcodespace.sonarpredict.protocol.dto;
+
+import static org.junit.jupiter.api.Assertions.assertEquals;
+
+import io.github.randomcodespace.sonarpredict.protocol.Json;
+import org.junit.jupiter.api.Test;
+
+class TextEditTest {
+
+    @Test
+    void serializesAndDeserializes() throws Exception {
+        TextEdit original = new TextEdit(10, 4, 10, 20, "Optional.empty()");
+        String json = Json.mapper().writeValueAsString(original);
+        TextEdit restored = Json.mapper().readValue(json, TextEdit.class);
+        assertEquals(original, restored);
+    }
+
+    @Test
+    void roundtripsMultiLineEdit() throws Exception {
+        TextEdit original = new TextEdit(10, 0, 14, 6, """
+                String s = """ + "\"\"\"" + """
+                  multi
+                  line
+                """ + "\"\"\"" + ";\n");
+        String json = Json.mapper().writeValueAsString(original);
+        assertEquals(original, Json.mapper().readValue(json, TextEdit.class));
+    }
+
+    @Test
+    void emptyReplacementMeansDelete() throws Exception {
+        TextEdit deletion = new TextEdit(5, 0, 6, 0, "");
+        String json = Json.mapper().writeValueAsString(deletion);
+        TextEdit restored = Json.mapper().readValue(json, TextEdit.class);
+        assertEquals("", restored.replacement());
+    }
+}

From 6e62502eb0c307a4a94e9294d9d983fd8010790d Mon Sep 17 00:00:00 2001
From: Amit Kumar <ak.nitrr13@gmail.com>
Date: Mon, 25 May 2026 12:26:47 +0000
Subject: [PATCH 2/2] feat(cli): wire quickFixes through JsonReporter (CLI
 output layer)
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

The previous commit added quickFixes to the protocol DTO. JsonReporter
builds the per-issue ObjectNode by hand and was never updated, so the
new field rode in the daemon -> CLI pipeline but never reached the
user-facing JSON.

This adds a quickFixNode() builder and emits a "quickFixes" array on
issues that carry at least one analyzer-supplied fix. Issues with no
quick fix omit the field entirely (rather than emitting "quickFixes":[])
to keep the wire format token-lean for the common case.

Schema:
  "quickFixes": [{
    "message": "Replace with isEmpty()",
    "fileEdits": [{
      "filePath": "src/main/java/.../SonarCommand.java",
      "edits": [
        { "startLine":254, "startColumn":20, "endLine":254, "endColumn":20,
          "replacement":"!" },
        ...
      ]
    }]
  }]

Field order in each node matches the DTO so emitted JSON roundtrips
cleanly through Json.mapper().readValue(QuickFix.class).

Test coverage (+2 in ReportersTest, 358/358 total):
  - jsonOmitsEmptyQuickFixes: existing WITH_ISSUES fixture has no
    quick fixes; the field must be absent from the rendered JSON.
  - jsonEmitsQuickFixes: a synthetic Issue carrying a real QuickFix
    serializes through JsonReporter; verifies message, fileEdits[0]
    .filePath, and edits[0].{startLine,startColumn,endLine,endColumn,
    replacement} all roundtrip with the right values.

Self-scan canary (ran sonar against this worktree): 3 of 29 issues
now carry quick fixes (2x java:S7158 "isEmpty()" replacement in
SonarCommand.java, 1x java:S1450 field-to-local in DaemonServer.java).
Real machine-applicable edits, not guesses.

SARIF reporter is intentionally unchanged in this commit — SARIF has
its own 'fixes' schema that warrants a separate, dedicated mapping.
---
 .../sonarpredict/cli/JsonReporter.java        | 38 +++++++++++++++
 .../sonarpredict/cli/ReportersTest.java       | 47 +++++++++++++++++++
 2 files changed, 85 insertions(+)

diff --git a/src/main/java/io/github/randomcodespace/sonarpredict/cli/JsonReporter.java b/src/main/java/io/github/randomcodespace/sonarpredict/cli/JsonReporter.java
index d2ca9c4..153af7e 100644
--- a/src/main/java/io/github/randomcodespace/sonarpredict/cli/JsonReporter.java
+++ b/src/main/java/io/github/randomcodespace/sonarpredict/cli/JsonReporter.java
@@ -13,8 +13,11 @@
 import io.github.randomcodespace.sonarpredict.protocol.Json;
 import io.github.randomcodespace.sonarpredict.protocol.dto.AnalysisWarning;
 import io.github.randomcodespace.sonarpredict.protocol.dto.AnalyzeResponse;
+import io.github.randomcodespace.sonarpredict.protocol.dto.FileEdit;
 import io.github.randomcodespace.sonarpredict.protocol.dto.Issue;
+import io.github.randomcodespace.sonarpredict.protocol.dto.QuickFix;
 import io.github.randomcodespace.sonarpredict.protocol.dto.RuleMetadata;
+import io.github.randomcodespace.sonarpredict.protocol.dto.TextEdit;
 
 /**
  * Renders an {@link AnalyzeResponse} as compact, single-line JSON, parseable by
@@ -97,6 +100,10 @@ private static double round(double percent) {
     /**
      * Builds one issue node with a fixed, deterministic field order. When
      * {@code metadata} is non-null the issue gains a nested {@code rule} object.
+     * When the issue carries any analyzer-supplied {@link QuickFix}es, the
+     * issue gains a {@code quickFixes} array; the field is omitted (rather
+     * than emitted as {@code []}) to keep the wire format token-lean for
+     * the common case where rules don't supply machine-applicable fixes.
      */
     private static ObjectNode issueNode(Issue issue, RuleMetadata metadata) {
         ObjectNode node = Json.mapper().createObjectNode();
@@ -116,6 +123,37 @@ private static ObjectNode issueNode(Issue issue, RuleMetadata metadata) {
             rule.put("language", metadata.language());
             rule.put("howToFix", metadata.howToFix());
         }
+        if (!issue.quickFixes().isEmpty()) {
+            ArrayNode quickFixes = node.putArray("quickFixes");
+            for (QuickFix qf : issue.quickFixes()) {
+                quickFixes.add(quickFixNode(qf));
+            }
+        }
+        return node;
+    }
+
+    /**
+     * Builds one {@code {message, fileEdits:[{filePath, edits:[…]}]}} node
+     * for an analyzer-supplied quick fix. Field order matches the DTO so
+     * the emitted JSON can roundtrip through {@code Json.mapper().readValue}.
+     */
+    private static ObjectNode quickFixNode(QuickFix qf) {
+        ObjectNode node = Json.mapper().createObjectNode();
+        node.put("message", qf.message());
+        ArrayNode fileEdits = node.putArray("fileEdits");
+        for (FileEdit fe : qf.fileEdits()) {
+            ObjectNode feNode = fileEdits.addObject();
+            feNode.put("filePath", fe.filePath());
+            ArrayNode edits = feNode.putArray("edits");
+            for (TextEdit te : fe.edits()) {
+                ObjectNode teNode = edits.addObject();
+                teNode.put("startLine", te.startLine());
+                teNode.put("startColumn", te.startColumn());
+                teNode.put("endLine", te.endLine());
+                teNode.put("endColumn", te.endColumn());
+                teNode.put("replacement", te.replacement());
+            }
+        }
         return node;
     }
 }
diff --git a/src/test/java/io/github/randomcodespace/sonarpredict/cli/ReportersTest.java b/src/test/java/io/github/randomcodespace/sonarpredict/cli/ReportersTest.java
index d3f826d..1034d39 100644
--- a/src/test/java/io/github/randomcodespace/sonarpredict/cli/ReportersTest.java
+++ b/src/test/java/io/github/randomcodespace/sonarpredict/cli/ReportersTest.java
@@ -16,8 +16,11 @@
 import io.github.randomcodespace.sonarpredict.protocol.Json;
 import io.github.randomcodespace.sonarpredict.protocol.dto.AnalysisWarning;
 import io.github.randomcodespace.sonarpredict.protocol.dto.AnalyzeResponse;
+import io.github.randomcodespace.sonarpredict.protocol.dto.FileEdit;
 import io.github.randomcodespace.sonarpredict.protocol.dto.Issue;
+import io.github.randomcodespace.sonarpredict.protocol.dto.QuickFix;
 import io.github.randomcodespace.sonarpredict.protocol.dto.RuleMetadata;
+import io.github.randomcodespace.sonarpredict.protocol.dto.TextEdit;
 
 /**
  * Unit tests for the {@link Reporter} implementations: {@link TextReporter}
@@ -163,4 +166,48 @@ void jsonRuleBlockOmitsHtmlDescription() throws Exception {
                 "the compact JSON rule block must not carry an HTML 'description'");
         assertNotNull(ruleBlock.get("name"), "the rule name stays in the compact JSON");
     }
+
+    @Test
+    @DisplayName("JsonReporter omits 'quickFixes' for issues that have none (token-lean)")
+    void jsonOmitsEmptyQuickFixes() throws Exception {
+        String json = new JsonReporter().render(WITH_ISSUES);
+
+        assertFalse(json.contains("\"quickFixes\""),
+                "an issue with no analyzer-supplied quick fix must not emit an empty array; "
+                        + "the field should be absent. got: " + json);
+    }
+
+    @Test
+    @DisplayName("JsonReporter emits a quickFixes array when the issue carries one")
+    void jsonEmitsQuickFixes() throws Exception {
+        Issue withFix = new Issue(
+                "java:S1118", "src/Util.java", 3, 13, 3, 17,
+                "MAJOR", "CODE_SMELL", "Add a private constructor.",
+                List.of(new QuickFix(
+                        "Add a private constructor",
+                        List.of(new FileEdit(
+                                "src/Util.java",
+                                List.of(new TextEdit(3, 0, 3, 0,
+                                        "    private Util() {}\n")))))));
+        AnalyzeResponse response = new AnalyzeResponse(List.of(withFix), List.of());
+
+        String json = new JsonReporter().render(response);
+        JsonNode root = Json.mapper().readTree(json);
+        JsonNode issue = root.get("files").get(0).get("issues").get(0);
+
+        JsonNode qfs = issue.get("quickFixes");
+        assertNotNull(qfs, "the issue must carry a quickFixes array; got: " + json);
+        assertEquals(1, qfs.size(), "exactly one quick fix was supplied");
+        assertEquals("Add a private constructor", qfs.get(0).get("message").asText());
+
+        JsonNode fileEdit = qfs.get(0).get("fileEdits").get(0);
+        assertEquals("src/Util.java", fileEdit.get("filePath").asText());
+
+        JsonNode edit = fileEdit.get("edits").get(0);
+        assertEquals(3, edit.get("startLine").asInt());
+        assertEquals(0, edit.get("startColumn").asInt());
+        assertEquals(3, edit.get("endLine").asInt());
+        assertEquals(0, edit.get("endColumn").asInt());
+        assertEquals("    private Util() {}\n", edit.get("replacement").asText());
+    }
 }