@mrsf/cli 0.4.0 → 0.4.2

package/README.md

@@ -384,6 +384,26 @@ const updated = addComment(doc, lines, {
 await writeSidecar("docs/api.md.review.yaml", updated);
 ```
 
+### Browser-safe reanchoring
+
+The default `@mrsf/cli` entrypoint is Node-oriented and includes file system and git-backed helpers such as `parseSidecar`, `readDocumentLines`, and `reanchorFile`. For browser bundles and editor integrations, use the `@mrsf/cli/browser` subpath instead.
+
+`@mrsf/cli/browser` exports the pure text-based matching and reanchoring primitives only:
+
+```typescript
+import {
+  applyReanchorResults,
+  reanchorDocumentText,
+} from "@mrsf/cli/browser";
+
+const results = reanchorDocumentText(sidecar, markdownText);
+const changed = applyReanchorResults(sidecar, results);
+
+console.log(changed, results.map((result) => result.status));
+```
+
+Use this entrypoint when you already have the document text and sidecar object in memory. It intentionally excludes Node-only helpers such as sidecar discovery, file parsing, file writing, and git-aware diff reanchoring.
+
 ## Configuration
 
 Place a `.mrsf.yaml` at your repository root to configure sidecar discovery:

package/dist/browser.d.ts

@@ -0,0 +1,17 @@
+import * as fuzzy from "./lib/fuzzy.js";
+import * as reanchorCore from "./lib/reanchor-core.js";
+export type { Comment, DiffHunk, FuzzyCandidate, MrsfDocument, ReanchorResult, ReanchorStatus, } from "./lib/types.js";
+export declare const combinedScore: typeof fuzzy.combinedScore;
+export declare const exactMatch: typeof fuzzy.exactMatch;
+export declare const fuzzySearch: typeof fuzzy.fuzzySearch;
+export declare const levenshteinScore: typeof fuzzy.levenshteinScore;
+export declare const normalizedMatch: typeof fuzzy.normalizedMatch;
+export declare const tokenLcsScore: typeof fuzzy.tokenLcsScore;
+export declare const applyReanchorResults: typeof reanchorCore.applyReanchorResults;
+export declare const DEFAULT_THRESHOLD = 0.6;
+export declare const HIGH_THRESHOLD = 0.8;
+export declare const reanchorComment: typeof reanchorCore.reanchorComment;
+export declare const reanchorDocumentLines: typeof reanchorCore.reanchorDocumentLines;
+export declare const reanchorDocumentText: typeof reanchorCore.reanchorDocumentText;
+export declare const toReanchorLines: typeof reanchorCore.toReanchorLines;
+//# sourceMappingURL=browser.d.ts.map

package/dist/browser.js

@@ -0,0 +1,16 @@
+import * as fuzzy from "./lib/fuzzy.js";
+import * as reanchorCore from "./lib/reanchor-core.js";
+export const combinedScore = fuzzy.combinedScore;
+export const exactMatch = fuzzy.exactMatch;
+export const fuzzySearch = fuzzy.fuzzySearch;
+export const levenshteinScore = fuzzy.levenshteinScore;
+export const normalizedMatch = fuzzy.normalizedMatch;
+export const tokenLcsScore = fuzzy.tokenLcsScore;
+export const applyReanchorResults = reanchorCore.applyReanchorResults;
+export const DEFAULT_THRESHOLD = reanchorCore.DEFAULT_THRESHOLD;
+export const HIGH_THRESHOLD = reanchorCore.HIGH_THRESHOLD;
+export const reanchorComment = reanchorCore.reanchorComment;
+export const reanchorDocumentLines = reanchorCore.reanchorDocumentLines;
+export const reanchorDocumentText = reanchorCore.reanchorDocumentText;
+export const toReanchorLines = reanchorCore.toReanchorLines;
+//# sourceMappingURL=browser.js.map

package/dist/commands/init.js

@@ -28,17 +28,19 @@ export function registerInit(program) {
         const root = await findWorkspaceRoot(cwd);
         const sidecarPath = await discoverSidecar(docPath, { cwd: root ?? cwd });
         // Check if sidecar already exists
+        let sidecarExists = false;
         try {
             await fs.access(sidecarPath);
-            if (!opts.force) {
-                console.error(chalk.yellow(`Sidecar already exists: ${sidecarPath}`));
-                console.error("Use --force to overwrite.");
-                process.exit(1);
-            }
+            sidecarExists = true;
         }
         catch {
             // Good — doesn't exist yet
         }
+        if (sidecarExists && !opts.force) {
+            console.error(chalk.yellow(`Sidecar already exists: ${sidecarPath}`));
+            console.error("Use --force to overwrite.");
+            process.exit(1);
+        }
         const doc = {
             mrsf_version: "1.0",
             document: path.basename(docPath),

package/dist/commands/watch.js

@@ -253,6 +253,7 @@ export function registerWatch(program) {
         }
         // ── Graceful shutdown ────────────────────────────────
         async function shutdown() {
+            cleanupSignalHandlers();
             // Clear pending debounce timers
             for (const t of timers.values())
                 clearTimeout(t);
@@ -266,8 +267,19 @@ export function registerWatch(program) {
             }
             process.exit(totalErrors > 0 ? 1 : 0);
         }
-        process.on("SIGINT", () => void shutdown());
-        process.on("SIGTERM", () => void shutdown());
+        const onSigint = () => {
+            void shutdown();
+        };
+        const onSigterm = () => {
+            void shutdown();
+        };
+        function cleanupSignalHandlers() {
+            process.off("SIGINT", onSigint);
+            process.off("SIGTERM", onSigterm);
+        }
+        process.on("SIGINT", onSigint);
+        process.on("SIGTERM", onSigterm);
+        watcher.once("close", cleanupSignalHandlers);
         // Keep the process alive
         await new Promise(() => {
             // Never resolves — the process runs until interrupted

package/dist/index.d.ts

@@ -4,16 +4,67 @@
  * Usage:
  *   import { validate, reanchorFile, addComment, ... } from "mrsf";
  */
-export type { MrsfDocument, Comment, CommentExtensions, CommentExtensionValue, MrsfConfig, DiagnosticSeverity, ValidationDiagnostic, ValidationResult, ReanchorStatus, ReanchorResult, FuzzyCandidate, DiffHunk, AddCommentOptions, CommentFilter, AnchorHealth, StatusResult, BaseOptions, ReanchorOptions, ValidateOptions, } from "./lib/types.js";
-export { findWorkspaceRoot, loadConfig, discoverSidecar, sidecarToDocument, discoverAllSidecars, } from "./lib/discovery.js";
-export { resolveSidecarPaths } from "./lib/resolve-files.js";
-export { parseSidecar, parseSidecarContent, parseSidecarLenient, parseSidecarContentLenient, readDocumentLines, } from "./lib/parser.js";
+import * as discovery from "./lib/discovery.js";
+import * as resolveFiles from "./lib/resolve-files.js";
+import * as parser from "./lib/parser.js";
+import * as writer from "./lib/writer.js";
+import * as validator from "./lib/validator.js";
+import * as fuzzy from "./lib/fuzzy.js";
+import * as git from "./lib/git.js";
+import * as reanchor from "./lib/reanchor.js";
+import * as comments from "./lib/comments.js";
+export type { MrsfDocument, Comment, CommentExtensions, CommentExtensionValue, MrsfConfig, DiagnosticSeverity, ValidationDiagnostic, ValidationResult, ReanchorStatus, ReanchorResult, FuzzyCandidate, DiffHunk, AddCommentOptions, EditCommentOptions, CommentFilter, AnchorHealth, StatusResult, BaseOptions, ReanchorOptions, ValidateOptions, } from "./lib/types.js";
+export declare const findWorkspaceRoot: typeof discovery.findWorkspaceRoot;
+export declare const loadConfig: typeof discovery.loadConfig;
+export declare const discoverSidecar: typeof discovery.discoverSidecar;
+export declare const sidecarToDocument: typeof discovery.sidecarToDocument;
+export declare const discoverAllSidecars: typeof discovery.discoverAllSidecars;
+export declare const resolveSidecarPaths: typeof resolveFiles.resolveSidecarPaths;
+export declare const parseSidecar: typeof parser.parseSidecar;
+export declare const parseSidecarContent: typeof parser.parseSidecarContent;
+export declare const parseSidecarLenient: typeof parser.parseSidecarLenient;
+export declare const parseSidecarContentLenient: typeof parser.parseSidecarContentLenient;
+export declare const readDocumentLines: typeof parser.readDocumentLines;
 export type { LenientParseResult } from "./lib/parser.js";
-export { computeHash, syncHash, toYaml, toJson, writeSidecar, } from "./lib/writer.js";
-export { validate, validateFile } from "./lib/validator.js";
-export { exactMatch, normalizedMatch, fuzzySearch, combinedScore, } from "./lib/fuzzy.js";
-export { isGitAvailable, findRepoRoot, getCurrentCommit, isStale, getDiff, getLineShift, getFileAtCommit, getStagedFiles, detectRenames, parseDiffHunks, } from "./lib/git.js";
-export { reanchorComment, reanchorDocument, applyReanchorResults, reanchorFile, } from "./lib/reanchor.js";
-export { addComment, normalizeCommentExtensions, populateSelectedText, resolveComment, unresolveComment, removeComment, filterComments, getThreads, summarize, } from "./lib/comments.js";
+export declare const computeHash: typeof writer.computeHash;
+export declare const syncHash: typeof writer.syncHash;
+export declare const toYaml: typeof writer.toYaml;
+export declare const toJson: typeof writer.toJson;
+export declare const writeSidecar: typeof writer.writeSidecar;
+export declare const validate: typeof validator.validate;
+export declare const validateFile: typeof validator.validateFile;
+export declare const exactMatch: typeof fuzzy.exactMatch;
+export declare const normalizedMatch: typeof fuzzy.normalizedMatch;
+export declare const fuzzySearch: typeof fuzzy.fuzzySearch;
+export declare const combinedScore: typeof fuzzy.combinedScore;
+export declare const isGitAvailable: typeof git.isGitAvailable;
+export declare const findRepoRoot: typeof git.findRepoRoot;
+export declare const getCurrentCommit: typeof git.getCurrentCommit;
+export declare const isStale: typeof git.isStale;
+export declare const getDiff: typeof git.getDiff;
+export declare const getLineShift: typeof git.getLineShift;
+export declare const getFileAtCommit: typeof git.getFileAtCommit;
+export declare const getStagedFiles: typeof git.getStagedFiles;
+export declare const detectRenames: typeof git.detectRenames;
+export declare const parseDiffHunks: typeof git.parseDiffHunks;
+export declare const DEFAULT_THRESHOLD = 0.6;
+export declare const HIGH_THRESHOLD = 0.8;
+export declare const reanchorComment: typeof reanchor.reanchorComment;
+export declare const reanchorDocumentLines: typeof reanchor.reanchorDocumentLines;
+export declare const reanchorDocumentText: typeof reanchor.reanchorDocumentText;
+export declare const toReanchorLines: typeof reanchor.toReanchorLines;
+export declare const reanchorDocument: typeof reanchor.reanchorDocument;
+export declare const applyReanchorResults: typeof reanchor.applyReanchorResults;
+export declare const reanchorFile: typeof reanchor.reanchorFile;
+export declare const addComment: typeof comments.addComment;
+export declare const editComment: typeof comments.editComment;
+export declare const normalizeCommentExtensions: typeof comments.normalizeCommentExtensions;
+export declare const populateSelectedText: typeof comments.populateSelectedText;
+export declare const resolveComment: typeof comments.resolveComment;
+export declare const unresolveComment: typeof comments.unresolveComment;
+export declare const removeComment: typeof comments.removeComment;
+export declare const filterComments: typeof comments.filterComments;
+export declare const getThreads: typeof comments.getThreads;
+export declare const summarize: typeof comments.summarize;
 export type { CommentSummary, RemoveCommentOptions } from "./lib/comments.js";
 //# sourceMappingURL=index.d.ts.map

package/dist/index.js

@@ -4,22 +4,73 @@
  * Usage:
  *   import { validate, reanchorFile, addComment, ... } from "mrsf";
  */
+import * as discovery from "./lib/discovery.js";
+import * as resolveFiles from "./lib/resolve-files.js";
+import * as parser from "./lib/parser.js";
+import * as writer from "./lib/writer.js";
+import * as validator from "./lib/validator.js";
+import * as fuzzy from "./lib/fuzzy.js";
+import * as git from "./lib/git.js";
+import * as reanchor from "./lib/reanchor.js";
+import * as comments from "./lib/comments.js";
 // Discovery
-export { findWorkspaceRoot, loadConfig, discoverSidecar, sidecarToDocument, discoverAllSidecars, } from "./lib/discovery.js";
+export const findWorkspaceRoot = discovery.findWorkspaceRoot;
+export const loadConfig = discovery.loadConfig;
+export const discoverSidecar = discovery.discoverSidecar;
+export const sidecarToDocument = discovery.sidecarToDocument;
+export const discoverAllSidecars = discovery.discoverAllSidecars;
 // File resolution
-export { resolveSidecarPaths } from "./lib/resolve-files.js";
+export const resolveSidecarPaths = resolveFiles.resolveSidecarPaths;
 // Parsing
-export { parseSidecar, parseSidecarContent, parseSidecarLenient, parseSidecarContentLenient, readDocumentLines, } from "./lib/parser.js";
+export const parseSidecar = parser.parseSidecar;
+export const parseSidecarContent = parser.parseSidecarContent;
+export const parseSidecarLenient = parser.parseSidecarLenient;
+export const parseSidecarContentLenient = parser.parseSidecarContentLenient;
+export const readDocumentLines = parser.readDocumentLines;
 // Writing
-export { computeHash, syncHash, toYaml, toJson, writeSidecar, } from "./lib/writer.js";
+export const computeHash = writer.computeHash;
+export const syncHash = writer.syncHash;
+export const toYaml = writer.toYaml;
+export const toJson = writer.toJson;
+export const writeSidecar = writer.writeSidecar;
 // Validation
-export { validate, validateFile } from "./lib/validator.js";
+export const validate = validator.validate;
+export const validateFile = validator.validateFile;
 // Fuzzy matching
-export { exactMatch, normalizedMatch, fuzzySearch, combinedScore, } from "./lib/fuzzy.js";
+export const exactMatch = fuzzy.exactMatch;
+export const normalizedMatch = fuzzy.normalizedMatch;
+export const fuzzySearch = fuzzy.fuzzySearch;
+export const combinedScore = fuzzy.combinedScore;
 // Git
-export { isGitAvailable, findRepoRoot, getCurrentCommit, isStale, getDiff, getLineShift, getFileAtCommit, getStagedFiles, detectRenames, parseDiffHunks, } from "./lib/git.js";
+export const isGitAvailable = git.isGitAvailable;
+export const findRepoRoot = git.findRepoRoot;
+export const getCurrentCommit = git.getCurrentCommit;
+export const isStale = git.isStale;
+export const getDiff = git.getDiff;
+export const getLineShift = git.getLineShift;
+export const getFileAtCommit = git.getFileAtCommit;
+export const getStagedFiles = git.getStagedFiles;
+export const detectRenames = git.detectRenames;
+export const parseDiffHunks = git.parseDiffHunks;
 // Re-anchoring
-export { reanchorComment, reanchorDocument, applyReanchorResults, reanchorFile, } from "./lib/reanchor.js";
+export const DEFAULT_THRESHOLD = reanchor.DEFAULT_THRESHOLD;
+export const HIGH_THRESHOLD = reanchor.HIGH_THRESHOLD;
+export const reanchorComment = reanchor.reanchorComment;
+export const reanchorDocumentLines = reanchor.reanchorDocumentLines;
+export const reanchorDocumentText = reanchor.reanchorDocumentText;
+export const toReanchorLines = reanchor.toReanchorLines;
+export const reanchorDocument = reanchor.reanchorDocument;
+export const applyReanchorResults = reanchor.applyReanchorResults;
+export const reanchorFile = reanchor.reanchorFile;
 // Comments
-export { addComment, normalizeCommentExtensions, populateSelectedText, resolveComment, unresolveComment, removeComment, filterComments, getThreads, summarize, } from "./lib/comments.js";
+export const addComment = comments.addComment;
+export const editComment = comments.editComment;
+export const normalizeCommentExtensions = comments.normalizeCommentExtensions;
+export const populateSelectedText = comments.populateSelectedText;
+export const resolveComment = comments.resolveComment;
+export const unresolveComment = comments.unresolveComment;
+export const removeComment = comments.removeComment;
+export const filterComments = comments.filterComments;
+export const getThreads = comments.getThreads;
+export const summarize = comments.summarize;
 //# sourceMappingURL=index.js.map

package/dist/lib/comments.d.ts

@@ -1,7 +1,7 @@
 /**
  * MRSF Comment Operations — CRUD for sidecar comments.
  */
-import type { AddCommentOptions, Comment, CommentFilter, CommentExtensions, MrsfDocument } from "./types.js";
+import type { AddCommentOptions, Comment, CommentFilter, CommentExtensions, EditCommentOptions, MrsfDocument } from "./types.js";
 export declare function normalizeCommentExtensions(extensions?: Record<string, unknown>): CommentExtensions;
 /**
  * Add a new comment to a document. Mutates doc.comments in place.
@@ -13,6 +13,7 @@ export declare function addComment(doc: MrsfDocument, opts: AddCommentOptions, r
  * Should be called after addComment if the caller provides line info but not selected_text.
  */
 export declare function populateSelectedText(comment: Comment, documentLines: string[]): void;
+export declare function editComment(doc: MrsfDocument, commentId: string, opts: EditCommentOptions): Comment;
 /**
  * Resolve a comment by id. Per §9, resolving a parent does NOT
  * automatically resolve its replies.

package/dist/lib/comments.js

@@ -129,6 +129,20 @@ export function populateSelectedText(comment, documentLines) {
         comment.selected_text_hash = computeHash(comment.selected_text);
     }
 }
+export function editComment(doc, commentId, opts) {
+    const comment = doc.comments.find((entry) => entry.id === commentId);
+    if (!comment) {
+        throw new Error(`Unknown comment '${commentId}'.`);
+    }
+    if (opts.actor && comment.author !== opts.actor) {
+        throw new Error("Only the comment author can edit this comment.");
+    }
+    if (opts.text.trim().length === 0) {
+        throw new Error("Comment text cannot be empty.");
+    }
+    comment.text = opts.text;
+    return comment;
+}
 // ---------------------------------------------------------------------------
 // Resolve / Unresolve
 // ---------------------------------------------------------------------------

package/dist/lib/parser.js

@@ -175,7 +175,7 @@ function salvageYaml(content) {
  */
 export async function readDocumentLines(filePath) {
     const content = await readFile(path.resolve(filePath), "utf-8");
-    const lines = content.split("\n");
+    const lines = content.replace(/\r\n?/g, "\n").split("\n");
     // Prepend empty element so lines[1] = first line (1-based)
     return ["", ...lines];
 }

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

@@ -0,0 +1,21 @@
+import type { Comment, DiffHunk, MrsfDocument, ReanchorResult } from "./types.js";
+export declare const HIGH_THRESHOLD = 0.8;
+export declare const DEFAULT_THRESHOLD = 0.6;
+export declare function toReanchorLines(documentText: string): string[];
+export declare function reanchorComment(comment: Comment, documentLines: string[], opts?: {
+    diffHunks?: DiffHunk[];
+    threshold?: number;
+    commitIsStale?: boolean;
+}): ReanchorResult;
+export declare function reanchorDocumentLines(doc: MrsfDocument, documentLines: string[], opts?: {
+    threshold?: number;
+}): ReanchorResult[];
+export declare function reanchorDocumentText(doc: MrsfDocument, documentText: string, opts?: {
+    threshold?: number;
+}): ReanchorResult[];
+export declare function applyReanchorResults(doc: MrsfDocument, results: ReanchorResult[], opts?: {
+    updateText?: boolean;
+    force?: boolean;
+    headCommit?: string;
+}): number;
+//# sourceMappingURL=reanchor-core.d.ts.map

package/dist/lib/reanchor-core.js

@@ -0,0 +1,298 @@
+import { exactMatch, fuzzySearch, normalizedMatch, } from "./fuzzy.js";
+export const HIGH_THRESHOLD = 0.8;
+export const DEFAULT_THRESHOLD = 0.6;
+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 commentId = comment.id;
+    const selectedText = comment.selected_text;
+    if (!selectedText && comment.line == null) {
+        return {
+            commentId,
+            status: "anchored",
+            score: 1.0,
+            reason: "Document-level comment (no anchor needed).",
+        };
+    }
+    if (comment.line != null && opts.diffHunks?.length) {
+        const { shift, modified } = getLineShift(opts.diffHunks, comment.line);
+        if (!selectedText) {
+            const shiftedLine = comment.line + shift;
+            const lineSpan = comment.end_line != null ? comment.end_line - comment.line : 0;
+            const shiftedEndLine = comment.end_line != null ? shiftedLine + lineSpan : undefined;
+            return {
+                commentId,
+                status: shift === 0 ? "anchored" : "shifted",
+                score: 1.0,
+                newLine: shiftedLine,
+                newEndLine: shiftedEndLine,
+                reason: shift === 0
+                    ? "Line-only comment unchanged (diff confirms position)."
+                    : `Line-only comment shifted by ${shift > 0 ? "+" : ""}${shift} line(s) via diff.`,
+            };
+        }
+        if (!modified) {
+            const shiftedLine = comment.line + shift;
+            const lineSpan = comment.end_line != null ? comment.end_line - comment.line : 0;
+            const shiftedEndLine = comment.end_line != null ? shiftedLine + lineSpan : undefined;
+            const textAtShifted = extractText(documentLines, shiftedLine, shiftedEndLine, comment.start_column, comment.end_column);
+            if (textAtShifted === selectedText) {
+                return {
+                    commentId,
+                    status: shift === 0 ? "anchored" : "shifted",
+                    score: 1.0,
+                    newLine: shiftedLine,
+                    newEndLine: shiftedEndLine,
+                    reason: shift === 0
+                        ? "Diff confirms text unchanged at original position."
+                        : `Diff shifted by ${shift > 0 ? "+" : ""}${shift} line(s).`,
+                };
+            }
+        }
+    }
+    if (selectedText) {
+        const exactCandidates = exactMatch(documentLines, selectedText);
+        if (exactCandidates.length === 1) {
+            const candidate = exactCandidates[0];
+            return {
+                commentId,
+                status: "anchored",
+                score: 1.0,
+                newLine: candidate.line,
+                newEndLine: candidate.endLine,
+                newStartColumn: candidate.startColumn,
+                newEndColumn: candidate.endColumn,
+                reason: "Exact text match (unique).",
+            };
+        }
+        if (exactCandidates.length > 1 && comment.line != null) {
+            const best = closestToLine(exactCandidates, comment.line);
+            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}).`,
+            };
+        }
+        const normCandidates = normalizedMatch(documentLines, selectedText);
+        if (normCandidates.length === 1) {
+            const candidate = normCandidates[0];
+            return {
+                commentId,
+                status: "fuzzy",
+                score: candidate.score,
+                newLine: candidate.line,
+                newEndLine: candidate.endLine,
+                newStartColumn: candidate.startColumn,
+                newEndColumn: candidate.endColumn,
+                anchoredText: candidate.text,
+                previousSelectedText: selectedText,
+                reason: "Normalized whitespace match.",
+            };
+        }
+        const fuzzyCandidates = fuzzySearch(documentLines, selectedText, HIGH_THRESHOLD, comment.line);
+        if (fuzzyCandidates.length === 1 || (fuzzyCandidates.length > 0 && fuzzyCandidates[0].score >= HIGH_THRESHOLD)) {
+            const best = fuzzyCandidates.length === 1
+                ? fuzzyCandidates[0]
+                : closestToLine(fuzzyCandidates, comment.line ?? 1);
+            return {
+                commentId,
+                status: "fuzzy",
+                score: best.score,
+                newLine: best.line,
+                newEndLine: best.endLine,
+                newStartColumn: best.startColumn,
+                newEndColumn: best.endColumn,
+                anchoredText: best.text,
+                previousSelectedText: selectedText,
+                reason: `High-confidence fuzzy match (score ${best.score.toFixed(3)}).`,
+            };
+        }
+    }
+    if (comment.line != null) {
+        const lineIdx = comment.line;
+        if (lineIdx > 0 && lineIdx < documentLines.length) {
+            const qualifier = opts.commitIsStale
+                ? " (commit is stale — line may have shifted)"
+                : "";
+            if (selectedText) {
+                const lineText = documentLines[lineIdx];
+                const candidates = fuzzySearch(["", lineText], selectedText, DEFAULT_THRESHOLD);
+                if (candidates.length > 0) {
+                    return {
+                        commentId,
+                        status: "fuzzy",
+                        score: candidates[0].score,
+                        newLine: comment.line,
+                        newEndLine: comment.end_line,
+                        anchoredText: candidates[0].text,
+                        previousSelectedText: selectedText,
+                        reason: `Line-fallback with fuzzy text match (score ${candidates[0].score.toFixed(3)})${qualifier}.`,
+                    };
+                }
+            }
+            const isLineOnly = !selectedText;
+            return {
+                commentId,
+                status: isLineOnly ? "anchored" : (opts.commitIsStale ? "ambiguous" : "anchored"),
+                score: isLineOnly ? 1.0 : (opts.commitIsStale ? 0.5 : 0.8),
+                newLine: comment.line,
+                newEndLine: comment.end_line,
+                reason: isLineOnly
+                    ? "Line-only comment (no selected_text to verify)."
+                    : `Line/column fallback${qualifier}.`,
+            };
+        }
+    }
+    if (selectedText) {
+        const lowCandidates = fuzzySearch(documentLines, selectedText, threshold, comment.line);
+        if (lowCandidates.length === 1) {
+            const candidate = lowCandidates[0];
+            return {
+                commentId,
+                status: "fuzzy",
+                score: candidate.score,
+                newLine: candidate.line,
+                newEndLine: candidate.endLine,
+                newStartColumn: candidate.startColumn,
+                newEndColumn: candidate.endColumn,
+                anchoredText: candidate.text,
+                previousSelectedText: selectedText,
+                reason: `Low-threshold fuzzy match (score ${candidate.score.toFixed(3)}).`,
+            };
+        }
+        if (lowCandidates.length > 1) {
+            const best = lowCandidates[0];
+            return {
+                commentId,
+                status: "ambiguous",
+                score: best.score,
+                newLine: best.line,
+                newEndLine: best.endLine,
+                reason: `Ambiguous: ${lowCandidates.length} fuzzy matches (best score ${best.score.toFixed(3)}).`,
+            };
+        }
+    }
+    return {
+        commentId,
+        status: "orphaned",
+        score: 0,
+        reason: "No match found. Comment is orphaned.",
+    };
+}
+export function reanchorDocumentLines(doc, documentLines, opts = {}) {
+    return doc.comments.map((comment) => reanchorComment(comment, documentLines, opts));
+}
+export function reanchorDocumentText(doc, documentText, opts = {}) {
+    return reanchorDocumentLines(doc, toReanchorLines(documentText), opts);
+}
+export function applyReanchorResults(doc, results, opts = {}) {
+    let changed = 0;
+    const resultMap = new Map(results.map((result) => [result.commentId, result]));
+    for (const comment of doc.comments) {
+        const result = resultMap.get(comment.id);
+        if (!result)
+            continue;
+        let isChanged = false;
+        if (result.newLine != null && result.newLine !== comment.line) {
+            comment.line = result.newLine;
+            isChanged = true;
+        }
+        if (result.newEndLine != null && result.newEndLine !== comment.end_line) {
+            comment.end_line = result.newEndLine;
+            isChanged = true;
+        }
+        if (result.newStartColumn != null && result.newStartColumn !== comment.start_column) {
+            comment.start_column = result.newStartColumn;
+            isChanged = true;
+        }
+        if (result.newEndColumn != null && result.newEndColumn !== comment.end_column) {
+            comment.end_column = result.newEndColumn;
+            isChanged = true;
+        }
+        if (result.anchoredText != null && result.anchoredText !== comment.selected_text) {
+            if (opts.updateText) {
+                comment.selected_text = result.anchoredText;
+                delete comment.anchored_text;
+            }
+            else {
+                comment.anchored_text = result.anchoredText;
+            }
+            isChanged = true;
+        }
+        else if (result.anchoredText != null && result.anchoredText === comment.selected_text) {
+            if (comment.anchored_text) {
+                delete comment.anchored_text;
+                isChanged = true;
+            }
+        }
+        if (isChanged || result.status !== "anchored") {
+            comment.x_reanchor_status = result.status;
+            comment.x_reanchor_score = result.score;
+        }
+        if (opts.force
+            && opts.headCommit
+            && (result.status === "anchored" || result.status === "shifted")
+            && result.score >= HIGH_THRESHOLD) {
+            comment.commit = opts.headCommit;
+            delete comment.x_reanchor_status;
+            delete comment.x_reanchor_score;
+            if (comment.anchored_text && comment.anchored_text === comment.selected_text) {
+                delete comment.anchored_text;
+            }
+            isChanged = true;
+        }
+        if (isChanged) {
+            changed += 1;
+        }
+    }
+    return changed;
+}
+function extractText(lines, line, endLine, startColumn, endColumn) {
+    const startIdx = line;
+    const endIdx = endLine ?? line;
+    if (startIdx < 1 || endIdx >= lines.length)
+        return null;
+    if (startIdx === endIdx) {
+        const text = lines[startIdx];
+        if (startColumn != null && endColumn != null) {
+            return text.slice(startColumn, endColumn);
+        }
+        return text;
+    }
+    const result = [];
+    for (let index = startIdx; index <= endIdx; index += 1) {
+        let currentLine = lines[index];
+        if (index === startIdx && startColumn != null)
+            currentLine = currentLine.slice(startColumn);
+        if (index === endIdx && endColumn != null)
+            currentLine = currentLine.slice(0, endColumn);
+        result.push(currentLine);
+    }
+    return result.join("\n");
+}
+function closestToLine(candidates, targetLine) {
+    return candidates.reduce((best, candidate) => Math.abs(candidate.line - targetLine) < Math.abs(best.line - targetLine) ? candidate : best);
+}
+function getLineShift(diffHunks, line) {
+    let shift = 0;
+    let modified = false;
+    for (const hunk of diffHunks) {
+        const oldStart = hunk.oldStart;
+        const oldEnd = hunk.oldStart + Math.max(hunk.oldCount, 1) - 1;
+        if (line >= oldStart && line <= oldEnd && hunk.oldCount > 0) {
+            modified = true;
+        }
+        if (line > oldEnd || (hunk.oldCount === 0 && line >= oldStart)) {
+            shift += hunk.newCount - hunk.oldCount;
+        }
+    }
+    return { shift, modified };
+}
+//# sourceMappingURL=reanchor-core.js.map

