Add comprehensive test suite and GitHub Actions CI

- Extract pure algorithms into HunkMatcher (no IntelliJ deps) for easy testing
- HunkMatcherTest: 22 tests covering exactMatch, parseDiffAndRemap, fuzzySearch, lcsScore
- ReviewCommentTest: 18 tests covering serialization, status, edge cases (unicode, multiline, long threads)
- CommentStoreFileIOTest: 13 tests covering file I/O, atomic writes, filtering, malformed files, schema versions
- Remove MockProject-based AnchorResolverTest (replaced by HunkMatcherTest)
- Add .github/workflows/ci.yml: build, test, plugin verification on JDK 17

https://claude.ai/code/session_015LpmjAt17XD582hZ9TPLCv

Author: claude

.github/workflows/ci.yml

@@ -0,0 +1,79 @@
+name: CI
+
+on:
+  push:
+    branches: [ main, 'claude/**' ]
+  pull_request:
+    branches: [ main ]
+
+permissions:
+  contents: read
+
+jobs:
+  build-and-test:
+    name: Build & Test
+    runs-on: ubuntu-latest
+    defaults:
+      run:
+        working-directory: review-plugin
+
+    steps:
+      - name: Checkout
+        uses: actions/checkout@v4
+
+      - name: Set up JDK 17
+        uses: actions/setup-java@v4
+        with:
+          distribution: temurin
+          java-version: 17
+
+      - name: Setup Gradle
+        uses: gradle/actions/setup-gradle@v4
+
+      - name: Build plugin
+        run: ./gradlew buildPlugin
+
+      - name: Run tests
+        run: ./gradlew test
+
+      - name: Upload test results
+        if: always()
+        uses: actions/upload-artifact@v4
+        with:
+          name: test-results
+          path: review-plugin/build/reports/tests/
+          retention-days: 14
+
+  verify-plugin:
+    name: Verify Plugin Compatibility
+    runs-on: ubuntu-latest
+    needs: build-and-test
+    defaults:
+      run:
+        working-directory: review-plugin
+
+    steps:
+      - name: Checkout
+        uses: actions/checkout@v4
+
+      - name: Set up JDK 17
+        uses: actions/setup-java@v4
+        with:
+          distribution: temurin
+          java-version: 17
+
+      - name: Setup Gradle
+        uses: gradle/actions/setup-gradle@v4
+
+      - name: Verify plugin descriptor
+        run: ./gradlew verifyPluginConfiguration
+
+      - name: Build plugin distribution
+        run: ./gradlew buildPlugin
+
+      - name: Upload plugin artifact
+        uses: actions/upload-artifact@v4
+        with:
+          name: review-plugin
+          path: review-plugin/build/distributions/*.zip
+          retention-days: 30

review-plugin/src/main/kotlin/com/reviewplugin/anchor/AnchorResolver.kt

@@ -1,7 +1,6 @@
 package com.reviewplugin.anchor
 
 import com.intellij.openapi.project.Project
-import com.reviewplugin.model.Hunk
 import com.reviewplugin.model.ReviewComment
 import java.util.concurrent.ConcurrentHashMap
 
@@ -33,7 +32,7 @@ class AnchorResolver(private val project: Project) {
         val target = anchor.hunk.target
 
         // Step 1: Exact match at hint
-        exactMatch(fileLines, anchor.line_hint, target)?.let {
+        HunkMatcher.exactMatch(fileLines, anchor.line_hint, target)?.let {
             return AnchorResult.Found(it)
         }
 
@@ -47,130 +46,19 @@ class AnchorResolver(private val project: Project) {
         }
 
         // Step 3: Fuzzy search
-        fuzzySearch(fileLines, anchor.hunk)?.let {
+        HunkMatcher.fuzzySearch(fileLines, anchor.hunk)?.let {
             return AnchorResult.Found(it)
         }
 
         return AnchorResult.Drifted
     }
 
-    /**
-     * Step 1: Check if lines at line_hint match the target exactly (trimmed comparison).
-     * Returns 0-based line index or null.
-     */
-    internal fun exactMatch(lines: List<String>, lineHint: Int, target: List<String>): Int? {
-        // line_hint is 1-based in the schema
-        val startIdx = lineHint - 1
-        if (startIdx < 0 || startIdx + target.size > lines.size) return null
-        val matches = target.indices.all { i ->
-            lines[startIdx + i].trim() == target[i].trim()
-        }
-        return if (matches) startIdx else null
-    }
-
-    /**
-     * Step 2: Parse unified diff to remap line_hint from old commit to current.
-     * Returns 0-based line index or null.
-     */
-    internal fun gitDiffRemap(commit: String, file: String, hintLine: Int): Int? {
+    private fun gitDiffRemap(commit: String, file: String, hintLine: Int): Int? {
         val gitRunner = GitRunner(project.basePath ?: return null)
         val diffOutput = gitRunner.diffUnified(commit, file)
         if (diffOutput.isBlank()) {
-            // No diff means file hasn't changed, return original hint (0-based)
             return hintLine - 1
         }
-        return parseDiffAndRemap(diffOutput, hintLine)
-    }
-
-    /**
-     * Parse unified diff output and remap a 1-based old line number to a 0-based new line number.
-     */
-    internal fun parseDiffAndRemap(diffOutput: String, oldLine: Int): Int? {
-        val hunkHeaderRegex = Regex("""^@@ -(\d+)(?:,(\d+))? \+(\d+)(?:,(\d+))? @@""")
-        var offset = 0
-        var lastOldEnd = 0
-
-        for (line in diffOutput.lines()) {
-            val match = hunkHeaderRegex.find(line) ?: continue
-            val oldStart = match.groupValues[1].toInt()
-            val oldCount = match.groupValues[2].ifEmpty { "1" }.toInt()
-            val newStart = match.groupValues[3].toInt()
-            val newCount = match.groupValues[4].ifEmpty { "1" }.toInt()
-
-            // If our line is before this hunk, the accumulated offset applies
-            if (oldLine < oldStart) {
-                return oldLine - 1 + offset
-            }
-
-            // If our line falls within a deleted range in this hunk, it's gone
-            val oldEnd = oldStart + oldCount - 1
-            if (oldLine in oldStart..oldEnd) {
-                // Line is in the modified hunk - could be deleted or changed
-                // We can't precisely determine without parsing line-by-line, so return null
-                // to fall through to fuzzy search
-                return null
-            }
-
-            offset = (newStart + newCount) - (oldStart + oldCount)
-            lastOldEnd = oldEnd
-        }
-
-        // Line is after all hunks
-        return oldLine - 1 + offset
-    }
-
-    /**
-     * Step 3: Sliding window fuzzy search using LCS similarity.
-     * Returns 0-based line index or null.
-     */
-    internal fun fuzzySearch(lines: List<String>, hunk: Hunk): Int? {
-        val searchBlock = hunk.context_before + hunk.target + hunk.context_after
-        if (searchBlock.isEmpty()) return null
-
-        val windowSize = searchBlock.size
-        if (lines.size < windowSize) return null
-
-        var bestScore = 0.0
-        var bestLine = -1
-        val threshold = 0.75
-
-        for (i in 0..lines.size - windowSize) {
-            val window = lines.subList(i, i + windowSize)
-            val score = lcsScore(
-                window.map { it.trim() },
-                searchBlock.map { it.trim() }
-            )
-            if (score > bestScore) {
-                bestScore = score
-                bestLine = i
-            }
-        }
-
-        if (bestScore >= threshold && bestLine >= 0) {
-            // Return the line corresponding to the start of the target within the block
-            return bestLine + hunk.context_before.size
-        }
-        return null
-    }
-
-    /**
-     * Compute LCS-based similarity between two lists of strings.
-     */
-    private fun lcsScore(a: List<String>, b: List<String>): Double {
-        val m = a.size
-        val n = b.size
-        if (m == 0 || n == 0) return 0.0
-
-        val dp = Array(m + 1) { IntArray(n + 1) }
-        for (i in 1..m) {
-            for (j in 1..n) {
-                dp[i][j] = if (a[i - 1] == b[j - 1]) {
-                    dp[i - 1][j - 1] + 1
-                } else {
-                    maxOf(dp[i - 1][j], dp[i][j - 1])
-                }
-            }
-        }
-        return dp[m][n].toDouble() / maxOf(m, n)
+        return HunkMatcher.parseDiffAndRemap(diffOutput, hintLine)
     }
 }

