@mrsf/cli 0.4.1 → 0.4.3

package/dist/browser.d.ts

@@ -1,4 +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 { combinedScore, exactMatch, fuzzySearch, levenshteinScore, normalizedMatch, tokenLcsScore, } from "./lib/fuzzy.js";
-export { applyReanchorResults, DEFAULT_THRESHOLD, HIGH_THRESHOLD, reanchorComment, reanchorDocumentLines, reanchorDocumentText, toReanchorLines, } from "./lib/reanchor-core.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

@@ -1,3 +1,16 @@
-export { combinedScore, exactMatch, fuzzySearch, levenshteinScore, normalizedMatch, tokenLcsScore, } from "./lib/fuzzy.js";
-export { applyReanchorResults, DEFAULT_THRESHOLD, HIGH_THRESHOLD, reanchorComment, reanchorDocumentLines, reanchorDocumentText, toReanchorLines, } from "./lib/reanchor-core.js";
+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/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 { DEFAULT_THRESHOLD, HIGH_THRESHOLD, reanchorComment, reanchorDocumentLines, reanchorDocumentText, toReanchorLines, 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 { DEFAULT_THRESHOLD, HIGH_THRESHOLD, reanchorComment, reanchorDocumentLines, reanchorDocumentText, toReanchorLines, 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/fuzzy.js

@@ -110,6 +110,37 @@ export function normalizedMatch(lines, needle) {
 function tokenize(text) {
     return text.split(/\s+/).filter((t) => t.length > 0);
 }
+/**
+ * Build a frequency map for a token array. Used for fast multiset
+ * intersection during the fuzzySearch prefilter.
+ */
+function buildTokenFreq(tokens) {
+    const freq = new Map();
+    for (const tok of tokens) {
+        freq.set(tok, (freq.get(tok) ?? 0) + 1);
+    }
+    return freq;
+}
+/**
+ * Multiset intersection size: sum over needle tokens of
+ * min(needleFreq[token], windowFreq[token]). This is an upper bound on
+ * the longest common subsequence length, so it lets us cheaply skip
+ * windows that cannot possibly reach the score threshold.
+ */
+function multisetIntersection(needleFreq, windowFreq) {
+    let common = 0;
+    // Iterate the smaller map for speed.
+    const [smaller, larger] = needleFreq.size <= windowFreq.size
+        ? [needleFreq, windowFreq]
+        : [windowFreq, needleFreq];
+    for (const [tok, cnt] of smaller) {
+        const other = larger.get(tok);
+        if (other !== undefined) {
+            common += cnt < other ? cnt : other;
+        }
+    }
+    return common;
+}
 /**
  * Longest Common Subsequence length of two token arrays.
  */
@@ -199,38 +230,144 @@ export function fuzzySearch(lines, needle, threshold = 0.6, hintLine) {
     const needleLines = needle.split("\n");
     const needleLineCount = needleLines.length;
     const candidates = [];
+    // Pre-tokenize: do this once per call instead of per window. Per-line
+    // tokenization gives identical results to tokenize(lines.join("\n")) since
+    // tokenize splits on /\s+/ and filters empties.
+    const lineTokens = new Array(lines.length);
+    const lineTokenLengths = new Array(lines.length);
+    for (let i = 0; i < lines.length; i++) {
+        const toks = lines[i] ? tokenize(lines[i]) : [];
+        lineTokens[i] = toks;
+        lineTokenLengths[i] = toks.length;
+    }
+    const needleTokens = tokenize(needle);
+    const needleTokenCount = needleTokens.length;
+    const needleFreq = buildTokenFreq(needleTokens);
+    // The combined score is 0.6 * tScore + 0.4 * lScore. Since lScore <= 1.0,
+    // a window can only reach `threshold` if tScore >= (threshold - 0.4) / 0.6.
+    // Use this as a hard prefilter before doing the expensive LCS / Levenshtein.
+    const minTScore = Math.max(0, (threshold - 0.4) / 0.6);
     // Window sizes: ±30% of original line count, minimum 1
     const minWindow = Math.max(1, Math.floor(needleLineCount * 0.7));
     const maxWindow = Math.min(lines.length - 1, Math.ceil(needleLineCount * 1.3) + 1);
+    // Track total token count per window using a rolling sum so we don't
+    // re-walk the line-token arrays for every (winSize, startLine) pair.
     for (let winSize = minWindow; winSize <= maxWindow; winSize++) {
+        if (winSize < 1)
+            continue;
+        if (winSize > lines.length - 1)
+            continue;
+        // Initial window token sum for startLine = 1.
+        let runningTokenCount = 0;
+        for (let i = 1; i < 1 + winSize && i < lines.length; i++) {
+            runningTokenCount += lineTokenLengths[i];
+        }
         for (let startLine = 1; startLine + winSize - 1 < lines.length; startLine++) {
-            const windowLines = lines.slice(startLine, startLine + winSize);
-            const windowText = windowLines.join("\n");
-            const score = combinedScore(needle, windowText);
-            if (score >= threshold) {
-                candidates.push({
-                    text: windowText,
-                    line: startLine,
-                    endLine: startLine + winSize - 1,
-                    startColumn: 0,
-                    endColumn: windowLines[windowLines.length - 1].length,
-                    score,
-                });
+            const endLineExclusive = startLine + winSize;
+            const M = runningTokenCount;
+            // Cheap skip: empty windows or empty needle can't fuzzy-match.
+            if (needleTokenCount > 0 && M > 0) {
+                // Build a frequency map for the window tokens. Cheaper than LCS:
+                // O(M) instead of O(M * needleTokenCount). We allocate a fresh map
+                // per window; tried a rolling map and the bookkeeping was a wash
+                // with realistic windowSize but if profiling demands it can be
+                // converted.
+                const windowFreq = new Map();
+                for (let li = startLine; li < endLineExclusive; li++) {
+                    const arr = lineTokens[li];
+                    for (let ti = 0; ti < arr.length; ti++) {
+                        const tok = arr[ti];
+                        windowFreq.set(tok, (windowFreq.get(tok) ?? 0) + 1);
+                    }
+                }
+                // Multiset intersection is an upper bound on LCS length. If we
+                // can't reach minTScore even with a perfect LCS, skip the window.
+                const common = multisetIntersection(needleFreq, windowFreq);
+                const tScoreUpperBound = common / Math.max(needleTokenCount, M);
+                if (tScoreUpperBound >= minTScore) {
+                    // Build the flat window token array only when we actually need
+                    // to compute LCS.
+                    const windowTokens = new Array(M);
+                    let wi = 0;
+                    for (let li = startLine; li < endLineExclusive; li++) {
+                        const arr = lineTokens[li];
+                        for (let ti = 0; ti < arr.length; ti++) {
+                            windowTokens[wi++] = arr[ti];
+                        }
+                    }
+                    const lcs = lcsLength(needleTokens, windowTokens);
+                    const tScore = lcs / Math.max(needleTokenCount, M);
+                    if (tScore >= minTScore) {
+                        // Defer expensive string join + Levenshtein until we know the
+                        // tScore could plausibly reach threshold.
+                        const windowLines = lines.slice(startLine, endLineExclusive);
+                        const windowText = windowLines.join("\n");
+                        let lScore;
+                        if (needle.length < 500 && windowText.length < 500) {
+                            lScore = levenshteinScore(needle, windowText);
+                        }
+                        else {
+                            lScore = tScore; // fall back to token score only
+                        }
+                        const score = tScore * 0.6 + lScore * 0.4;
+                        if (score >= threshold) {
+                            candidates.push({
+                                text: windowText,
+                                line: startLine,
+                                endLine: startLine + winSize - 1,
+                                startColumn: 0,
+                                endColumn: windowLines[windowLines.length - 1].length,
+                                score,
+                            });
+                        }
+                    }
+                }
+            }
+            // Slide window by one: drop startLine token count, add endLine token count.
+            const nextStart = startLine + 1;
+            const nextEndExclusive = nextStart + winSize;
+            if (nextEndExclusive <= lines.length) {
+                runningTokenCount += lineTokenLengths[endLineExclusive] - lineTokenLengths[startLine];
             }
         }
     }
-    // For single-line needles, also try substring matching within each line
+    // For single-line needles, also try substring matching within each line.
+    // Prefilter each line by token overlap before running the inner sliding
+    // window — long lines without enough needle-token coverage are skipped
+    // wholesale, since no substring of such a line can exceed its parent
+    // line's token-overlap with the needle.
     if (needleLineCount === 1 && needle.length < 200) {
+        // The minimum number of needle tokens that must appear in a line for any
+        // substring of that line to plausibly reach minTScore. tScore =
+        // lcs / max(needleN, subN), so lcs >= minTScore * needleN is required,
+        // and lcs <= number of common tokens.
+        const requiredLineCommon = Math.max(0, Math.ceil(needleTokenCount * minTScore));
         for (let lineNum = 1; lineNum < lines.length; lineNum++) {
             const line = lines[lineNum];
             if (!line)
                 continue;
-            // Sliding window within line
+            if (needleTokenCount > 0 && requiredLineCommon > 0) {
+                const lineFreq = buildTokenFreq(lineTokens[lineNum]);
+                const lineCommon = multisetIntersection(needleFreq, lineFreq);
+                if (lineCommon < requiredLineCommon)
+                    continue;
+            }
+            // Sliding window within line. Step by 1 by default for accuracy, but
+            // for very long lines and long needles, we coarsen the column step to
+            // avoid quadratic-in-line-length behaviour. The natural `len = winLen`
+            // is always swept densely so we don't miss the most likely match.
             const winLen = needle.length;
             const minWinLen = Math.max(3, Math.floor(winLen * 0.7));
             const maxWinLen = Math.min(line.length, Math.ceil(winLen * 1.3));
             for (let len = minWinLen; len <= maxWinLen; len++) {
-                for (let col = 0; col + len <= line.length; col++) {
+                // Coarsen the column step proportionally to needle length once the
+                // sub-window is no longer the natural needle length. This trades a
+                // tiny bit of recall for an order-of-magnitude speedup on long
+                // lines with many candidate offsets.
+                const colStep = len === winLen
+                    ? 1
+                    : Math.max(1, Math.floor(winLen / 16));
+                for (let col = 0; col + len <= line.length; col += colStep) {
                     const sub = line.substring(col, col + len);
                     const score = combinedScore(needle, sub);
                     if (score >= threshold) {

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/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.1",
+  "version": "0.4.3",
   "description": "CLI and library for the Markdown Review Sidecar Format (MRSF)",
   "type": "module",
   "main": "./dist/index.js",