@mrsf/cli 0.6.0 → 0.7.0

package/dist/lib/reanchor.js

@@ -11,8 +11,12 @@
  *   Step 3  – lower-threshold fuzzy ≥ configured threshold (0.6)
  *   Step 4  – orphan
  */
-import { findRepoRoot, getCurrentCommit, getDiff, isGitAvailable, } from "./git.js";
-import { applyReanchorResults, DEFAULT_THRESHOLD, reanchorComment, reanchorDocumentLines, } from "./reanchor-core.js";
+import { findRepoRoot, getCurrentCommit, getDiff, getFileAtCommit, isGitAvailable, resolveCommit, } from "./git.js";
+import { applyReanchorResults, DEFAULT_THRESHOLD, reanchorComment, reanchorDocumentLines, toReanchorLines, } from "./reanchor-core.js";
+import { createRevisionProjection, } from "./revision-projection.js";
+import { createAnchorContextIndex, } from "./anchor-context.js";
+import { createFuzzySearchIndex, } from "./fuzzy.js";
+import { reconcileCommentAnchors } from "./global-reconciliation.js";
 import { readDocumentLines } from "./parser.js";
 import { sidecarToDocument } from "./discovery.js";
 import { parseSidecar } from "./parser.js";
@@ -32,9 +36,11 @@ export async function reanchorDocument(doc, documentLines, opts = {}) {
     const results = [];
     const threshold = opts.threshold ?? DEFAULT_THRESHOLD;
     const proximityWindow = opts.proximityWindow;
-    // Determine git context
-    let diffHunks;
-    let commitIsStale = false;
+    let fuzzySearchIndex;
+    const getFuzzySearchIndex = () => {
+        fuzzySearchIndex ??= createFuzzySearchIndex(documentLines);
+        return fuzzySearchIndex;
+    };
     if (!opts.noGit && (await isGitAvailable())) {
         const repoRoot = opts.repoRoot ?? (await findRepoRoot(opts.cwd));
         if (repoRoot && opts.documentPath) {
@@ -42,23 +48,88 @@ export async function reanchorDocument(doc, documentLines, opts = {}) {
             const head = await getCurrentCommit(repoRoot);
             // Use a shared fromCommit for all comments, or per-comment
             const globalFrom = opts.fromCommit;
+            const diffCache = new Map();
+            const projectionCache = new Map();
+            const contextCache = new Map();
+            const canonicalCommitCache = new Map();
+            const reconciliationGroups = new Map();
             for (const comment of doc.comments) {
-                const commentCommit = globalFrom ?? comment.commit;
-                if (commentCommit && head && commentCommit !== head) {
-                    commitIsStale = true;
-                    // Get diff for this commit range
-                    const hunks = await getDiff(commentCommit, head, relPath, repoRoot);
+                const rawCommentCommit = globalFrom ?? comment.commit;
+                if (rawCommentCommit && head) {
+                    const cachedCommit = canonicalCommitCache.get(rawCommentCommit);
+                    const commentCommit = cachedCommit
+                        ?? await resolveCommit(rawCommentCommit, repoRoot)
+                        ?? rawCommentCommit;
+                    if (!cachedCommit) {
+                        canonicalCommitCache.set(rawCommentCommit, commentCommit);
+                    }
+                    if (commentCommit === head) {
+                        results.push(reanchorComment(comment, documentLines, {
+                            threshold,
+                            commitIsStale: false,
+                            proximityWindow,
+                            getFuzzySearchIndex,
+                        }));
+                        continue;
+                    }
+                    let hunks = diffCache.get(commentCommit);
+                    if (!hunks) {
+                        hunks = await getDiff(commentCommit, head, relPath, repoRoot);
+                        diffCache.set(commentCommit, hunks);
+                    }
+                    let revisionProjection = projectionCache.get(commentCommit);
+                    let anchorContext = contextCache.get(commentCommit);
+                    if (!projectionCache.has(commentCommit)) {
+                        const sourceText = await getFileAtCommit(commentCommit, relPath, repoRoot);
+                        revisionProjection = sourceText == null
+                            ? undefined
+                            : createRevisionProjection(toReanchorLines(sourceText), documentLines);
+                        anchorContext = sourceText == null
+                            ? undefined
+                            : createAnchorContextIndex(toReanchorLines(sourceText), documentLines);
+                        projectionCache.set(commentCommit, revisionProjection);
+                        contextCache.set(commentCommit, anchorContext);
+                    }
                     const result = reanchorComment(comment, documentLines, {
                         diffHunks: hunks,
                         threshold,
                         commitIsStale: true,
                         proximityWindow,
+                        revisionProjection,
+                        anchorContext,
+                        getFuzzySearchIndex,
                     });
+                    const resultIndex = results.length;
                     results.push(result);
+                    if (anchorContext) {
+                        const group = reconciliationGroups.get(commentCommit);
+                        if (group) {
+                            group.comments.push(comment);
+                            group.resultIndexes.push(resultIndex);
+                        }
+                        else {
+                            reconciliationGroups.set(commentCommit, {
+                                comments: [comment],
+                                resultIndexes: [resultIndex],
+                                anchorContext,
+                            });
+                        }
+                    }
                     continue;
                 }
                 // non-stale or no commit
-                results.push(reanchorComment(comment, documentLines, { threshold, commitIsStale: false, proximityWindow }));
+                results.push(reanchorComment(comment, documentLines, {
+                    threshold,
+                    commitIsStale: false,
+                    proximityWindow,
+                    getFuzzySearchIndex,
+                }));
+            }
+            for (const group of reconciliationGroups.values()) {
+                const reconciled = reconcileCommentAnchors(group.comments, group.resultIndexes.map((index) => results[index]), group.anchorContext);
+                for (const [offset, resultIndex] of group.resultIndexes.entries()) {
+                    results[resultIndex] = reconciled[offset];
+                }
             }
             return results;
         }

package/dist/lib/revision-projection.d.ts

@@ -0,0 +1,21 @@
+import type { Comment } from "./types.js";
+export interface RevisionProjectionIndex {
+    sourceLines: string[];
+    targetLines: string[];
+    lineMap: Map<number, number>;
+}
+export interface ProjectedAnchor {
+    line: number;
+    endLine: number;
+    startColumn?: number;
+    endColumn?: number;
+    text: string;
+    score: number;
+    exact: boolean;
+    contextSupport: number;
+    contextMargin: number;
+    reason: string;
+}
+export declare function createRevisionProjection(sourceLines: string[], targetLines: string[]): RevisionProjectionIndex;
+export declare function projectCommentAnchor(comment: Comment, projection: RevisionProjectionIndex, threshold: number): ProjectedAnchor | undefined;
+//# sourceMappingURL=revision-projection.d.ts.map

package/dist/lib/revision-projection.js

@@ -0,0 +1,203 @@
+import { combinedScore, exactMatch } from "./fuzzy.js";
+const CONTEXT_RADIUS = 8;
+export function createRevisionProjection(sourceLines, targetLines) {
+    const sourceOccurrences = collectLineOccurrences(sourceLines);
+    const targetOccurrences = collectLineOccurrences(targetLines);
+    const lineMap = new Map();
+    for (const [text, sourceLineNumbers] of sourceOccurrences) {
+        const targetLineNumbers = targetOccurrences.get(text);
+        if (sourceLineNumbers.length === 1 && targetLineNumbers?.length === 1) {
+            lineMap.set(sourceLineNumbers[0], targetLineNumbers[0]);
+        }
+    }
+    return { sourceLines, targetLines, lineMap };
+}
+export function projectCommentAnchor(comment, projection, threshold) {
+    if (comment.line == null || !comment.selected_text)
+        return undefined;
+    const sourceText = extractText(projection.sourceLines, comment.line, comment.end_line, comment.start_column, comment.end_column);
+    if (sourceText !== comment.selected_text)
+        return undefined;
+    const exactCandidates = exactMatch(projection.targetLines, comment.selected_text);
+    if (exactCandidates.length === 1) {
+        const candidate = exactCandidates[0];
+        const contextSupport = countIndependentExactSupport(comment, candidate.line, projection);
+        if (contextSupport >= 2) {
+            return {
+                line: candidate.line,
+                endLine: candidate.endLine,
+                startColumn: candidate.startColumn,
+                endColumn: candidate.endColumn,
+                text: candidate.text,
+                score: 1,
+                exact: true,
+                contextSupport,
+                contextMargin: 1,
+                reason: "Source revision and neighboring line evidence confirm exact relocation.",
+            };
+        }
+    }
+    if (exactCandidates.length > 0)
+        return undefined;
+    const projected = projectLineFromContext(comment, projection);
+    if (projected == null)
+        return undefined;
+    const projectedLine = projected.line;
+    const lineSpan = (comment.end_line ?? comment.line) - comment.line;
+    const projectedEndLine = projectedLine + lineSpan;
+    if (projectedLine < 1
+        || projectedEndLine >= projection.targetLines.length) {
+        return undefined;
+    }
+    const columns = projectColumns(comment, projection, projectedLine);
+    const targetText = extractText(projection.targetLines, projectedLine, projectedEndLine, columns.startColumn, columns.endColumn);
+    if (targetText == null)
+        return undefined;
+    const score = Math.min(1, combinedScore(comment.selected_text, targetText) + 0.1);
+    if (score < threshold)
+        return undefined;
+    return {
+        line: projectedLine,
+        endLine: projectedEndLine,
+        startColumn: columns.startColumn,
+        endColumn: columns.endColumn,
+        text: targetText,
+        score,
+        exact: targetText === comment.selected_text,
+        contextSupport: projected.support,
+        contextMargin: projected.margin,
+        reason: "Source revision context projects the edited anchor range.",
+    };
+}
+function collectLineOccurrences(lines) {
+    const occurrences = new Map();
+    for (let line = 1; line < lines.length; line += 1) {
+        const text = lines[line];
+        if (!text.trim())
+            continue;
+        const existing = occurrences.get(text);
+        if (existing) {
+            existing.push(line);
+        }
+        else {
+            occurrences.set(text, [line]);
+        }
+    }
+    return occurrences;
+}
+function countIndependentExactSupport(comment, candidateLine, projection) {
+    const sourceEndLine = comment.end_line ?? comment.line;
+    const expectedShift = candidateLine - comment.line;
+    if (comment.start_column != null
+        || comment.end_column != null) {
+        const mappedContainerLine = projection.lineMap.get(comment.line);
+        if (mappedContainerLine === candidateLine)
+            return 2;
+    }
+    let support = 0;
+    for (let distance = 1; distance <= CONTEXT_RADIUS; distance += 1) {
+        for (const sourceLine of [
+            comment.line - distance,
+            sourceEndLine + distance,
+        ]) {
+            if (sourceLine < 1 || sourceLine >= projection.sourceLines.length) {
+                continue;
+            }
+            const targetLine = projection.lineMap.get(sourceLine);
+            if (targetLine != null && targetLine - sourceLine === expectedShift) {
+                support += 1;
+            }
+        }
+    }
+    return support;
+}
+function projectLineFromContext(comment, projection) {
+    const sourceLine = comment.line;
+    const sourceEndLine = comment.end_line ?? sourceLine;
+    const votes = new Map();
+    for (let distance = 1; distance <= CONTEXT_RADIUS; distance += 1) {
+        for (const contextLine of [
+            sourceLine - distance,
+            sourceEndLine + distance,
+        ]) {
+            if (contextLine < 1 || contextLine >= projection.sourceLines.length) {
+                continue;
+            }
+            const targetLine = projection.lineMap.get(contextLine);
+            if (targetLine == null)
+                continue;
+            const shift = targetLine - contextLine;
+            const vote = votes.get(shift);
+            if (vote) {
+                vote.count += 1;
+                vote.nearest = Math.min(vote.nearest, distance);
+            }
+            else {
+                votes.set(shift, { count: 1, nearest: distance });
+            }
+        }
+    }
+    const ranked = [...votes.entries()].sort((left, right) => right[1].count - left[1].count
+        || left[1].nearest - right[1].nearest
+        || Math.abs(left[0]) - Math.abs(right[0]));
+    const best = ranked[0];
+    if (!best)
+        return undefined;
+    if (best[1].count < 2 && best[1].nearest > 3)
+        return undefined;
+    if (ranked[1]
+        && ranked[1][1].count === best[1].count
+        && ranked[1][1].nearest === best[1].nearest) {
+        return undefined;
+    }
+    const runnerUpCount = ranked[1]?.[1].count ?? 0;
+    return {
+        line: sourceLine + best[0],
+        support: best[1].count,
+        margin: (best[1].count - runnerUpCount) / best[1].count,
+    };
+}
+function projectColumns(comment, projection, targetLine) {
+    if (comment.line == null
+        || (comment.end_line != null && comment.end_line !== comment.line)
+        || comment.start_column == null
+        || comment.end_column == null) {
+        return {
+            startColumn: comment.start_column,
+            endColumn: comment.end_column,
+        };
+    }
+    const sourceLine = projection.sourceLines[comment.line];
+    const targetLineText = projection.targetLines[targetLine];
+    const prefix = sourceLine.slice(0, comment.start_column);
+    const suffix = sourceLine.slice(comment.end_column);
+    const startColumn = targetLineText.startsWith(prefix)
+        ? prefix.length
+        : Math.min(comment.start_column, targetLineText.length);
+    const endColumn = targetLineText.endsWith(suffix)
+        ? targetLineText.length - suffix.length
+        : Math.min(targetLineText.length, startColumn + (comment.end_column - comment.start_column));
+    return { startColumn, endColumn };
+}
+function extractText(lines, line, endLine, startColumn, endColumn) {
+    const finalLine = endLine ?? line;
+    if (line < 1 || finalLine >= lines.length)
+        return null;
+    if (line === finalLine) {
+        const text = lines[line];
+        return startColumn != null && endColumn != null
+            ? text.slice(startColumn, endColumn)
+            : text;
+    }
+    const result = [];
+    for (let current = line; current <= finalLine; current += 1) {
+        let text = lines[current];
+        if (current === line && startColumn != null)
+            text = text.slice(startColumn);
+        if (current === finalLine && endColumn != null)
+            text = text.slice(0, endColumn);
+        result.push(text);
+    }
+    return result.join("\n");
+}
+//# sourceMappingURL=revision-projection.js.map

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@mrsf/cli",
-  "version": "0.6.0",
+  "version": "0.7.0",
   "description": "CLI and library for the Markdown Review Sidecar Format (MRSF)",
   "type": "module",
   "main": "./dist/index.js",
@@ -30,6 +30,10 @@
     "test": "vitest run",
     "test:watch": "vitest",
     "lint": "tsc --noEmit",
+    "eval:reanchor": "tsc && node dist/evaluation/run-reanchor-eval.js",
+    "eval:reanchor:baseline": "tsc && node dist/evaluation/run-reanchor-eval.js --baseline ../evaluation/reanchor/baseline.json",
+    "eval:reanchor:generate": "tsc && node dist/evaluation/run-reanchor-generator.js",
+    "eval:reanchor:profile": "tsc && node dist/evaluation/run-reanchor-profile.js",
     "prepublishOnly": "cp ../LICENSE . && npm run build && npm test",
     "postpublish": "rm -f LICENSE"
   },