@mrsf/cli 0.4.3 → 0.5.0

package/dist/lib/fuzzy.js

@@ -110,37 +110,6 @@ 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.
  */
@@ -230,144 +199,38 @@ 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 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];
+            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,
+                });
             }
         }
     }
-    // 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.
+    // For single-line needles, also try substring matching within each line
     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;
-            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.
+            // Sliding window within line
             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++) {
-                // 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) {
+                for (let col = 0; col + len <= line.length; col++) {
                     const sub = line.substring(col, col + len);
                     const score = combinedScore(needle, sub);
                     if (score >= threshold) {

package/dist/lib/identity.d.ts

@@ -0,0 +1,12 @@
+export interface ParsedAuthor {
+    name: string;
+    handle?: string;
+}
+export declare function formatAuthor(name: string, handle?: string): string;
+export declare function parseAuthor(author: string): ParsedAuthor;
+/**
+ * Create a collision-resistant MRSF comment id.
+ * ULID is also permitted by the spec; UUIDv4 is the default for this package.
+ */
+export declare function newCommentId(): string;
+//# sourceMappingURL=identity.d.ts.map

package/dist/lib/identity.js

@@ -0,0 +1,23 @@
+import { v4 as uuidv4 } from "uuid";
+export function formatAuthor(name, handle) {
+    const trimmedName = name.trim();
+    const trimmedHandle = handle?.trim();
+    return trimmedHandle ? `${trimmedName} (${trimmedHandle})` : trimmedName;
+}
+export function parseAuthor(author) {
+    const trimmed = author.trim();
+    const match = /^(.*?)\s*\(([^()]*)\)\s*$/.exec(trimmed);
+    if (!match)
+        return { name: trimmed };
+    const name = match[1].trim();
+    const handle = match[2].trim();
+    return handle ? { name, handle } : { name };
+}
+/**
+ * Create a collision-resistant MRSF comment id.
+ * ULID is also permitted by the spec; UUIDv4 is the default for this package.
+ */
+export function newCommentId() {
+    return uuidv4();
+}
+//# sourceMappingURL=identity.js.map

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

@@ -1,4 +1,4 @@
-import type { Comment, DiffHunk, MrsfDocument, ReanchorResult } from "./types.js";
+import type { AnchorPosition, 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[];
@@ -13,6 +13,9 @@ export declare function reanchorDocumentLines(doc: MrsfDocument, documentLines:
 export declare function reanchorDocumentText(doc: MrsfDocument, documentText: string, opts?: {
     threshold?: number;
 }): ReanchorResult[];
+export declare function resolveAnchor(comment: Comment, documentText: string, opts?: {
+    threshold?: number;
+}): AnchorPosition;
 export declare function applyReanchorResults(doc: MrsfDocument, results: ReanchorResult[], opts?: {
     updateText?: boolean;
     force?: boolean;

package/dist/lib/reanchor-core.js

@@ -192,6 +192,68 @@ export function reanchorDocumentLines(doc, documentLines, opts = {}) {
 export function reanchorDocumentText(doc, documentText, opts = {}) {
     return reanchorDocumentLines(doc, toReanchorLines(documentText), opts);
 }
+export function resolveAnchor(comment, documentText, opts = {}) {
+    const normalizedText = documentText.replace(/\r\n/g, "\n");
+    const documentLines = toReanchorLines(documentText);
+    const result = reanchorComment(comment, documentLines, opts);
+    if (result.status === "orphaned") {
+        return {
+            status: "orphaned",
+            score: result.score,
+            reason: result.reason,
+        };
+    }
+    const line = result.newLine ?? comment.line;
+    if (line == null) {
+        return {
+            status: result.status,
+            score: result.score,
+            reason: result.reason,
+        };
+    }
+    const rawLines = normalizedText.split("\n");
+    const lineStarts = computeLineStarts(rawLines);
+    const endLine = result.newEndLine ?? comment.end_line ?? line;
+    const startColumn = result.newStartColumn ?? comment.start_column ?? 0;
+    const endColumn = result.newEndColumn ?? comment.end_column;
+    const from = offsetFor(lineStarts, rawLines, line, startColumn);
+    const selectedText = comment.selected_text?.replace(/\r\n/g, "\n");
+    const to = endColumn != null
+        ? offsetFor(lineStarts, rawLines, endLine, endColumn)
+        : selectedText
+            ? from + selectedText.length
+            : offsetFor(lineStarts, rawLines, endLine, rawLines[endLine - 1]?.length ?? 0);
+    return {
+        status: result.status,
+        score: result.score,
+        from,
+        to,
+        line,
+        endLine,
+        startColumn,
+        endColumn: endColumn ?? columnForOffset(lineStarts, rawLines, endLine, to),
+        reason: result.reason,
+    };
+}
+function computeLineStarts(lines) {
+    const starts = [0];
+    let offset = 0;
+    for (const line of lines) {
+        starts.push(offset);
+        offset += line.length + 1;
+    }
+    return starts;
+}
+function offsetFor(lineStarts, lines, line, column) {
+    const start = lineStarts[line] ?? 0;
+    const maxColumn = lines[line - 1]?.length ?? 0;
+    return start + Math.max(0, Math.min(column, maxColumn));
+}
+function columnForOffset(lineStarts, lines, line, offset) {
+    const start = lineStarts[line] ?? 0;
+    const maxColumn = lines[line - 1]?.length ?? 0;
+    return Math.max(0, Math.min(offset - start, maxColumn));
+}
 export function applyReanchorResults(doc, results, opts = {}) {
     let changed = 0;
     const resultMap = new Map(results.map((result) => [result.commentId, result]));

package/dist/lib/reanchor.d.ts

@@ -12,7 +12,7 @@
  *   Step 4  – orphan
  */
 import type { MrsfDocument, ReanchorOptions, ReanchorResult } from "./types.js";
-export { applyReanchorResults, DEFAULT_THRESHOLD, HIGH_THRESHOLD, reanchorComment, reanchorDocumentLines, reanchorDocumentText, toReanchorLines, } from "./reanchor-core.js";
+export { applyReanchorResults, DEFAULT_THRESHOLD, HIGH_THRESHOLD, reanchorComment, reanchorDocumentLines, reanchorDocumentText, resolveAnchor, toReanchorLines, } from "./reanchor-core.js";
 /**
  * Re-anchor all comments in an MRSF document.
  */

package/dist/lib/reanchor.js

@@ -18,7 +18,7 @@ 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";
+export { applyReanchorResults, DEFAULT_THRESHOLD, HIGH_THRESHOLD, reanchorComment, reanchorDocumentLines, reanchorDocumentText, resolveAnchor, toReanchorLines, } from "./reanchor-core.js";
 // ---------------------------------------------------------------------------
 // Constants
 // ---------------------------------------------------------------------------

package/dist/lib/schema.d.ts

@@ -0,0 +1,106 @@
+export declare const mrsfSchema: {
+    $schema: string;
+    $id: string;
+    title: string;
+    description: string;
+    type: string;
+    required: string[];
+    additionalProperties: boolean;
+    properties: {
+        mrsf_version: {
+            type: string;
+            pattern: string;
+            description: string;
+        };
+        document: {
+            type: string;
+            description: string;
+        };
+        comments: {
+            type: string;
+            items: {
+                type: string;
+                required: string[];
+                additionalProperties: boolean;
+                properties: {
+                    id: {
+                        type: string;
+                        description: string;
+                    };
+                    author: {
+                        type: string;
+                        description: string;
+                    };
+                    timestamp: {
+                        type: string;
+                        format: string;
+                        description: string;
+                    };
+                    text: {
+                        type: string;
+                        maxLength: number;
+                        description: string;
+                    };
+                    resolved: {
+                        type: string;
+                        description: string;
+                    };
+                    commit: {
+                        type: string;
+                        description: string;
+                    };
+                    type: {
+                        type: string;
+                        description: string;
+                        examples: string[];
+                    };
+                    severity: {
+                        type: string;
+                        description: string;
+                        enum: string[];
+                    };
+                    reply_to: {
+                        type: string;
+                        description: string;
+                    };
+                    line: {
+                        type: string;
+                        minimum: number;
+                        description: string;
+                    };
+                    end_line: {
+                        type: string;
+                        minimum: number;
+                        description: string;
+                    };
+                    start_column: {
+                        type: string;
+                        minimum: number;
+                        description: string;
+                    };
+                    end_column: {
+                        type: string;
+                        minimum: number;
+                        description: string;
+                    };
+                    selected_text: {
+                        type: string;
+                        maxLength: number;
+                        description: string;
+                    };
+                    anchored_text: {
+                        type: string;
+                        maxLength: number;
+                        description: string;
+                    };
+                    selected_text_hash: {
+                        type: string;
+                        pattern: string;
+                        description: string;
+                    };
+                };
+            };
+        };
+    };
+};
+//# sourceMappingURL=schema.d.ts.map

package/dist/lib/schema.js

@@ -0,0 +1,3 @@
+import mrsfSchemaJson from "../../mrsf.schema.json" with { type: "json" };
+export const mrsfSchema = mrsfSchemaJson;
+//# sourceMappingURL=schema.js.map

package/dist/lib/types.d.ts

@@ -40,6 +40,7 @@ export interface MrsfConfig {
 export type DiagnosticSeverity = "error" | "warning";
 export interface ValidationDiagnostic {
     severity: DiagnosticSeverity;
+    code: string;
     message: string;
     /** Path within the document, e.g. "/comments/0/end_line". */
     path?: string;
@@ -69,6 +70,23 @@ export interface ReanchorResult {
     /** Human-readable explanation of the resolution. */
     reason: string;
 }
+export interface AnchorPosition {
+    status: ReanchorStatus;
+    score: number;
+    /** Absolute 0-based character offset in normalized document text (start). */
+    from?: number;
+    /** Absolute 0-based character offset in normalized document text (end, exclusive). */
+    to?: number;
+    /** 1-based start line. */
+    line?: number;
+    /** 1-based end line. */
+    endLine?: number;
+    /** 0-based start column. */
+    startColumn?: number;
+    /** 0-based end column. */
+    endColumn?: number;
+    reason: string;
+}
 export interface FuzzyCandidate {
     /** Matched text in the document. */
     text: string;

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

@@ -0,0 +1,6 @@
+import type { MrsfDocument, ValidationDiagnostic, ValidationResult } from "./types.js";
+export type HashFunction = (text: string) => string;
+export declare function validateDocument(doc: MrsfDocument, schema?: object): ValidationResult;
+export declare function validateSchema(doc: MrsfDocument, rawSchema: object, errors: ValidationDiagnostic[]): void;
+export declare function validateCrossFields(doc: MrsfDocument, errors: ValidationDiagnostic[], warnings: ValidationDiagnostic[], hash?: HashFunction): void;
+//# sourceMappingURL=validate-core.d.ts.map

package/dist/lib/validate-core.js

@@ -0,0 +1,128 @@
+import AjvModule from "ajv";
+import addFormatsModule from "ajv-formats";
+import { mrsfSchema } from "./schema.js";
+const Ajv = AjvModule.default ?? AjvModule;
+const addFormats = addFormatsModule.default ?? addFormatsModule;
+export function validateDocument(doc, schema = mrsfSchema) {
+    const errors = [];
+    const warnings = [];
+    validateSchema(doc, schema, errors);
+    validateCrossFields(doc, errors, warnings);
+    return {
+        valid: errors.length === 0,
+        errors,
+        warnings,
+    };
+}
+export function validateSchema(doc, rawSchema, errors) {
+    const { $schema, ...schema } = rawSchema;
+    void $schema;
+    const ajv = new Ajv({ allErrors: true, strict: false });
+    addFormats(ajv);
+    const ajvValidate = ajv.compile(schema);
+    const schemaValid = ajvValidate(doc);
+    if (!schemaValid && ajvValidate.errors) {
+        for (const err of ajvValidate.errors) {
+            errors.push({
+                severity: "error",
+                code: "schema-violation",
+                message: `${err.instancePath || "/"}: ${err.message ?? "schema error"}`,
+                path: err.instancePath || "/",
+            });
+        }
+    }
+}
+export function validateCrossFields(doc, errors, warnings, hash) {
+    if (!Array.isArray(doc.comments))
+        return;
+    const ids = new Set();
+    const allIds = doc.comments.map((x) => x.id);
+    for (let i = 0; i < doc.comments.length; i++) {
+        const c = doc.comments[i];
+        const prefix = `/comments/${i}`;
+        if (c.id) {
+            if (ids.has(c.id)) {
+                errors.push({
+                    severity: "error",
+                    code: "duplicate-id",
+                    message: `Duplicate comment id "${c.id}"`,
+                    path: `${prefix}/id`,
+                    commentId: c.id,
+                });
+            }
+            ids.add(c.id);
+        }
+        if (c.line != null && c.end_line != null && c.end_line < c.line) {
+            errors.push({
+                severity: "error",
+                code: "end-line-before-line",
+                message: `end_line (${c.end_line}) must be ≥ line (${c.line})`,
+                path: `${prefix}/end_line`,
+                commentId: c.id,
+            });
+        }
+        if (c.start_column != null &&
+            c.end_column != null &&
+            (c.line == null || c.end_line == null || c.line === c.end_line) &&
+            c.end_column < c.start_column) {
+            errors.push({
+                severity: "error",
+                code: "end-column-before-start-column",
+                message: `end_column (${c.end_column}) must be ≥ start_column (${c.start_column}) on the same line`,
+                path: `${prefix}/end_column`,
+                commentId: c.id,
+            });
+        }
+        if (c.selected_text && c.selected_text.length > 4096) {
+            errors.push({
+                severity: "error",
+                code: "selected-text-too-long",
+                message: `selected_text exceeds 4096 characters (${c.selected_text.length})`,
+                path: `${prefix}/selected_text`,
+                commentId: c.id,
+            });
+        }
+        if (c.text && c.text.length > 16384) {
+            warnings.push({
+                severity: "warning",
+                code: "text-too-long",
+                message: `text exceeds recommended 16384 characters (${c.text.length})`,
+                path: `${prefix}/text`,
+                commentId: c.id,
+            });
+        }
+        // Browser-safe callers do not get the Node SHA-256 implementation.
+        // The hash check runs only when a hash function is injected by the Node validator.
+        if (hash && c.selected_text && c.selected_text_hash) {
+            const expected = hash(c.selected_text);
+            if (c.selected_text_hash !== expected) {
+                warnings.push({
+                    severity: "warning",
+                    code: "hash-mismatch",
+                    message: `selected_text_hash mismatch (expected ${expected.slice(0, 12)}…, got ${c.selected_text_hash.slice(0, 12)}…)`,
+                    path: `${prefix}/selected_text_hash`,
+                    commentId: c.id,
+                });
+            }
+        }
+        if (c.reply_to && !ids.has(c.reply_to) && !allIds.includes(c.reply_to)) {
+            warnings.push({
+                severity: "warning",
+                code: "unresolved-reply-to",
+                message: `reply_to "${c.reply_to}" does not resolve to any comment id in this file`,
+                path: `${prefix}/reply_to`,
+                commentId: c.id,
+            });
+        }
+        if (c.line != null && !c.selected_text) {
+            warnings.push({
+                severity: "warning",
+                code: "missing-selected-text",
+                message: "Comment has line anchors but no selected_text — anchoring will be fragile across edits",
+                path: `${prefix}/selected_text`,
+                commentId: c.id,
+            });
+        }
+    }
+}
+//# sourceMappingURL=validate-core.js.map