@mrsf/cli 0.5.0 → 0.7.0

package/dist/lib/parser.js

@@ -3,7 +3,10 @@
  */
 import { readFile } from "node:fs/promises";
 import path from "node:path";
-import yaml from "js-yaml";
+import { parseSidecarContent, parseSidecarContentLenient, } from "./serialize.js";
+// Re-exported from the Node-free serialize module so existing
+// `@mrsf/cli` import paths keep working.
+export { parseSidecarContent, parseSidecarContentLenient, } from "./serialize.js";
 /**
  * Parse an MRSF sidecar file from disk.
  */
@@ -12,37 +15,6 @@ export async function parseSidecar(filePath) {
     const content = await readFile(abs, "utf-8");
     return parseSidecarContent(content, abs);
 }
-/**
- * Parse MRSF sidecar content from a string.
- * Detects JSON vs YAML based on content or optional filename hint.
- */
-export function parseSidecarContent(content, filenameHint) {
-    const trimmed = content.trim();
-    let parsed;
-    // Detect JSON by content or filename
-    const isJson = trimmed.startsWith("{") ||
-        (filenameHint && filenameHint.endsWith(".review.json"));
-    if (isJson) {
-        try {
-            parsed = JSON.parse(trimmed);
-        }
-        catch (e) {
-            throw new Error(`Failed to parse JSON: ${e.message}`);
-        }
-    }
-    else {
-        try {
-            parsed = yaml.load(trimmed, { schema: yaml.JSON_SCHEMA });
-        }
-        catch (e) {
-            throw new Error(`Failed to parse YAML: ${e.message}`);
-        }
-    }
-    if (!parsed || typeof parsed !== "object" || Array.isArray(parsed)) {
-        throw new Error("MRSF sidecar must be a YAML/JSON object");
-    }
-    return parsed;
-}
 /**
  * Lenient parse: attempts to parse a sidecar file from disk without
  * throwing.  On complete failure, returns `{ doc: null, error }`.
@@ -61,114 +33,6 @@ export async function parseSidecarLenient(filePath) {
     }
     return parseSidecarContentLenient(content, abs);
 }
-/**
- * Lenient parse from string content.
- */
-export function parseSidecarContentLenient(content, filenameHint) {
-    const trimmed = content.trim();
-    if (!trimmed) {
-        return { doc: null, error: "File is empty" };
-    }
-    const isJson = trimmed.startsWith("{") ||
-        (filenameHint && filenameHint.endsWith(".review.json"));
-    // First, try a normal parse
-    let parsed;
-    try {
-        parsed = isJson ? JSON.parse(trimmed) : yaml.load(trimmed, { schema: yaml.JSON_SCHEMA });
-    }
-    catch (e) {
-        // Total parse failure — try to salvage what we can from YAML
-        if (!isJson) {
-            return salvageYaml(trimmed);
-        }
-        return { doc: null, error: `Failed to parse JSON: ${e.message}` };
-    }
-    if (!parsed || typeof parsed !== "object" || Array.isArray(parsed)) {
-        return { doc: null, error: "MRSF sidecar must be a YAML/JSON object" };
-    }
-    const obj = parsed;
-    const doc = {
-        mrsf_version: typeof obj.mrsf_version === "string" ? obj.mrsf_version : "1.0",
-        document: typeof obj.document === "string" ? obj.document : "unknown",
-        comments: [],
-    };
-    if (!Array.isArray(obj.comments)) {
-        return {
-            doc,
-            error: "comments field is not an array — file may be corrupted",
-        };
-    }
-    // Validate each comment individually
-    const good = [];
-    const bad = [];
-    for (let i = 0; i < obj.comments.length; i++) {
-        const c = obj.comments[i];
-        if (c && typeof c === "object" && !Array.isArray(c) && typeof c.id === "string") {
-            good.push(c);
-        }
-        else {
-            bad.push(i);
-        }
-    }
-    doc.comments = good;
-    if (bad.length > 0) {
-        return {
-            doc,
-            error: `${bad.length} comment(s) at indices [${bad.join(", ")}] were malformed and skipped`,
-            partialComments: good,
-        };
-    }
-    return { doc };
-}
-/**
- * Attempt to extract individual comment blocks from corrupted YAML by
- * splitting on `- id:` patterns and parsing each block independently.
- */
-function salvageYaml(content) {
-    const salvaged = [];
-    let mrsf_version = "1.0";
-    let document = "unknown";
-    // Try to extract top-level fields from the beginning
-    const versionMatch = content.match(/^mrsf_version:\s*["']?([^"'\n]+)/m);
-    if (versionMatch)
-        mrsf_version = versionMatch[1].trim();
-    const docMatch = content.match(/^document:\s*["']?([^"'\n]+)/m);
-    if (docMatch)
-        document = docMatch[1].trim();
-    // Split on comment block boundaries (- id: ...)
-    const blocks = content.split(/(?=^  - id:\s)/m);
-    for (const block of blocks) {
-        const trimmed = block.trim();
-        if (!trimmed.startsWith("- id:"))
-            continue;
-        // Wrap in a minimal YAML array context and try to parse
-        try {
-            const parsed = yaml.load(trimmed, { schema: yaml.JSON_SCHEMA });
-            if (Array.isArray(parsed) && parsed.length > 0) {
-                const c = parsed[0];
-                if (c && typeof c === "object" && typeof c.id === "string") {
-                    salvaged.push(c);
-                }
-            }
-            else if (parsed && typeof parsed === "object" && typeof parsed.id === "string") {
-                salvaged.push(parsed);
-            }
-        }
-        catch {
-            // This block is unparseable — skip
-        }
-    }
-    const doc = {
-        mrsf_version,
-        document,
-        comments: salvaged,
-    };
-    return {
-        doc: salvaged.length > 0 ? doc : null,
-        error: `YAML parse failed. Salvaged ${salvaged.length} comment(s) from raw content.`,
-        partialComments: salvaged.length > 0 ? salvaged : undefined,
-    };
-}
 /**
  * Read a Markdown document from disk and return its lines.
  * Lines are 1-indexed in the returned array (index 0 is unused).

package/dist/lib/reanchor-core.d.ts

@@ -1,20 +1,40 @@
 import type { AnchorPosition, Comment, DiffHunk, MrsfDocument, ReanchorResult } from "./types.js";
+import { type FuzzySearchIndex } from "./fuzzy.js";
+import { type RevisionProjectionIndex } from "./revision-projection.js";
+import { type AnchorContextIndex } from "./anchor-context.js";
 export declare const HIGH_THRESHOLD = 0.8;
 export declare const DEFAULT_THRESHOLD = 0.6;
+/**
+ * Default proximity window (in lines) for the §7.4 step 1a relocation guard.
+ *
+ * A lone exact match of `selected_text` that lands farther than this many
+ * lines from the comment's original `line` — while the text at the original
+ * position has changed — is treated as an in-place edit rather than a
+ * confident relocation. See {@link isImplausibleExactRelocation}.
+ */
+export declare const DEFAULT_PROXIMITY_WINDOW = 5;
 export declare function toReanchorLines(documentText: string): string[];
 export declare function reanchorComment(comment: Comment, documentLines: string[], opts?: {
     diffHunks?: DiffHunk[];
     threshold?: number;
     commitIsStale?: boolean;
+    proximityWindow?: number;
+    revisionProjection?: RevisionProjectionIndex;
+    anchorContext?: AnchorContextIndex;
+    fuzzySearchIndex?: FuzzySearchIndex;
+    getFuzzySearchIndex?: () => FuzzySearchIndex;
 }): ReanchorResult;
 export declare function reanchorDocumentLines(doc: MrsfDocument, documentLines: string[], opts?: {
     threshold?: number;
+    proximityWindow?: number;
 }): ReanchorResult[];
 export declare function reanchorDocumentText(doc: MrsfDocument, documentText: string, opts?: {
     threshold?: number;
+    proximityWindow?: number;
 }): ReanchorResult[];
 export declare function resolveAnchor(comment: Comment, documentText: string, opts?: {
     threshold?: number;
+    proximityWindow?: number;
 }): AnchorPosition;
 export declare function applyReanchorResults(doc: MrsfDocument, results: ReanchorResult[], opts?: {
     updateText?: boolean;

package/dist/lib/reanchor-core.js

@@ -1,13 +1,33 @@
-import { exactMatch, fuzzySearch, normalizedMatch, } from "./fuzzy.js";
+import { createFuzzySearchIndex, exactMatch, fuzzySearch, fuzzySearchThresholds, normalizedMatch, } from "./fuzzy.js";
+import { projectCommentAnchor, } from "./revision-projection.js";
+import { resolveContextAnchor, } from "./anchor-context.js";
+import { calibrateAnchorEvidence } from "./confidence-calibration.js";
 export const HIGH_THRESHOLD = 0.8;
 export const DEFAULT_THRESHOLD = 0.6;
+/**
+ * Default proximity window (in lines) for the §7.4 step 1a relocation guard.
+ *
+ * A lone exact match of `selected_text` that lands farther than this many
+ * lines from the comment's original `line` — while the text at the original
+ * position has changed — is treated as an in-place edit rather than a
+ * confident relocation. See {@link isImplausibleExactRelocation}.
+ */
+export const DEFAULT_PROXIMITY_WINDOW = 5;
 export function toReanchorLines(documentText) {
     return ["", ...documentText.replace(/\r\n/g, "\n").split("\n")];
 }
 export function reanchorComment(comment, documentLines, opts = {}) {
     const threshold = opts.threshold ?? DEFAULT_THRESHOLD;
+    const proximityWindow = opts.proximityWindow ?? DEFAULT_PROXIMITY_WINDOW;
     const commentId = comment.id;
     const selectedText = comment.selected_text;
+    let fuzzyCandidateSets;
+    let fuzzySearchIndex = opts.fuzzySearchIndex;
+    const getFuzzySearchIndex = () => {
+        fuzzySearchIndex ??= opts.getFuzzySearchIndex?.()
+            ?? createFuzzySearchIndex(documentLines);
+        return fuzzySearchIndex;
+    };
     if (!selectedText && comment.line == null) {
         return {
             commentId,
@@ -52,32 +72,78 @@ export function reanchorComment(comment, documentLines, opts = {}) {
             }
         }
     }
+    const projected = selectedText && opts.revisionProjection
+        ? projectCommentAnchor(comment, opts.revisionProjection, threshold)
+        : undefined;
+    if (selectedText && projected?.exact) {
+        const exactCalibration = calibrateAnchorEvidence(commentId, selectedText, projected);
+        if (exactCalibration)
+            return exactCalibration.result;
+    }
+    const contextual = selectedText && opts.anchorContext
+        ? resolveContextAnchor(comment, opts.anchorContext)
+        : undefined;
+    if (selectedText && (projected || contextual)) {
+        const calibrated = calibrateAnchorEvidence(commentId, selectedText, projected, contextual);
+        if (calibrated)
+            return calibrated.result;
+    }
     if (selectedText) {
         const exactCandidates = exactMatch(documentLines, selectedText);
-        if (exactCandidates.length === 1) {
-            const candidate = exactCandidates[0];
+        if (exactCandidates.length > 1 && comment.line == null) {
             return {
                 commentId,
-                status: "anchored",
-                score: 1.0,
-                newLine: candidate.line,
-                newEndLine: candidate.endLine,
-                newStartColumn: candidate.startColumn,
-                newEndColumn: candidate.endColumn,
-                reason: "Exact text match (unique).",
+                status: "ambiguous",
+                score: 1,
+                reason: `Ambiguous: ${exactCandidates.length} exact matches and no position `
+                    + "or source context to disambiguate them.",
             };
         }
-        if (exactCandidates.length > 1 && comment.line != null) {
-            const best = closestToLine(exactCandidates, comment.line);
+        // Pick the best exact candidate: the only one, or — when several remain —
+        // the one nearest to the original line (§7.4 step 1b).
+        let chosen;
+        let chosenReason = "";
+        if (exactCandidates.length === 1) {
+            chosen = exactCandidates[0];
+            chosenReason = "Exact text match (unique).";
+        }
+        else if (exactCandidates.length > 1 && comment.line != null) {
+            chosen = closestToLine(exactCandidates, comment.line);
+            chosenReason = `Exact text match (${exactCandidates.length} occurrences; chose nearest to original line ${comment.line}).`;
+        }
+        if (chosen) {
+            // §7.4 step 1a proximity guard: a lone/closest exact match that lands far
+            // from the original position — while the text at the original position no
+            // longer equals selected_text — most likely indicates an in-place edit of
+            // the anchored text, not a genuine relocation. Keep the comment at its
+            // original position and flag it for re-anchoring instead of teleporting it
+            // onto an unrelated identical token with full confidence.
+            if (isImplausibleExactRelocation(comment, chosen, documentLines, proximityWindow)) {
+                const textAtOrigin = extractText(documentLines, comment.line, comment.end_line, comment.start_column, comment.end_column);
+                return {
+                    commentId,
+                    status: "fuzzy",
+                    score: 0.5,
+                    newLine: comment.line,
+                    newEndLine: comment.end_line,
+                    newStartColumn: comment.start_column,
+                    newEndColumn: comment.end_column,
+                    anchoredText: textAtOrigin ?? undefined,
+                    previousSelectedText: selectedText,
+                    reason: `Lone exact match at line ${chosen.line} is beyond the proximity window ` +
+                        `(±${proximityWindow}) of original line ${comment.line} and the text at the ` +
+                        `original position changed; kept at original position, needs re-anchoring.`,
+                };
+            }
             return {
                 commentId,
                 status: "anchored",
                 score: 1.0,
-                newLine: best.line,
-                newEndLine: best.endLine,
-                newStartColumn: best.startColumn,
-                newEndColumn: best.endColumn,
-                reason: `Exact text match (${exactCandidates.length} occurrences; chose nearest to original line ${comment.line}).`,
+                newLine: chosen.line,
+                newEndLine: chosen.endLine,
+                newStartColumn: chosen.startColumn,
+                newEndColumn: chosen.endColumn,
+                reason: chosenReason,
             };
         }
         const normCandidates = normalizedMatch(documentLines, selectedText);
@@ -96,7 +162,8 @@ export function reanchorComment(comment, documentLines, opts = {}) {
                 reason: "Normalized whitespace match.",
             };
         }
-        const fuzzyCandidates = fuzzySearch(documentLines, selectedText, HIGH_THRESHOLD, comment.line);
+        fuzzyCandidateSets = fuzzySearchThresholds(documentLines, selectedText, [HIGH_THRESHOLD, threshold], comment.line, getFuzzySearchIndex());
+        const fuzzyCandidates = fuzzyCandidateSets.get(HIGH_THRESHOLD) ?? [];
         if (fuzzyCandidates.length === 1 || (fuzzyCandidates.length > 0 && fuzzyCandidates[0].score >= HIGH_THRESHOLD)) {
             const best = fuzzyCandidates.length === 1
                 ? fuzzyCandidates[0]
@@ -151,7 +218,8 @@ export function reanchorComment(comment, documentLines, opts = {}) {
         }
     }
     if (selectedText) {
-        const lowCandidates = fuzzySearch(documentLines, selectedText, threshold, comment.line);
+        const lowCandidates = fuzzyCandidateSets?.get(threshold)
+            ?? fuzzySearch(documentLines, selectedText, threshold, comment.line, getFuzzySearchIndex());
         if (lowCandidates.length === 1) {
             const candidate = lowCandidates[0];
             return {
@@ -187,7 +255,12 @@ export function reanchorComment(comment, documentLines, opts = {}) {
     };
 }
 export function reanchorDocumentLines(doc, documentLines, opts = {}) {
-    return doc.comments.map((comment) => reanchorComment(comment, documentLines, opts));
+    let fuzzySearchIndex;
+    const getFuzzySearchIndex = () => {
+        fuzzySearchIndex ??= createFuzzySearchIndex(documentLines);
+        return fuzzySearchIndex;
+    };
+    return doc.comments.map((comment) => reanchorComment(comment, documentLines, { ...opts, getFuzzySearchIndex }));
 }
 export function reanchorDocumentText(doc, documentText, opts = {}) {
     return reanchorDocumentLines(doc, toReanchorLines(documentText), opts);
@@ -342,6 +415,36 @@ function extractText(lines, line, endLine, startColumn, endColumn) {
 function closestToLine(candidates, targetLine) {
     return candidates.reduce((best, candidate) => Math.abs(candidate.line - targetLine) < Math.abs(best.line - targetLine) ? candidate : best);
 }
+/**
+ * §7.4 step 1a relocation guard.
+ *
+ * Returns true when a chosen exact-match candidate is an *implausible*
+ * full-confidence relocation: the original `line` still exists in the document,
+ * the candidate is farther than `proximityWindow` lines away, and the text now
+ * at the original position no longer equals `selected_text`. This is the
+ * signature of an in-place edit of the anchored text (which removed the
+ * original occurrence) rather than a genuine move of the selection.
+ *
+ * When the original line no longer exists (the document shrank or the section
+ * was removed) or no positional anchor is available, relocation is treated as a
+ * legitimate §7.4 step 3 contextual re-anchor and this returns false.
+ */
+function isImplausibleExactRelocation(comment, candidate, lines, proximityWindow) {
+    if (comment.line == null)
+        return false;
+    // Original position must still exist to be a viable fallback anchor.
+    if (comment.line <= 0 || comment.line >= lines.length)
+        return false;
+    // A nearby match is plausibly the same (or an adjacent) edit region.
+    if (Math.abs(candidate.line - comment.line) <= proximityWindow)
+        return false;
+    // If the text at the original position still equals selected_text, the
+    // original occurrence is intact and relocation is not a teleport.
+    const textAtOrigin = extractText(lines, comment.line, comment.end_line, comment.start_column, comment.end_column);
+    if (textAtOrigin === comment.selected_text)
+        return false;
+    return true;
+}
 function getLineShift(diffHunks, line) {
     let shift = 0;
     let modified = false;

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";
@@ -31,9 +35,12 @@ export { applyReanchorResults, DEFAULT_THRESHOLD, HIGH_THRESHOLD, reanchorCommen
 export async function reanchorDocument(doc, documentLines, opts = {}) {
     const results = [];
     const threshold = opts.threshold ?? DEFAULT_THRESHOLD;
-    // Determine git context
-    let diffHunks;
-    let commitIsStale = false;
+    const proximityWindow = opts.proximityWindow;
+    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) {
@@ -41,27 +48,93 @@ 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 }));
+                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;
         }
     }
-    return reanchorDocumentLines(doc, documentLines, { threshold });
+    return reanchorDocumentLines(doc, documentLines, { threshold, proximityWindow });
 }
 /**
  * High-level re-anchor for a single sidecar file path.

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