package/dist/lib/reanchor.d.ts

@@ -11,15 +11,8 @@
  *   Step 3  – lower-threshold fuzzy ≥ configured threshold (0.6)
  *   Step 4  – orphan
  */
-import type { Comment, MrsfDocument, ReanchorOptions, ReanchorResult, DiffHunk } from "./types.js";
-/**
- * Re-anchor a single comment against the current document lines.
- */
-export declare function reanchorComment(comment: Comment, documentLines: string[], opts?: {
-    diffHunks?: DiffHunk[];
-    threshold?: number;
-    commitIsStale?: boolean;
-}): ReanchorResult;
+import type { MrsfDocument, ReanchorOptions, ReanchorResult } from "./types.js";
+export { applyReanchorResults, DEFAULT_THRESHOLD, HIGH_THRESHOLD, reanchorComment, reanchorDocumentLines, reanchorDocumentText, toReanchorLines, } from "./reanchor-core.js";
 /**
  * Re-anchor all comments in an MRSF document.
  */
@@ -27,15 +20,6 @@ export declare function reanchorDocument(doc: MrsfDocument, documentLines: strin
     documentPath?: string;
     repoRoot?: string;
 }): Promise<ReanchorResult[]>;
-/**
- * Apply re-anchor results to the document's comments.
- * Mutates the document in place and returns the number of changed comments.
- */
-export declare function applyReanchorResults(doc: MrsfDocument, results: ReanchorResult[], opts?: {
-    updateText?: boolean;
-    force?: boolean;
-    headCommit?: string;
-}): number;
 /**
  * High-level re-anchor for a single sidecar file path.
  */

