@mrsf/cli 0.5.0 → 0.7.0

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/dist/lib/serialize.d.ts

@@ -0,0 +1,37 @@
+/**
+ * MRSF string (de)serialization — pure, dependency-light helpers that parse and
+ * serialize MRSF sidecar content to/from strings.
+ *
+ * This module intentionally has **no Node-only imports** (no `node:fs`,
+ * `node:path`, `node:crypto`, …) so it can be consumed from browser/host
+ * adapters via the slim `@mrsf/cli/browser` entry point. Filesystem-bound
+ * helpers (read/discover/write a file) live in `parser.ts` / `writer.ts`.
+ */
+import type { MrsfDocument, Comment } from "./types.js";
+/** Result from a lenient (non-throwing) parse attempt. */
+export interface LenientParseResult {
+    /** Fully parsed document, or null if parsing failed entirely. */
+    doc: MrsfDocument | null;
+    /** If parsing failed or produced warnings, the error message. */
+    error?: string;
+    /** Comments that could be salvaged from a partially-corrupted sidecar. */
+    partialComments?: Comment[];
+}
+/**
+ * Parse MRSF sidecar content from a string.
+ * Detects JSON vs YAML based on content or optional filename hint.
+ */
+export declare function parseSidecarContent(content: string, filenameHint?: string): MrsfDocument;
+/**
+ * Lenient parse from string content.
+ */
+export declare function parseSidecarContentLenient(content: string, filenameHint?: string): LenientParseResult;
+/**
+ * Serialize an MrsfDocument to YAML (for new files / non-round-trip use).
+ */
+export declare function toYaml(doc: MrsfDocument): string;
+/**
+ * Serialize an MrsfDocument to JSON.
+ */
+export declare function toJson(doc: MrsfDocument): string;
+//# sourceMappingURL=serialize.d.ts.map

package/dist/lib/serialize.js

@@ -0,0 +1,170 @@
+/**
+ * MRSF string (de)serialization — pure, dependency-light helpers that parse and
+ * serialize MRSF sidecar content to/from strings.
+ *
+ * This module intentionally has **no Node-only imports** (no `node:fs`,
+ * `node:path`, `node:crypto`, …) so it can be consumed from browser/host
+ * adapters via the slim `@mrsf/cli/browser` entry point. Filesystem-bound
+ * helpers (read/discover/write a file) live in `parser.ts` / `writer.ts`.
+ */
+import yaml from "js-yaml";
+import { Document } from "yaml";
+// ---------------------------------------------------------------------------
+// Parsing (string → document)
+// ---------------------------------------------------------------------------
+/**
+ * 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 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,
+    };
+}
+// ---------------------------------------------------------------------------
+// Serialization (document → string)
+// ---------------------------------------------------------------------------
+/**
+ * Serialize an MrsfDocument to YAML (for new files / non-round-trip use).
+ */
+export function toYaml(doc) {
+    const yamlDoc = new Document(doc);
+    return yamlDoc.toString({ lineWidth: 0 });
+}
+/**
+ * Serialize an MrsfDocument to JSON.
+ */
+export function toJson(doc) {
+    return JSON.stringify(doc, null, 2) + "\n";
+}
+//# sourceMappingURL=serialize.js.map

package/dist/lib/types.d.ts

@@ -172,6 +172,13 @@ export interface ReanchorOptions extends BaseOptions {
     fromCommit?: string;
     /** Update selected_text to match anchored_text (opt-in per §6.2). */
     updateText?: boolean;
+    /**
+     * Proximity window (in lines) for the §7.4 step 1a relocation guard.
+     * A lone exact match farther than this from the original line, when the
+     * original position's text has changed, is kept in place and flagged for
+     * re-anchoring rather than relocated with full confidence. Default 5.
+     */
+    proximityWindow?: number;
     /** Force-anchor: update commit to HEAD and clear audit fields for high-confidence results. */
     force?: boolean;
 }

package/dist/lib/writer.d.ts

@@ -21,14 +21,7 @@ export declare function computeHash(text: string): string;
  * If selected_text is absent, removes the hash.
  */
 export declare function syncHash(comment: Comment): Comment;
-/**
- * Serialize an MrsfDocument to YAML (for new files / non-round-trip use).
- */
-export declare function toYaml(doc: MrsfDocument): string;
-/**
- * Serialize an MrsfDocument to JSON.
- */
-export declare function toJson(doc: MrsfDocument): string;
+export { toYaml, toJson } from "./serialize.js";
 /**
  * Write an MrsfDocument to disk.
  *

package/dist/lib/writer.js

@@ -14,7 +14,8 @@ import { readFile, writeFile, rename, unlink } from "node:fs/promises";
 import { existsSync } from "node:fs";
 import { createHash, randomBytes } from "node:crypto";
 import path from "node:path";
-import { Document, Parser, CST, parse as yamlParse } from "yaml";
+import { Parser, CST, parse as yamlParse } from "yaml";
+import { toYaml, toJson } from "./serialize.js";
 /* ------------------------------------------------------------------ */
 /*  Per-file write serialization                                       */
 /* ------------------------------------------------------------------ */
@@ -327,19 +328,9 @@ function deepEqual(a, b) {
 /* ------------------------------------------------------------------ */
 /*  Public API                                                         */
 /* ------------------------------------------------------------------ */
-/**
- * Serialize an MrsfDocument to YAML (for new files / non-round-trip use).
- */
-export function toYaml(doc) {
-    const yamlDoc = new Document(doc);
-    return yamlDoc.toString({ lineWidth: 0 });
-}
-/**
- * Serialize an MrsfDocument to JSON.
- */
-export function toJson(doc) {
-    return JSON.stringify(doc, null, 2) + "\n";
-}
+// `toYaml` / `toJson` now live in the Node-free serialize module; re-exported
+// here so existing `@mrsf/cli` import paths keep working.
+export { toYaml, toJson } from "./serialize.js";
 /**
  * Write an MrsfDocument to disk.
  *

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@mrsf/cli",
-  "version": "0.5.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"
   },