review-plugin/src/main/kotlin/com/reviewplugin/anchor/HunkMatcher.kt

@@ -0,0 +1,107 @@
+package com.reviewplugin.anchor
+
+import com.reviewplugin.model.Hunk
+
+/**
+ * Pure algorithms for hunk matching and diff remapping.
+ * No IntelliJ dependencies — fully unit-testable.
+ */
+object HunkMatcher {
+
+    /**
+     * Check if lines at lineHint (1-based) match the target exactly (trimmed comparison).
+     * Returns 0-based line index or null.
+     */
+    fun exactMatch(lines: List<String>, lineHint: Int, target: List<String>): Int? {
+        val startIdx = lineHint - 1
+        if (startIdx < 0 || startIdx + target.size > lines.size) return null
+        val matches = target.indices.all { i ->
+            lines[startIdx + i].trim() == target[i].trim()
+        }
+        return if (matches) startIdx else null
+    }
+
+    /**
+     * Parse unified diff output and remap a 1-based old line number to a 0-based new line number.
+     * Returns null if the line falls within a modified hunk (can't reliably remap).
+     */
+    fun parseDiffAndRemap(diffOutput: String, oldLine: Int): Int? {
+        val hunkHeaderRegex = Regex("""^@@ -(\d+)(?:,(\d+))? \+(\d+)(?:,(\d+))? @@""")
+        var offset = 0
+
+        for (line in diffOutput.lines()) {
+            val match = hunkHeaderRegex.find(line) ?: continue
+            val oldStart = match.groupValues[1].toInt()
+            val oldCount = match.groupValues[2].ifEmpty { "1" }.toInt()
+            val newStart = match.groupValues[3].toInt()
+            val newCount = match.groupValues[4].ifEmpty { "1" }.toInt()
+
+            if (oldLine < oldStart) {
+                return oldLine - 1 + offset
+            }
+
+            val oldEnd = oldStart + oldCount - 1
+            if (oldLine in oldStart..oldEnd) {
+                return null
+            }
+
+            offset = (newStart + newCount) - (oldStart + oldCount)
+        }
+
+        return oldLine - 1 + offset
+    }
+
+    /**
+     * Sliding window fuzzy search using LCS similarity.
+     * Returns 0-based line index of the target start, or null if no match above threshold.
+     */
+    fun fuzzySearch(lines: List<String>, hunk: Hunk, threshold: Double = 0.75): Int? {
+        val searchBlock = hunk.context_before + hunk.target + hunk.context_after
+        if (searchBlock.isEmpty()) return null
+
+        val windowSize = searchBlock.size
+        if (lines.size < windowSize) return null
+
+        var bestScore = 0.0
+        var bestLine = -1
+
+        for (i in 0..lines.size - windowSize) {
+            val window = lines.subList(i, i + windowSize)
+            val score = lcsScore(
+                window.map { it.trim() },
+                searchBlock.map { it.trim() }
+            )
+            if (score > bestScore) {
+                bestScore = score
+                bestLine = i
+            }
+        }
+
+        if (bestScore >= threshold && bestLine >= 0) {
+            return bestLine + hunk.context_before.size
+        }
+        return null
+    }
+
+    /**
+     * Compute LCS-based similarity between two lists of strings.
+     * Returns a value between 0.0 and 1.0.
+     */
+    fun lcsScore(a: List<String>, b: List<String>): Double {
+        val m = a.size
+        val n = b.size
+        if (m == 0 || n == 0) return 0.0
+
+        val dp = Array(m + 1) { IntArray(n + 1) }
+        for (i in 1..m) {
+            for (j in 1..n) {
+                dp[i][j] = if (a[i - 1] == b[j - 1]) {
+                    dp[i - 1][j - 1] + 1
+                } else {
+                    maxOf(dp[i - 1][j], dp[i][j - 1])
+                }
+            }
+        }
+        return dp[m][n].toDouble() / maxOf(m, n)
+    }
+}