package/dist/lib/reanchor.js

@@ -11,236 +11,17 @@
  *   Step 3  – lower-threshold fuzzy ≥ configured threshold (0.6)
  *   Step 4  – orphan
  */
-import { findRepoRoot, getCurrentCommit, getDiff, getLineShift, isGitAvailable, } from "./git.js";
-import { exactMatch, fuzzySearch, normalizedMatch, } from "./fuzzy.js";
+import { findRepoRoot, getCurrentCommit, getDiff, isGitAvailable, } from "./git.js";
+import { applyReanchorResults, DEFAULT_THRESHOLD, reanchorComment, reanchorDocumentLines, } from "./reanchor-core.js";
 import { readDocumentLines } from "./parser.js";
 import { sidecarToDocument } from "./discovery.js";
 import { parseSidecar } from "./parser.js";
 import { writeSidecar } from "./writer.js";
 import path from "node:path";
+export { applyReanchorResults, DEFAULT_THRESHOLD, HIGH_THRESHOLD, reanchorComment, reanchorDocumentLines, reanchorDocumentText, toReanchorLines, } from "./reanchor-core.js";
 // ---------------------------------------------------------------------------
 // Constants
 // ---------------------------------------------------------------------------
-const HIGH_THRESHOLD = 0.8;
-const DEFAULT_THRESHOLD = 0.6;
-// ---------------------------------------------------------------------------
-// Single comment re-anchoring
-// ---------------------------------------------------------------------------
-/**
- * Re-anchor a single comment against the current document lines.
- */
-export function reanchorComment(comment, documentLines, opts = {}) {
-    const threshold = opts.threshold ?? DEFAULT_THRESHOLD;
-    const commentId = comment.id;
-    const selectedText = comment.selected_text;
-    // No selected_text and no line — nothing to anchor
-    if (!selectedText && comment.line == null) {
-        return {
-            commentId,
-            status: "anchored",
-            score: 1.0,
-            reason: "Document-level comment (no anchor needed).",
-        };
-    }
-    // -----------------------------------------------------------------------
-    // Step 0: Diff-based shift
-    // -----------------------------------------------------------------------
-    if (comment.line != null && opts.diffHunks?.length) {
-        const { shift, modified } = getLineShift(opts.diffHunks, comment.line);
-        // For line-only comments (no selected_text), apply the diff shift directly
-        if (!selectedText) {
-            const shiftedLine = comment.line + shift;
-            const lineSpan = comment.end_line != null ? comment.end_line - comment.line : 0;
-            const shiftedEndLine = comment.end_line != null ? shiftedLine + lineSpan : undefined;
-            return {
-                commentId,
-                status: shift === 0 ? "anchored" : "shifted",
-                score: 1.0,
-                newLine: shiftedLine,
-                newEndLine: shiftedEndLine,
-                reason: shift === 0
-                    ? "Line-only comment unchanged (diff confirms position)."
-                    : `Line-only comment shifted by ${shift > 0 ? "+" : ""}${shift} line(s) via diff.`,
-            };
-        }
-        if (!modified) {
-            const shiftedLine = comment.line + shift;
-            const lineSpan = comment.end_line != null ? comment.end_line - comment.line : 0;
-            const shiftedEndLine = comment.end_line != null ? shiftedLine + lineSpan : undefined;
-            // Verify the selected text still matches at the shifted position
-            const textAtShifted = extractText(documentLines, shiftedLine, shiftedEndLine, comment.start_column, comment.end_column);
-            if (textAtShifted === selectedText) {
-                return {
-                    commentId,
-                    status: shift === 0 ? "anchored" : "shifted",
-                    score: 1.0,
-                    newLine: shiftedLine,
-                    newEndLine: shiftedEndLine,
-                    reason: shift === 0
-                        ? "Diff confirms text unchanged at original position."
-                        : `Diff shifted by ${shift > 0 ? "+" : ""}${shift} line(s).`,
-                };
-            }
-        }
-        // Fall through — line was modified or text doesn't match after shift
-    }
-    // -----------------------------------------------------------------------
-    // Step 1: Exact text match
-    // -----------------------------------------------------------------------
-    if (selectedText) {
-        const exactCandidates = exactMatch(documentLines, selectedText);
-        if (exactCandidates.length === 1) {
-            const c = exactCandidates[0];
-            return {
-                commentId,
-                status: "anchored",
-                score: 1.0,
-                newLine: c.line,
-                newEndLine: c.endLine,
-                newStartColumn: c.startColumn,
-                newEndColumn: c.endColumn,
-                reason: "Exact text match (unique).",
-            };
-        }
-        if (exactCandidates.length > 1 && comment.line != null) {
-            // Disambiguate by proximity to original line
-            const best = closestToLine(exactCandidates, comment.line);
-            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}).`,
-            };
-        }
-        // -----------------------------------------------------------------------
-        // Step 1.5: Normalized + high-threshold fuzzy match
-        // -----------------------------------------------------------------------
-        // Try whitespace-normalized match first
-        const normCandidates = normalizedMatch(documentLines, selectedText);
-        if (normCandidates.length === 1) {
-            const c = normCandidates[0];
-            return {
-                commentId,
-                status: "fuzzy",
-                score: c.score,
-                newLine: c.line,
-                newEndLine: c.endLine,
-                newStartColumn: c.startColumn,
-                newEndColumn: c.endColumn,
-                anchoredText: c.text,
-                previousSelectedText: selectedText,
-                reason: "Normalized whitespace match.",
-            };
-        }
-        // High threshold fuzzy
-        const fuzzyCandidates = fuzzySearch(documentLines, selectedText, HIGH_THRESHOLD, comment.line);
-        if (fuzzyCandidates.length === 1 || (fuzzyCandidates.length > 0 && fuzzyCandidates[0].score >= HIGH_THRESHOLD)) {
-            const best = fuzzyCandidates.length === 1
-                ? fuzzyCandidates[0]
-                : closestToLine(fuzzyCandidates, comment.line ?? 1);
-            return {
-                commentId,
-                status: "fuzzy",
-                score: best.score,
-                newLine: best.line,
-                newEndLine: best.endLine,
-                newStartColumn: best.startColumn,
-                newEndColumn: best.endColumn,
-                anchoredText: best.text,
-                previousSelectedText: selectedText,
-                reason: `High-confidence fuzzy match (score ${best.score.toFixed(3)}).`,
-            };
-        }
-    }
-    // -----------------------------------------------------------------------
-    // Step 2: Line/column fallback
-    // -----------------------------------------------------------------------
-    if (comment.line != null) {
-        const lineIdx = comment.line - 1;
-        if (lineIdx >= 0 && lineIdx < documentLines.length) {
-            const qualifier = opts.commitIsStale
-                ? " (commit is stale — line may have shifted)"
-                : "";
-            // If we have selected_text, check if current line text is a decent fuzzy match
-            if (selectedText) {
-                const lineText = documentLines[lineIdx];
-                const candidates = fuzzySearch([lineText], selectedText, DEFAULT_THRESHOLD);
-                if (candidates.length > 0) {
-                    return {
-                        commentId,
-                        status: "fuzzy",
-                        score: candidates[0].score,
-                        newLine: comment.line,
-                        newEndLine: comment.end_line,
-                        anchoredText: candidates[0].text,
-                        previousSelectedText: selectedText,
-                        reason: `Line-fallback with fuzzy text match (score ${candidates[0].score.toFixed(3)})${qualifier}.`,
-                    };
-                }
-            }
-            // Pure line fallback
-            // If there's no selected_text, the comment is purely line-anchored.
-            // A commit change alone doesn't make it ambiguous — we accept it as-is.
-            const isLineOnly = !selectedText;
-            return {
-                commentId,
-                status: isLineOnly ? "anchored" : (opts.commitIsStale ? "ambiguous" : "anchored"),
-                score: isLineOnly ? 1.0 : (opts.commitIsStale ? 0.5 : 0.8),
-                newLine: comment.line,
-                newEndLine: comment.end_line,
-                reason: isLineOnly
-                    ? "Line-only comment (no selected_text to verify)."
-                    : `Line/column fallback${qualifier}.`,
-            };
-        }
-    }
-    // -----------------------------------------------------------------------
-    // Step 3: Lower-threshold fuzzy search
-    // -----------------------------------------------------------------------
-    if (selectedText) {
-        const lowCandidates = fuzzySearch(documentLines, selectedText, threshold, comment.line);
-        if (lowCandidates.length === 1) {
-            const c = lowCandidates[0];
-            return {
-                commentId,
-                status: "fuzzy",
-                score: c.score,
-                newLine: c.line,
-                newEndLine: c.endLine,
-                newStartColumn: c.startColumn,
-                newEndColumn: c.endColumn,
-                anchoredText: c.text,
-                previousSelectedText: selectedText,
-                reason: `Low-threshold fuzzy match (score ${c.score.toFixed(3)}).`,
-            };
-        }
-        if (lowCandidates.length > 1) {
-            // Ambiguous — multiple low-confidence matches
-            const best = lowCandidates[0];
-            return {
-                commentId,
-                status: "ambiguous",
-                score: best.score,
-                newLine: best.line,
-                newEndLine: best.endLine,
-                reason: `Ambiguous: ${lowCandidates.length} fuzzy matches (best score ${best.score.toFixed(3)}).`,
-            };
-        }
-    }
-    // -----------------------------------------------------------------------
-    // Step 4: Orphan
-    // -----------------------------------------------------------------------
-    return {
-        commentId,
-        status: "orphaned",
-        score: 0,
-        reason: "No match found. Comment is orphaned.",
-    };
-}
 // ---------------------------------------------------------------------------
 // Batch re-anchoring
 // ---------------------------------------------------------------------------
@@ -280,87 +61,7 @@ export async function reanchorDocument(doc, documentLines, opts = {}) {
             return results;
         }
     }
-    // No git — pure text-based re-anchoring
-    for (const comment of doc.comments) {
-        results.push(reanchorComment(comment, documentLines, { threshold }));
-    }
-    return results;
-}
-/**
- * Apply re-anchor results to the document's comments.
- * Mutates the document in place and returns the number of changed comments.
- */
-export function applyReanchorResults(doc, results, opts = {}) {
-    let changed = 0;
-    const resultMap = new Map(results.map((r) => [r.commentId, r]));
-    for (const comment of doc.comments) {
-        const result = resultMap.get(comment.id);
-        if (!result)
-            continue;
-        let isChanged = false;
-        if (result.newLine != null && result.newLine !== comment.line) {
-            comment.line = result.newLine;
-            isChanged = true;
-        }
-        if (result.newEndLine != null && result.newEndLine !== comment.end_line) {
-            comment.end_line = result.newEndLine;
-            isChanged = true;
-        }
-        if (result.newStartColumn != null && result.newStartColumn !== comment.start_column) {
-            comment.start_column = result.newStartColumn;
-            isChanged = true;
-        }
-        if (result.newEndColumn != null && result.newEndColumn !== comment.end_column) {
-            comment.end_column = result.newEndColumn;
-            isChanged = true;
-        }
-        // Handle anchored_text / selected_text per §6.2 & §7.4 Step 3a.
-        // By default, selected_text is preserved (SHOULD NOT modify).
-        // anchored_text records the text currently at the resolved position.
-        if (result.anchoredText != null && result.anchoredText !== comment.selected_text) {
-            if (opts.updateText) {
-                // Opt-in: replace selected_text and clear anchored_text
-                comment.selected_text = result.anchoredText;
-                delete comment.anchored_text;
-            }
-            else {
-                // Default: preserve selected_text, record current text in anchored_text
-                comment.anchored_text = result.anchoredText;
-            }
-            isChanged = true;
-        }
-        else if (result.anchoredText != null && result.anchoredText === comment.selected_text) {
-            // Text matches exactly — clear any stale anchored_text
-            if (comment.anchored_text) {
-                delete comment.anchored_text;
-                isChanged = true;
-            }
-        }
-        // Audit fields (x_ extension prefix per §10)
-        if (isChanged || result.status !== "anchored") {
-            comment.x_reanchor_status = result.status;
-            comment.x_reanchor_score = result.score;
-        }
-        // --force: firmly anchor high-confidence results
-        // Update commit to HEAD and clear audit fields so the comment
-        // won't be re-evaluated on the next reanchor run.
-        if (opts.force &&
-            opts.headCommit &&
-            (result.status === "anchored" || result.status === "shifted") &&
-            result.score >= HIGH_THRESHOLD) {
-            comment.commit = opts.headCommit;
-            delete comment.x_reanchor_status;
-            delete comment.x_reanchor_score;
-            // Clear stale anchored_text since anchor is now confirmed
-            if (comment.anchored_text && comment.anchored_text === comment.selected_text) {
-                delete comment.anchored_text;
-            }
-            isChanged = true;
-        }
-        if (isChanged)
-            changed++;
-    }
-    return changed;
+    return reanchorDocumentLines(doc, documentLines, { threshold });
 }
 /**
  * High-level re-anchor for a single sidecar file path.
@@ -394,38 +95,4 @@ export async function reanchorFile(sidecarPath, opts = {}) {
 // ---------------------------------------------------------------------------
 // Helpers
 // ---------------------------------------------------------------------------
-/**
- * Extract text from document lines at the given position.
- * Lines array is 1-based (index 0 is unused), so lines[line] is the content.
- */
-function extractText(lines, line, endLine, startColumn, endColumn) {
-    const startIdx = line; // 1-based array: lines[1] = first line
-    const endIdx = endLine ?? line;
-    if (startIdx < 1 || endIdx >= lines.length)
-        return null;
-    if (startIdx === endIdx) {
-        const text = lines[startIdx];
-        if (startColumn != null && endColumn != null) {
-            return text.slice(startColumn, endColumn);
-        }
-        return text;
-    }
-    // Multi-line
-    const result = [];
-    for (let i = startIdx; i <= endIdx; i++) {
-        let l = lines[i];
-        if (i === startIdx && startColumn != null)
-            l = l.slice(startColumn);
-        if (i === endIdx && endColumn != null)
-            l = l.slice(0, endColumn);
-        result.push(l);
-    }
-    return result.join("\n");
-}
-/**
- * Pick the candidate closest to a hint line.
- */
-function closestToLine(candidates, targetLine) {
-    return candidates.reduce((best, c) => Math.abs(c.line - targetLine) < Math.abs(best.line - targetLine) ? c : best);
-}
 //# sourceMappingURL=reanchor.js.map

package/dist/lib/types.d.ts

@@ -113,6 +113,11 @@ export interface AddCommentOptions {
     /** Tool-specific extension fields keyed by x_*. */
     extensions?: CommentExtensions;
 }
+export interface EditCommentOptions {
+    text: string;
+    /** Optional actor identity for author-based edit permission checks. */
+    actor?: string;
+}
 export interface CommentFilter {
     open?: boolean;
     resolved?: boolean;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@mrsf/cli",
-  "version": "0.4.0",
+  "version": "0.4.2",
   "description": "CLI and library for the Markdown Review Sidecar Format (MRSF)",
   "type": "module",
   "main": "./dist/index.js",
@@ -9,6 +9,10 @@
     ".": {
       "import": "./dist/index.js",
       "types": "./dist/index.d.ts"
+    },
+    "./browser": {
+      "import": "./dist/browser.js",
+      "types": "./dist/browser.d.ts"
     }
   },
   "bin": {
@@ -72,8 +76,8 @@
     "@types/js-yaml": "^4.0.9",
     "@types/node": "^22.13.10",
     "@types/uuid": "^10.0.0",
-    "@vitest/coverage-v8": "^3.2.4",
+    "@vitest/coverage-v8": "^4.0.18",
     "typescript": "^5.8.2",
-    "vitest": "^3.0.9"
+    "vitest": "^4.0.18"
   }
 }