@greppleai/grip 0.0.0-stage → 0.1.3

package/dist/core/tools/hashline/apply.js

@@ -0,0 +1,261 @@
+import { cntLines } from "../hashline-utils.js";
+import { abortIf } from "../runtime.js";
+import { _lineHashesPure, HASH_SEP } from "./hash.js";
+import { assertNoBarePrefix, descEdit, fmtMismatch, valEdits, warnUnicodeEsc, } from "./resolve.js";
+export function buildIdx(content) {
+    const fileLines = content.split("\n");
+    const lineStarts = [];
+    let offset = 0;
+    for (let index = 0; index < fileLines.length; index++) {
+        lineStarts.push(offset);
+        offset += fileLines[index].length;
+        if (index < fileLines.length - 1) {
+            offset += 1;
+        }
+    }
+    return {
+        fileLines,
+        lineStarts,
+        hasTerminalNewline: content.endsWith("\n"),
+    };
+}
+function assertNotEmpty(originalContent, result) {
+    if (originalContent.length > 0 && result.length === 0) {
+        throw new Error("[E_WOULD_EMPTY] Cannot empty a non-empty file via edit.");
+    }
+}
+function throwConflict(left, right, reason) {
+    throw new Error(`[E_EDIT_CONFLICT] Edit ${left.index} (${left.label}) and edit ${right.index} (${right.label}) ${reason}.`);
+}
+function resToSpan(edit, index, content, lineIndex, noopEdits) {
+    const { fileLines, lineStarts } = lineIndex;
+    const startLine = edit.hash_range_inclusive[0].line;
+    const endLine = edit.hash_range_inclusive[1].line;
+    const originalLines = fileLines.slice(startLine - 1, endLine);
+    if (originalLines.length === edit.content_lines.length &&
+        originalLines.every((line, lineIndex) => line === edit.content_lines[lineIndex])) {
+        noopEdits.push({
+            editIndex: index,
+            loc: edit.hash_range_inclusive[0].hash,
+            currentContent: originalLines.join("\n"),
+        });
+        return null;
+    }
+    const label = descEdit(edit);
+    if (edit.content_lines.length > 0) {
+        return {
+            kind: "replace",
+            index,
+            label,
+            start: lineStarts[startLine - 1],
+            end: lineStarts[endLine - 1] + fileLines[endLine - 1].length,
+            replacement: edit.content_lines.join("\n"),
+        };
+    }
+    if (startLine === 1 && endLine === fileLines.length) {
+        return {
+            kind: "replace",
+            index,
+            label,
+            start: 0,
+            end: content.length,
+            replacement: "",
+        };
+    }
+    if (endLine < fileLines.length) {
+        return {
+            kind: "replace",
+            index,
+            label,
+            start: lineStarts[startLine - 1],
+            end: lineStarts[endLine],
+            replacement: "",
+        };
+    }
+    return {
+        kind: "replace",
+        index,
+        label,
+        start: Math.max(0, lineStarts[startLine - 1] - 1),
+        end: lineStarts[endLine - 1] + fileLines[endLine - 1].length,
+        replacement: "",
+    };
+}
+function assertNoConflict(spans) {
+    if (spans.length < 2)
+        return;
+    const ordered = [...spans].sort((left, right) => left.start - right.start || right.end - left.end || left.index - right.index);
+    let furthestEndSpan = ordered[0];
+    for (let index = 1; index < ordered.length; index++) {
+        const current = ordered[index];
+        if (furthestEndSpan.start < current.end && current.start < furthestEndSpan.end) {
+            const [left, right] = furthestEndSpan.index < current.index ? [furthestEndSpan, current] : [current, furthestEndSpan];
+            throwConflict(left, right, "overlap on the same original line range");
+        }
+        if (current.end > furthestEndSpan.end)
+            furthestEndSpan = current;
+    }
+}
+function resSpans(edits, content, lineIndex, noopEdits, signal) {
+    const seenSpanKeys = new Set();
+    const resolvedSpans = [];
+    for (const [index, edit] of edits.entries()) {
+        abortIf(signal);
+        const span = resToSpan(edit, index, content, lineIndex, noopEdits);
+        if (!span) {
+            continue;
+        }
+        const spanKey = `replace:${span.start}:${span.end}:${span.replacement}`;
+        if (seenSpanKeys.has(spanKey)) {
+            continue;
+        }
+        seenSpanKeys.add(spanKey);
+        resolvedSpans.push(span);
+    }
+    assertNoConflict(resolvedSpans);
+    return [...resolvedSpans].sort((left, right) => {
+        if (right.end !== left.end) {
+            return right.end - left.end;
+        }
+        return left.index - right.index;
+    });
+}
+function assemble(content, spans, signal) {
+    let result = content;
+    for (const span of spans) {
+        abortIf(signal);
+        result = result.slice(0, span.start) + span.replacement + result.slice(span.end);
+    }
+    return result;
+}
+/**
+ * Builds the boundary-duplication warning shown after an edit. A minimal header
+ * is followed by a hashline-anchored window: 2 lines of context before the
+ * duplicated pair, the pair itself, and 2 lines after. The window carries the
+ * post-edit hashes the model needs to remove the duplicate in a follow-up
+ * `replace` (no `read` round-trip required, since the hashes are current and
+ * staleness is per-line). Rows are plain `HASH│content` — no annotations.
+ */
+export function fmtBoundaryWarning(params) {
+    const header = params.kind === "trailing"
+        ? "Boundary duplication (trailing): the last replacement line duplicated the next line. This happens when `content_lines` includes a line that was already outside the replaced range. Delete the duplicate — the original line outside the range is still there."
+        : "Boundary duplication (leading): the first replacement line duplicated the previous line. This happens when `content_lines` includes a line that was already outside the replaced range. Delete the duplicate — the original line outside the range is still there.";
+    // Locate the adjacent duplicated pair (two identical neighboring lines). The
+    // occurrence-based matchIndex usually lands inside the pair; when a file has
+    // several identical lines we pick the pair nearest matchIndex so the window
+    // frames the duplication this edit introduced, not an unrelated one.
+    let pairStart = -1;
+    let bestDist = Infinity;
+    for (let i = 0; i < params.resultLines.length - 1; i++) {
+        if (params.resultLines[i] === params.survivingContent && params.resultLines[i + 1] === params.survivingContent) {
+            const dist = Math.abs(i - params.matchIndex);
+            if (dist < bestDist) {
+                bestDist = dist;
+                pairStart = i;
+            }
+        }
+    }
+    if (pairStart < 0)
+        pairStart = params.matchIndex;
+    const winStart = Math.max(0, pairStart - 2);
+    const winEnd = Math.min(params.resultLines.length - 1, pairStart + 3);
+    const rows = [];
+    for (let i = winStart; i <= winEnd; i++) {
+        rows.push(`${params.resultHashes[i]}${HASH_SEP}${params.resultLines[i]}`);
+    }
+    return `${header}\n\n${rows.join("\n")}`;
+}
+export function applyEdits(content, edits, signal, precomputedHashes, filePath) {
+    abortIf(signal);
+    if (!edits.length)
+        return {
+            content,
+            firstChangedLine: undefined,
+            lastChangedLine: undefined,
+        };
+    edits = edits.map((edit) => edit.content_lines.length === 1 && edit.content_lines[0] === "" ? { ...edit, content_lines: [] } : edit);
+    const lineIndex = buildIdx(content);
+    const fileHashes = precomputedHashes ?? _lineHashesPure(content);
+    const noopEdits = [];
+    const warnings = [];
+    const { resolved, mismatches, boundaryWarnings } = valEdits(edits, lineIndex.fileLines, fileHashes, warnings, signal);
+    if (mismatches.length) {
+        throw new Error(fmtMismatch(mismatches, lineIndex.fileLines, fileHashes, filePath));
+    }
+    assertNoBarePrefix(edits, lineIndex.fileLines, fileHashes);
+    warnUnicodeEsc(edits, warnings);
+    const orderedSpans = resSpans(resolved, content, lineIndex, noopEdits, signal);
+    const result = assemble(content, orderedSpans, signal);
+    assertNotEmpty(content, result);
+    const range = changedRange(content, result);
+    return {
+        content: result,
+        firstChangedLine: range?.firstChangedLine,
+        lastChangedLine: range?.lastChangedLine,
+        ...(warnings.length ? { warnings } : {}),
+        ...(noopEdits.length ? { noopEdits } : {}),
+        ...(boundaryWarnings.length ? { boundaryWarnings } : {}),
+    };
+}
+export function fmtRegion(hashes, lines) {
+    if (hashes.length !== lines.length) {
+        throw new Error(`fmtRegion: hashes.length (${hashes.length}) must match lines.length (${lines.length}).`);
+    }
+    return lines.map((line, index) => `${hashes[index]}${HASH_SEP}${line}`).join("\n");
+}
+function characterIndexToLineNumber(characterIndex, text) {
+    let line = 1;
+    for (let index = 0; index < characterIndex && index < text.length; index++) {
+        if (text[index] === "\n")
+            line++;
+    }
+    return line;
+}
+function resolveLastChangedLine(scan) {
+    if (scan.lastResultDifferenceIndex < scan.firstDifferenceIndex) {
+        return scan.result.length === 0 ? 1 : cntLines(scan.result);
+    }
+    if (scan.firstDifferenceIndex === 0 && scan.original.length > 0 && scan.result.endsWith(scan.original)) {
+        return scan.firstChangedLine;
+    }
+    return characterIndexToLineNumber(scan.lastResultDifferenceIndex + 1, scan.result);
+}
+export function changedRange(original, result) {
+    if (original === result)
+        return null;
+    if (original.length === 0) {
+        return {
+            firstChangedLine: 1,
+            lastChangedLine: cntLines(result),
+        };
+    }
+    if (result.startsWith(original) && original.endsWith("\n")) {
+        return {
+            firstChangedLine: cntLines(original) + 1,
+            lastChangedLine: cntLines(result),
+        };
+    }
+    let firstDiff = 0;
+    const minLen = Math.min(original.length, result.length);
+    while (firstDiff < minLen && original[firstDiff] === result[firstDiff]) {
+        firstDiff++;
+    }
+    if (firstDiff === minLen && original.length === result.length)
+        return null;
+    let lastOrig = original.length - 1;
+    let lastRes = result.length - 1;
+    while (lastOrig >= firstDiff && lastRes >= firstDiff && original[lastOrig] === result[lastRes]) {
+        lastOrig--;
+        lastRes--;
+    }
+    const firstChangedLine = characterIndexToLineNumber(firstDiff + 1, result);
+    const lastChangedLine = resolveLastChangedLine({
+        original,
+        result,
+        firstDifferenceIndex: firstDiff,
+        lastResultDifferenceIndex: lastRes,
+        firstChangedLine,
+    });
+    return { firstChangedLine, lastChangedLine };
+}
+//# sourceMappingURL=apply.js.map

package/dist/core/tools/hashline/apply.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"apply.js","sourceRoot":"","sources":["../../../../src/core/tools/hashline/apply.ts"],"names":[],"mappings":"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","sourcesContent":["import { cntLines } from \"../hashline-utils.ts\";\nimport { abortIf } from \"../runtime.ts\";\nimport { _lineHashesPure, HASH_SEP } from \"./hash.ts\";\nimport {\n\tassertNoBarePrefix,\n\ttype BDupWarn,\n\ttype BoundaryDuplicateKind,\n\tdescEdit,\n\tfmtMismatch,\n\ttype HEdit,\n\ttype NEdit,\n\ttype RHEdit,\n\tvalEdits,\n\twarnUnicodeEsc,\n} from \"./resolve.ts\";\n\ntype LIdx = {\n\tfileLines: string[];\n\tlineStarts: number[];\n\thasTerminalNewline: boolean;\n};\n\nexport function buildIdx(content: string): LIdx {\n\tconst fileLines = content.split(\"\\n\");\n\tconst lineStarts: number[] = [];\n\tlet offset = 0;\n\n\tfor (let index = 0; index < fileLines.length; index++) {\n\t\tlineStarts.push(offset);\n\t\toffset += fileLines[index]!.length;\n\t\tif (index < fileLines.length - 1) {\n\t\t\toffset += 1;\n\t\t}\n\t}\n\n\treturn {\n\t\tfileLines,\n\t\tlineStarts,\n\t\thasTerminalNewline: content.endsWith(\"\\n\"),\n\t};\n}\n\ntype RESpan = {\n\tkind: \"replace\";\n\tindex: number;\n\tlabel: string;\n\tstart: number;\n\tend: number;\n\treplacement: string;\n};\n\ninterface EditConflictSide {\n\tindex: number;\n\tlabel: string;\n}\n\ninterface BoundaryWarningFormatOptions {\n\tkind: BoundaryDuplicateKind;\n\tsurvivingContent: string;\n\tmatchIndex: number;\n\tresultLines: string[];\n\tresultHashes: string[];\n}\n\ninterface ChangedLineRange {\n\tfirstChangedLine: number;\n\tlastChangedLine: number;\n}\n\nexport interface ApplyEditsResult {\n\tcontent: string;\n\tfirstChangedLine: ChangedLineRange[\"firstChangedLine\"] | undefined;\n\tlastChangedLine: ChangedLineRange[\"lastChangedLine\"] | undefined;\n\twarnings?: string[];\n\tnoopEdits?: NEdit[];\n\tboundaryWarnings?: BDupWarn[];\n}\n\nfunction assertNotEmpty(originalContent: string, result: string): void {\n\tif (originalContent.length > 0 && result.length === 0) {\n\t\tthrow new Error(\"[E_WOULD_EMPTY] Cannot empty a non-empty file via edit.\");\n\t}\n}\n\nfunction throwConflict(left: EditConflictSide, right: EditConflictSide, reason: string): never {\n\tthrow new Error(\n\t\t`[E_EDIT_CONFLICT] Edit ${left.index} (${left.label}) and edit ${right.index} (${right.label}) ${reason}.`,\n\t);\n}\n\nfunction resToSpan(edit: RHEdit, index: number, content: string, lineIndex: LIdx, noopEdits: NEdit[]): RESpan | null {\n\tconst { fileLines, lineStarts } = lineIndex;\n\n\tconst startLine = edit.hash_range_inclusive[0].line;\n\tconst endLine = edit.hash_range_inclusive[1].line;\n\tconst originalLines = fileLines.slice(startLine - 1, endLine);\n\tif (\n\t\toriginalLines.length === edit.content_lines.length &&\n\t\toriginalLines.every((line, lineIndex) => line === edit.content_lines[lineIndex])\n\t) {\n\t\tnoopEdits.push({\n\t\t\teditIndex: index,\n\t\t\tloc: edit.hash_range_inclusive[0].hash,\n\t\t\tcurrentContent: originalLines.join(\"\\n\"),\n\t\t});\n\t\treturn null;\n\t}\n\n\tconst label = descEdit(edit);\n\n\tif (edit.content_lines.length > 0) {\n\t\treturn {\n\t\t\tkind: \"replace\",\n\t\t\tindex,\n\t\t\tlabel,\n\t\t\tstart: lineStarts[startLine - 1]!,\n\t\t\tend: lineStarts[endLine - 1]! + fileLines[endLine - 1]!.length,\n\t\t\treplacement: edit.content_lines.join(\"\\n\"),\n\t\t};\n\t}\n\n\tif (startLine === 1 && endLine === fileLines.length) {\n\t\treturn {\n\t\t\tkind: \"replace\",\n\t\t\tindex,\n\t\t\tlabel,\n\t\t\tstart: 0,\n\t\t\tend: content.length,\n\t\t\treplacement: \"\",\n\t\t};\n\t}\n\n\tif (endLine < fileLines.length) {\n\t\treturn {\n\t\t\tkind: \"replace\",\n\t\t\tindex,\n\t\t\tlabel,\n\t\t\tstart: lineStarts[startLine - 1]!,\n\t\t\tend: lineStarts[endLine]!,\n\t\t\treplacement: \"\",\n\t\t};\n\t}\n\n\treturn {\n\t\tkind: \"replace\",\n\t\tindex,\n\t\tlabel,\n\t\tstart: Math.max(0, lineStarts[startLine - 1]! - 1),\n\t\tend: lineStarts[endLine - 1]! + fileLines[endLine - 1]!.length,\n\t\treplacement: \"\",\n\t};\n}\n\nfunction assertNoConflict(spans: RESpan[]): void {\n\tif (spans.length < 2) return;\n\tconst ordered = [...spans].sort(\n\t\t(left, right) => left.start - right.start || right.end - left.end || left.index - right.index,\n\t);\n\tlet furthestEndSpan = ordered[0]!;\n\tfor (let index = 1; index < ordered.length; index++) {\n\t\tconst current = ordered[index]!;\n\t\tif (furthestEndSpan.start < current.end && current.start < furthestEndSpan.end) {\n\t\t\tconst [left, right] =\n\t\t\t\tfurthestEndSpan.index < current.index ? [furthestEndSpan, current] : [current, furthestEndSpan];\n\t\t\tthrowConflict(left, right, \"overlap on the same original line range\");\n\t\t}\n\t\tif (current.end > furthestEndSpan.end) furthestEndSpan = current;\n\t}\n}\n\nfunction resSpans(\n\tedits: RHEdit[],\n\tcontent: string,\n\tlineIndex: LIdx,\n\tnoopEdits: NEdit[],\n\tsignal: AbortSignal | undefined,\n): RESpan[] {\n\tconst seenSpanKeys = new Set<string>();\n\tconst resolvedSpans: RESpan[] = [];\n\tfor (const [index, edit] of edits.entries()) {\n\t\tabortIf(signal);\n\t\tconst span = resToSpan(edit, index, content, lineIndex, noopEdits);\n\t\tif (!span) {\n\t\t\tcontinue;\n\t\t}\n\n\t\tconst spanKey = `replace:${span.start}:${span.end}:${span.replacement}`;\n\t\tif (seenSpanKeys.has(spanKey)) {\n\t\t\tcontinue;\n\t\t}\n\t\tseenSpanKeys.add(spanKey);\n\t\tresolvedSpans.push(span);\n\t}\n\n\tassertNoConflict(resolvedSpans);\n\treturn [...resolvedSpans].sort((left, right) => {\n\t\tif (right.end !== left.end) {\n\t\t\treturn right.end - left.end;\n\t\t}\n\t\treturn left.index - right.index;\n\t});\n}\n\nfunction assemble(content: string, spans: RESpan[], signal: AbortSignal | undefined): string {\n\tlet result = content;\n\tfor (const span of spans) {\n\t\tabortIf(signal);\n\t\tresult = result.slice(0, span.start) + span.replacement + result.slice(span.end);\n\t}\n\treturn result;\n}\n\n/**\n * Builds the boundary-duplication warning shown after an edit. A minimal header\n * is followed by a hashline-anchored window: 2 lines of context before the\n * duplicated pair, the pair itself, and 2 lines after. The window carries the\n * post-edit hashes the model needs to remove the duplicate in a follow-up\n * `replace` (no `read` round-trip required, since the hashes are current and\n * staleness is per-line). Rows are plain `HASH│content` — no annotations.\n */\nexport function fmtBoundaryWarning(params: BoundaryWarningFormatOptions): string {\n\tconst header =\n\t\tparams.kind === \"trailing\"\n\t\t\t? \"Boundary duplication (trailing): the last replacement line duplicated the next line. This happens when `content_lines` includes a line that was already outside the replaced range. Delete the duplicate — the original line outside the range is still there.\"\n\t\t\t: \"Boundary duplication (leading): the first replacement line duplicated the previous line. This happens when `content_lines` includes a line that was already outside the replaced range. Delete the duplicate — the original line outside the range is still there.\";\n\n\t// Locate the adjacent duplicated pair (two identical neighboring lines). The\n\t// occurrence-based matchIndex usually lands inside the pair; when a file has\n\t// several identical lines we pick the pair nearest matchIndex so the window\n\t// frames the duplication this edit introduced, not an unrelated one.\n\tlet pairStart = -1;\n\tlet bestDist = Infinity;\n\tfor (let i = 0; i < params.resultLines.length - 1; i++) {\n\t\tif (params.resultLines[i] === params.survivingContent && params.resultLines[i + 1] === params.survivingContent) {\n\t\t\tconst dist = Math.abs(i - params.matchIndex);\n\t\t\tif (dist < bestDist) {\n\t\t\t\tbestDist = dist;\n\t\t\t\tpairStart = i;\n\t\t\t}\n\t\t}\n\t}\n\tif (pairStart < 0) pairStart = params.matchIndex;\n\n\tconst winStart = Math.max(0, pairStart - 2);\n\tconst winEnd = Math.min(params.resultLines.length - 1, pairStart + 3);\n\n\tconst rows: string[] = [];\n\tfor (let i = winStart; i <= winEnd; i++) {\n\t\trows.push(`${params.resultHashes[i]}${HASH_SEP}${params.resultLines[i]}`);\n\t}\n\treturn `${header}\\n\\n${rows.join(\"\\n\")}`;\n}\n\nexport function applyEdits(\n\tcontent: string,\n\tedits: HEdit[],\n\tsignal?: AbortSignal,\n\tprecomputedHashes?: string[],\n\tfilePath?: string,\n): ApplyEditsResult {\n\tabortIf(signal);\n\tif (!edits.length)\n\t\treturn {\n\t\t\tcontent,\n\t\t\tfirstChangedLine: undefined,\n\t\t\tlastChangedLine: undefined,\n\t\t};\n\n\tedits = edits.map((edit) =>\n\t\tedit.content_lines.length === 1 && edit.content_lines[0] === \"\" ? { ...edit, content_lines: [] } : edit,\n\t);\n\n\tconst lineIndex = buildIdx(content);\n\tconst fileHashes = precomputedHashes ?? _lineHashesPure(content);\n\tconst noopEdits: NEdit[] = [];\n\tconst warnings: string[] = [];\n\n\tconst { resolved, mismatches, boundaryWarnings } = valEdits(\n\t\tedits,\n\t\tlineIndex.fileLines,\n\t\tfileHashes,\n\t\twarnings,\n\t\tsignal,\n\t);\n\tif (mismatches.length) {\n\t\tthrow new Error(fmtMismatch(mismatches, lineIndex.fileLines, fileHashes, filePath));\n\t}\n\n\tassertNoBarePrefix(edits, lineIndex.fileLines, fileHashes);\n\twarnUnicodeEsc(edits, warnings);\n\n\tconst orderedSpans = resSpans(resolved, content, lineIndex, noopEdits, signal);\n\n\tconst result = assemble(content, orderedSpans, signal);\n\tassertNotEmpty(content, result);\n\tconst range = changedRange(content, result);\n\n\treturn {\n\t\tcontent: result,\n\t\tfirstChangedLine: range?.firstChangedLine,\n\t\tlastChangedLine: range?.lastChangedLine,\n\t\t...(warnings.length ? { warnings } : {}),\n\t\t...(noopEdits.length ? { noopEdits } : {}),\n\t\t...(boundaryWarnings.length ? { boundaryWarnings } : {}),\n\t};\n}\n\nexport function fmtRegion(hashes: string[], lines: string[]): string {\n\tif (hashes.length !== lines.length) {\n\t\tthrow new Error(`fmtRegion: hashes.length (${hashes.length}) must match lines.length (${lines.length}).`);\n\t}\n\treturn lines.map((line, index) => `${hashes[index]}${HASH_SEP}${line}`).join(\"\\n\");\n}\nfunction characterIndexToLineNumber(characterIndex: number, text: string): number {\n\tlet line = 1;\n\tfor (let index = 0; index < characterIndex && index < text.length; index++) {\n\t\tif (text[index] === \"\\n\") line++;\n\t}\n\treturn line;\n}\ninterface ChangedRangeScan {\n\toriginal: string;\n\tresult: string;\n\tfirstDifferenceIndex: number;\n\tlastResultDifferenceIndex: number;\n\tfirstChangedLine: number;\n}\n\nfunction resolveLastChangedLine(scan: ChangedRangeScan): number {\n\tif (scan.lastResultDifferenceIndex < scan.firstDifferenceIndex) {\n\t\treturn scan.result.length === 0 ? 1 : cntLines(scan.result);\n\t}\n\tif (scan.firstDifferenceIndex === 0 && scan.original.length > 0 && scan.result.endsWith(scan.original)) {\n\t\treturn scan.firstChangedLine;\n\t}\n\treturn characterIndexToLineNumber(scan.lastResultDifferenceIndex + 1, scan.result);\n}\n\nexport function changedRange(original: string, result: string): ChangedLineRange | null {\n\tif (original === result) return null;\n\n\tif (original.length === 0) {\n\t\treturn {\n\t\t\tfirstChangedLine: 1,\n\t\t\tlastChangedLine: cntLines(result),\n\t\t};\n\t}\n\n\tif (result.startsWith(original) && original.endsWith(\"\\n\")) {\n\t\treturn {\n\t\t\tfirstChangedLine: cntLines(original) + 1,\n\t\t\tlastChangedLine: cntLines(result),\n\t\t};\n\t}\n\n\tlet firstDiff = 0;\n\tconst minLen = Math.min(original.length, result.length);\n\twhile (firstDiff < minLen && original[firstDiff] === result[firstDiff]) {\n\t\tfirstDiff++;\n\t}\n\tif (firstDiff === minLen && original.length === result.length) return null;\n\n\tlet lastOrig = original.length - 1;\n\tlet lastRes = result.length - 1;\n\twhile (lastOrig >= firstDiff && lastRes >= firstDiff && original[lastOrig] === result[lastRes]) {\n\t\tlastOrig--;\n\t\tlastRes--;\n\t}\n\n\tconst firstChangedLine = characterIndexToLineNumber(firstDiff + 1, result);\n\tconst lastChangedLine = resolveLastChangedLine({\n\t\toriginal,\n\t\tresult,\n\t\tfirstDifferenceIndex: firstDiff,\n\t\tlastResultDifferenceIndex: lastRes,\n\t\tfirstChangedLine,\n\t});\n\n\treturn { firstChangedLine, lastChangedLine };\n}\n"]}

package/dist/core/tools/hashline/hash.d.ts

@@ -0,0 +1,56 @@
+export declare const HASH_LEN = 3;
+export declare const ANCHOR_LEN = 3;
+/**
+ * The `│` (U+2502) delimiter between a hash anchor and its line content. This
+ * is the wire-format separator in `HASH│content` rows. Kept as a constant so
+ * every construction site resolves the same delimiter.
+ */
+export declare const HASH_SEP = "\u2502";
+declare const ALPH_RE: RegExp;
+export declare const HASH_CLASS: string;
+export declare const HL_PREFIX_RE: RegExp;
+export declare const HL_PREFIX_PLUS_RE: RegExp;
+export declare const DIFF_MINUS_RE: RegExp;
+export declare const HL_BARE_PREFIX_RE: RegExp;
+type Hasher = {
+    h32(input: string, seed?: number): number;
+};
+export declare function initHasher(): Promise<Hasher>;
+/**
+ * Pure hash computation — no I/O, no persistence. Used internally by the
+ * stable path and as a fallback when no file path is available.
+ * Each line is hashed with xxHash32 over its canonical form (trailing
+ * whitespace and CR characters stripped). If the base hash collides with a
+ * hash already assigned to an earlier line, a retry counter (`:R{retry}`)
+ * is appended to the canonical content and the hash is recomputed until a
+ * unique anchor is found. This perfect-hashing step guarantees every line
+ * in a file receives a distinct anchor, even when multiple lines contain
+ * identical text (e.g. repeated `}` or `import` statements).
+ */
+export declare function _lineHashesPure(content: string): string[];
+interface PreviousLineHashSnapshot {
+    content: string;
+    hashes: string[];
+    removedHashes?: Set<string>;
+}
+/**
+ * Stable, persistent-aware hash computation.
+ *
+ * When `path` is provided, uses the persistent hash store to preserve
+ * hashes for unchanged lines across edits. When `previous` is also
+ * provided (called from the replace pipeline), diffs the previous content
+ * against the new content and copies hashes for unchanged lines to their
+ * new positions. New/changed lines allocate fresh hashes with collision
+ * avoidance against the preserved set.
+ *
+ * When `path` is provided without `previous` (called from read), loads
+ * the stored snapshot for that path. If the content matches, returns the
+ * saved hashes. Otherwise computes fresh hashes via `_lineHashesPure` and
+ * saves a new snapshot.
+ *
+ * When `path` is not provided, falls back to `_lineHashesPure` (for
+ * backward compatibility and tests that don't need persistence).
+ */
+export declare function lineHashes(content: string, path?: string, previous?: PreviousLineHashSnapshot): Promise<string[]>;
+export { ALPH_RE };
+//# sourceMappingURL=hash.d.ts.map

package/dist/core/tools/hashline/hash.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"hash.d.ts","sourceRoot":"","sources":["../../../../src/core/tools/hashline/hash.ts"],"names":[],"mappings":"AAGA,eAAO,MAAM,QAAQ,IAAI,CAAC;AAC1B,eAAO,MAAM,UAAU,IAAW,CAAC;AAEnC;;;;GAIG;AACH,eAAO,MAAM,QAAQ,WAAM,CAAC;AAM5B,QAAA,MAAM,OAAO,QAAkC,CAAC;AAChD,eAAO,MAAM,UAAU,QAAgC,CAAC;AAaxD,eAAO,MAAM,YAAY,QAAmD,CAAC;AAC7E,eAAO,MAAM,iBAAiB,QAAuC,CAAC;AACtE,eAAO,MAAM,aAAa,QAAkB,CAAC;AAE7C,eAAO,MAAM,iBAAiB,QAAsC,CAAC;AAErE,KAAK,MAAM,GAAG;IAAE,GAAG,CAAC,KAAK,EAAE,MAAM,EAAE,IAAI,CAAC,EAAE,MAAM,GAAG,MAAM,CAAA;CAAE,CAAC;AAmB5D,wBAAgB,UAAU,IAAI,OAAO,CAAC,MAAM,CAAC,CAE5C;AAUD;;;;;;;;;;GAUG;AACH,wBAAgB,eAAe,CAAC,OAAO,EAAE,MAAM,GAAG,MAAM,EAAE,CAgBzD;AAED,UAAU,wBAAwB;IACjC,OAAO,EAAE,MAAM,CAAC;IAChB,MAAM,EAAE,MAAM,EAAE,CAAC;IACjB,aAAa,CAAC,EAAE,GAAG,CAAC,MAAM,CAAC,CAAC;CAC5B;AAED;;;;;;;;;;;;;;;;;GAiBG;AACH,wBAAsB,UAAU,CAC/B,OAAO,EAAE,MAAM,EACf,IAAI,CAAC,EAAE,MAAM,EACb,QAAQ,CAAC,EAAE,wBAAwB,GACjC,OAAO,CAAC,MAAM,EAAE,CAAC,CA0BnB;AAkGD,OAAO,EAAE,OAAO,EAAE,CAAC","sourcesContent":["import xxhash from \"xxhash-wasm\";\nimport { loadHashStore, saveHashStore } from \"../hash-store.ts\";\n\nexport const HASH_LEN = 3;\nexport const ANCHOR_LEN = HASH_LEN;\n\n/**\n * The `│` (U+2502) delimiter between a hash anchor and its line content. This\n * is the wire-format separator in `HASH│content` rows. Kept as a constant so\n * every construction site resolves the same delimiter.\n */\nexport const HASH_SEP = \"│\";\n\nconst ALPH = \"ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789-_\";\nconst ALPH_BITS = 6;\nconst ALPH_MASK = (1 << ALPH_BITS) - 1;\nconst ALPH_SAFE = ALPH.replace(/-/g, \"\\\\-\");\nconst ALPH_RE = new RegExp(`^[${ALPH_SAFE}]+$`);\nexport const HASH_CLASS = `[${ALPH_SAFE}]{${HASH_LEN}}`;\n\nfunction h2s(h: number): string {\n\tconst totalBits = HASH_LEN * ALPH_BITS;\n\tconst shift = 32 - totalBits;\n\tconst n = h >>> shift;\n\tlet out = \"\";\n\tfor (let j = 0; j < HASH_LEN; j++) {\n\t\tout += ALPH[(n >>> ((HASH_LEN - 1 - j) * ALPH_BITS)) & ALPH_MASK]!;\n\t}\n\treturn out;\n}\n\nexport const HL_PREFIX_RE = new RegExp(`^\\\\s*(?:>>>|>>)?\\\\s*${HASH_CLASS}│`);\nexport const HL_PREFIX_PLUS_RE = new RegExp(`^\\\\+\\\\s*${HASH_CLASS}│`);\nexport const DIFF_MINUS_RE = /^-\\s*\\d+\\s{4}/;\n\nexport const HL_BARE_PREFIX_RE = new RegExp(`^\\\\s*(${HASH_CLASS})│`);\n\ntype Hasher = { h32(input: string, seed?: number): number };\nlet hasherP: Promise<Hasher> | null = null;\nlet hasher: Hasher | null = null;\n\nfunction getH(): Hasher {\n\tif (hasher) return hasher;\n\tthrow new Error(\"xxhash-wasm not initialized yet. This should not happen.\");\n}\n\nhasherP = xxhash()\n\t.then((h) => {\n\t\thasher = h;\n\t\treturn h;\n\t})\n\t.catch((err) => {\n\t\tconsole.error(\"xxhash-wasm initialization failed:\", err);\n\t\tthrow err;\n\t});\n\nexport function initHasher(): Promise<Hasher> {\n\treturn hasherP!;\n}\n\nfunction xxh32(input: string, seed = 0): number {\n\treturn getH().h32(input, seed) >>> 0;\n}\n\nfunction canon(line: string): string {\n\treturn line.replace(/\\r/g, \"\").trimEnd();\n}\n\n/**\n * Pure hash computation — no I/O, no persistence. Used internally by the\n * stable path and as a fallback when no file path is available.\n * Each line is hashed with xxHash32 over its canonical form (trailing\n * whitespace and CR characters stripped). If the base hash collides with a\n * hash already assigned to an earlier line, a retry counter (`:R{retry}`)\n * is appended to the canonical content and the hash is recomputed until a\n * unique anchor is found. This perfect-hashing step guarantees every line\n * in a file receives a distinct anchor, even when multiple lines contain\n * identical text (e.g. repeated `}` or `import` statements).\n */\nexport function _lineHashesPure(content: string): string[] {\n\tconst lines = content.split(\"\\n\");\n\tconst hashes = new Array<string>(lines.length);\n\tconst assigned = new Set<string>();\n\tfor (let i = 0; i < lines.length; i++) {\n\t\tconst c = canon(lines[i]!);\n\t\tlet hash = h2s(xxh32(c));\n\t\tlet retry = 0;\n\t\twhile (assigned.has(hash)) {\n\t\t\tretry++;\n\t\t\thash = h2s(xxh32(`${c}:R${retry}`));\n\t\t}\n\t\tassigned.add(hash);\n\t\thashes[i] = hash;\n\t}\n\treturn hashes;\n}\n\ninterface PreviousLineHashSnapshot {\n\tcontent: string;\n\thashes: string[];\n\tremovedHashes?: Set<string>;\n}\n\n/**\n * Stable, persistent-aware hash computation.\n *\n * When `path` is provided, uses the persistent hash store to preserve\n * hashes for unchanged lines across edits. When `previous` is also\n * provided (called from the replace pipeline), diffs the previous content\n * against the new content and copies hashes for unchanged lines to their\n * new positions. New/changed lines allocate fresh hashes with collision\n * avoidance against the preserved set.\n *\n * When `path` is provided without `previous` (called from read), loads\n * the stored snapshot for that path. If the content matches, returns the\n * saved hashes. Otherwise computes fresh hashes via `_lineHashesPure` and\n * saves a new snapshot.\n *\n * When `path` is not provided, falls back to `_lineHashesPure` (for\n * backward compatibility and tests that don't need persistence).\n */\nexport async function lineHashes(\n\tcontent: string,\n\tpath?: string,\n\tprevious?: PreviousLineHashSnapshot,\n): Promise<string[]> {\n\tif (!path) {\n\t\treturn _lineHashesPure(content);\n\t}\n\n\tconst store = await loadHashStore();\n\n\t// Case 1: previous content provided (replace pipeline) — diff and preserve\n\tif (previous) {\n\t\tconst newHashes = mapStableHashes(previous.content, previous.hashes, content, previous.removedHashes);\n\t\tstore.snapshots[path] = { content, hashes: newHashes };\n\t\tawait saveHashStore(store);\n\t\treturn newHashes;\n\t}\n\n\t// Case 2: no previous — check snapshot or compute fresh\n\tconst snapshot = store.snapshots[path];\n\tif (snapshot && snapshot.content === content) {\n\t\treturn snapshot.hashes;\n\t}\n\n\t// Compute fresh hashes\n\tconst newHashes = _lineHashesPure(content);\n\tstore.snapshots[path] = { content, hashes: newHashes };\n\tawait saveHashStore(store);\n\treturn newHashes;\n}\n\ninterface PreviousLineHashCandidate {\n\tindex: number;\n\thash: string;\n}\n\ninterface ReusedLineHashes {\n\thashes: string[];\n\tused: Set<string>;\n}\n\nfunction buildPreviousLineHashCandidates(\n\toldContent: string,\n\toldHashes: string[],\n): Map<string, PreviousLineHashCandidate[]> {\n\tconst candidatesByContent = new Map<string, PreviousLineHashCandidate[]>();\n\tconst oldLines = oldContent.split(\"\\n\");\n\tfor (let index = 0; index < oldLines.length; index++) {\n\t\tconst line = oldLines[index]!;\n\t\tconst candidate = { index, hash: oldHashes[index]! };\n\t\tconst candidates = candidatesByContent.get(line);\n\t\tif (candidates) candidates.push(candidate);\n\t\telse candidatesByContent.set(line, [candidate]);\n\t}\n\treturn candidatesByContent;\n}\n\nfunction takePreferredPreviousLineHash(\n\tcandidates: PreviousLineHashCandidate[],\n\tremovedHashes: Set<string> | undefined,\n): string {\n\tlet preferredIndex = 0;\n\tif (removedHashes && removedHashes.size > 0) {\n\t\tfor (let index = 0; index < candidates.length; index++) {\n\t\t\tif (!removedHashes.has(candidates[index]!.hash)) {\n\t\t\t\tpreferredIndex = index;\n\t\t\t\tbreak;\n\t\t\t}\n\t\t}\n\t}\n\treturn candidates.splice(preferredIndex, 1)[0]!.hash;\n}\n\nfunction reusePreviousLineHashes(\n\tnewLines: string[],\n\tcandidatesByContent: Map<string, PreviousLineHashCandidate[]>,\n\tremovedHashes: Set<string> | undefined,\n): ReusedLineHashes {\n\tconst hashes = new Array<string>(newLines.length);\n\tconst used = new Set<string>();\n\tfor (let index = 0; index < newLines.length; index++) {\n\t\tconst candidates = candidatesByContent.get(newLines[index]!);\n\t\tif (!candidates || candidates.length === 0) continue;\n\t\tconst hash = takePreferredPreviousLineHash(candidates, removedHashes);\n\t\thashes[index] = hash;\n\t\tused.add(hash);\n\t}\n\treturn { hashes, used };\n}\n\nfunction fillFreshLineHashes(newLines: string[], hashes: string[], used: Set<string>): void {\n\tfor (let index = 0; index < newLines.length; index++) {\n\t\tif (hashes[index]) continue;\n\t\tconst canonicalLine = canon(newLines[index]!);\n\t\tlet retry = 0;\n\t\tlet hash = h2s(xxh32(canonicalLine));\n\t\twhile (used.has(hash)) {\n\t\t\tretry++;\n\t\t\thash = h2s(xxh32(`${canonicalLine}:R${retry}`));\n\t\t}\n\t\tused.add(hash);\n\t\thashes[index] = hash;\n\t}\n}\n\n/**\n * Maps old hashes to new positions using hash-aware content matching.\n * Unlike Diff.diffLines (which is content-only and cannot distinguish\n * identical lines at different positions), this algorithm uses the\n * removedHashes set to disambiguate: when a line appears multiple times\n * in the old content and one occurrence was targeted by the edit,\n * the surviving occurrence is matched to the non-removed hash.\n * New/changed lines allocate fresh hashes with collision avoidance.\n */\nfunction mapStableHashes(\n\toldContent: string,\n\toldHashes: string[],\n\tnewContent: string,\n\tremovedHashes?: Set<string>,\n): string[] {\n\tconst newLines = newContent.split(\"\\n\");\n\tconst candidatesByContent = buildPreviousLineHashCandidates(oldContent, oldHashes);\n\tconst { hashes, used } = reusePreviousLineHashes(newLines, candidatesByContent, removedHashes);\n\tfillFreshLineHashes(newLines, hashes, used);\n\treturn hashes;\n}\n\nexport { ALPH_RE };\n"]}

package/dist/core/tools/hashline/hash.js

@@ -0,0 +1,196 @@
+import xxhash from "xxhash-wasm";
+import { loadHashStore, saveHashStore } from "../hash-store.js";
+export const HASH_LEN = 3;
+export const ANCHOR_LEN = HASH_LEN;
+/**
+ * The `│` (U+2502) delimiter between a hash anchor and its line content. This
+ * is the wire-format separator in `HASH│content` rows. Kept as a constant so
+ * every construction site resolves the same delimiter.
+ */
+export const HASH_SEP = "│";
+const ALPH = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789-_";
+const ALPH_BITS = 6;
+const ALPH_MASK = (1 << ALPH_BITS) - 1;
+const ALPH_SAFE = ALPH.replace(/-/g, "\\-");
+const ALPH_RE = new RegExp(`^[${ALPH_SAFE}]+$`);
+export const HASH_CLASS = `[${ALPH_SAFE}]{${HASH_LEN}}`;
+function h2s(h) {
+    const totalBits = HASH_LEN * ALPH_BITS;
+    const shift = 32 - totalBits;
+    const n = h >>> shift;
+    let out = "";
+    for (let j = 0; j < HASH_LEN; j++) {
+        out += ALPH[(n >>> ((HASH_LEN - 1 - j) * ALPH_BITS)) & ALPH_MASK];
+    }
+    return out;
+}
+export const HL_PREFIX_RE = new RegExp(`^\\s*(?:>>>|>>)?\\s*${HASH_CLASS}│`);
+export const HL_PREFIX_PLUS_RE = new RegExp(`^\\+\\s*${HASH_CLASS}│`);
+export const DIFF_MINUS_RE = /^-\s*\d+\s{4}/;
+export const HL_BARE_PREFIX_RE = new RegExp(`^\\s*(${HASH_CLASS})│`);
+let hasherP = null;
+let hasher = null;
+function getH() {
+    if (hasher)
+        return hasher;
+    throw new Error("xxhash-wasm not initialized yet. This should not happen.");
+}
+hasherP = xxhash()
+    .then((h) => {
+    hasher = h;
+    return h;
+})
+    .catch((err) => {
+    console.error("xxhash-wasm initialization failed:", err);
+    throw err;
+});
+export function initHasher() {
+    return hasherP;
+}
+function xxh32(input, seed = 0) {
+    return getH().h32(input, seed) >>> 0;
+}
+function canon(line) {
+    return line.replace(/\r/g, "").trimEnd();
+}
+/**
+ * Pure hash computation — no I/O, no persistence. Used internally by the
+ * stable path and as a fallback when no file path is available.
+ * Each line is hashed with xxHash32 over its canonical form (trailing
+ * whitespace and CR characters stripped). If the base hash collides with a
+ * hash already assigned to an earlier line, a retry counter (`:R{retry}`)
+ * is appended to the canonical content and the hash is recomputed until a
+ * unique anchor is found. This perfect-hashing step guarantees every line
+ * in a file receives a distinct anchor, even when multiple lines contain
+ * identical text (e.g. repeated `}` or `import` statements).
+ */
+export function _lineHashesPure(content) {
+    const lines = content.split("\n");
+    const hashes = new Array(lines.length);
+    const assigned = new Set();
+    for (let i = 0; i < lines.length; i++) {
+        const c = canon(lines[i]);
+        let hash = h2s(xxh32(c));
+        let retry = 0;
+        while (assigned.has(hash)) {
+            retry++;
+            hash = h2s(xxh32(`${c}:R${retry}`));
+        }
+        assigned.add(hash);
+        hashes[i] = hash;
+    }
+    return hashes;
+}
+/**
+ * Stable, persistent-aware hash computation.
+ *
+ * When `path` is provided, uses the persistent hash store to preserve
+ * hashes for unchanged lines across edits. When `previous` is also
+ * provided (called from the replace pipeline), diffs the previous content
+ * against the new content and copies hashes for unchanged lines to their
+ * new positions. New/changed lines allocate fresh hashes with collision
+ * avoidance against the preserved set.
+ *
+ * When `path` is provided without `previous` (called from read), loads
+ * the stored snapshot for that path. If the content matches, returns the
+ * saved hashes. Otherwise computes fresh hashes via `_lineHashesPure` and
+ * saves a new snapshot.
+ *
+ * When `path` is not provided, falls back to `_lineHashesPure` (for
+ * backward compatibility and tests that don't need persistence).
+ */
+export async function lineHashes(content, path, previous) {
+    if (!path) {
+        return _lineHashesPure(content);
+    }
+    const store = await loadHashStore();
+    // Case 1: previous content provided (replace pipeline) — diff and preserve
+    if (previous) {
+        const newHashes = mapStableHashes(previous.content, previous.hashes, content, previous.removedHashes);
+        store.snapshots[path] = { content, hashes: newHashes };
+        await saveHashStore(store);
+        return newHashes;
+    }
+    // Case 2: no previous — check snapshot or compute fresh
+    const snapshot = store.snapshots[path];
+    if (snapshot && snapshot.content === content) {
+        return snapshot.hashes;
+    }
+    // Compute fresh hashes
+    const newHashes = _lineHashesPure(content);
+    store.snapshots[path] = { content, hashes: newHashes };
+    await saveHashStore(store);
+    return newHashes;
+}
+function buildPreviousLineHashCandidates(oldContent, oldHashes) {
+    const candidatesByContent = new Map();
+    const oldLines = oldContent.split("\n");
+    for (let index = 0; index < oldLines.length; index++) {
+        const line = oldLines[index];
+        const candidate = { index, hash: oldHashes[index] };
+        const candidates = candidatesByContent.get(line);
+        if (candidates)
+            candidates.push(candidate);
+        else
+            candidatesByContent.set(line, [candidate]);
+    }
+    return candidatesByContent;
+}
+function takePreferredPreviousLineHash(candidates, removedHashes) {
+    let preferredIndex = 0;
+    if (removedHashes && removedHashes.size > 0) {
+        for (let index = 0; index < candidates.length; index++) {
+            if (!removedHashes.has(candidates[index].hash)) {
+                preferredIndex = index;
+                break;
+            }
+        }
+    }
+    return candidates.splice(preferredIndex, 1)[0].hash;
+}
+function reusePreviousLineHashes(newLines, candidatesByContent, removedHashes) {
+    const hashes = new Array(newLines.length);
+    const used = new Set();
+    for (let index = 0; index < newLines.length; index++) {
+        const candidates = candidatesByContent.get(newLines[index]);
+        if (!candidates || candidates.length === 0)
+            continue;
+        const hash = takePreferredPreviousLineHash(candidates, removedHashes);
+        hashes[index] = hash;
+        used.add(hash);
+    }
+    return { hashes, used };
+}
+function fillFreshLineHashes(newLines, hashes, used) {
+    for (let index = 0; index < newLines.length; index++) {
+        if (hashes[index])
+            continue;
+        const canonicalLine = canon(newLines[index]);
+        let retry = 0;
+        let hash = h2s(xxh32(canonicalLine));
+        while (used.has(hash)) {
+            retry++;
+            hash = h2s(xxh32(`${canonicalLine}:R${retry}`));
+        }
+        used.add(hash);
+        hashes[index] = hash;
+    }
+}
+/**
+ * Maps old hashes to new positions using hash-aware content matching.
+ * Unlike Diff.diffLines (which is content-only and cannot distinguish
+ * identical lines at different positions), this algorithm uses the
+ * removedHashes set to disambiguate: when a line appears multiple times
+ * in the old content and one occurrence was targeted by the edit,
+ * the surviving occurrence is matched to the non-removed hash.
+ * New/changed lines allocate fresh hashes with collision avoidance.
+ */
+function mapStableHashes(oldContent, oldHashes, newContent, removedHashes) {
+    const newLines = newContent.split("\n");
+    const candidatesByContent = buildPreviousLineHashCandidates(oldContent, oldHashes);
+    const { hashes, used } = reusePreviousLineHashes(newLines, candidatesByContent, removedHashes);
+    fillFreshLineHashes(newLines, hashes, used);
+    return hashes;
+}
+export { ALPH_RE };
+//# sourceMappingURL=hash.js.map

package/dist/core/tools/hashline/hash.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"hash.js","sourceRoot":"","sources":["../../../../src/core/tools/hashline/hash.ts"],"names":[],"mappings":"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","sourcesContent":["import xxhash from \"xxhash-wasm\";\nimport { loadHashStore, saveHashStore } from \"../hash-store.ts\";\n\nexport const HASH_LEN = 3;\nexport const ANCHOR_LEN = HASH_LEN;\n\n/**\n * The `│` (U+2502) delimiter between a hash anchor and its line content. This\n * is the wire-format separator in `HASH│content` rows. Kept as a constant so\n * every construction site resolves the same delimiter.\n */\nexport const HASH_SEP = \"│\";\n\nconst ALPH = \"ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789-_\";\nconst ALPH_BITS = 6;\nconst ALPH_MASK = (1 << ALPH_BITS) - 1;\nconst ALPH_SAFE = ALPH.replace(/-/g, \"\\\\-\");\nconst ALPH_RE = new RegExp(`^[${ALPH_SAFE}]+$`);\nexport const HASH_CLASS = `[${ALPH_SAFE}]{${HASH_LEN}}`;\n\nfunction h2s(h: number): string {\n\tconst totalBits = HASH_LEN * ALPH_BITS;\n\tconst shift = 32 - totalBits;\n\tconst n = h >>> shift;\n\tlet out = \"\";\n\tfor (let j = 0; j < HASH_LEN; j++) {\n\t\tout += ALPH[(n >>> ((HASH_LEN - 1 - j) * ALPH_BITS)) & ALPH_MASK]!;\n\t}\n\treturn out;\n}\n\nexport const HL_PREFIX_RE = new RegExp(`^\\\\s*(?:>>>|>>)?\\\\s*${HASH_CLASS}│`);\nexport const HL_PREFIX_PLUS_RE = new RegExp(`^\\\\+\\\\s*${HASH_CLASS}│`);\nexport const DIFF_MINUS_RE = /^-\\s*\\d+\\s{4}/;\n\nexport const HL_BARE_PREFIX_RE = new RegExp(`^\\\\s*(${HASH_CLASS})│`);\n\ntype Hasher = { h32(input: string, seed?: number): number };\nlet hasherP: Promise<Hasher> | null = null;\nlet hasher: Hasher | null = null;\n\nfunction getH(): Hasher {\n\tif (hasher) return hasher;\n\tthrow new Error(\"xxhash-wasm not initialized yet. This should not happen.\");\n}\n\nhasherP = xxhash()\n\t.then((h) => {\n\t\thasher = h;\n\t\treturn h;\n\t})\n\t.catch((err) => {\n\t\tconsole.error(\"xxhash-wasm initialization failed:\", err);\n\t\tthrow err;\n\t});\n\nexport function initHasher(): Promise<Hasher> {\n\treturn hasherP!;\n}\n\nfunction xxh32(input: string, seed = 0): number {\n\treturn getH().h32(input, seed) >>> 0;\n}\n\nfunction canon(line: string): string {\n\treturn line.replace(/\\r/g, \"\").trimEnd();\n}\n\n/**\n * Pure hash computation — no I/O, no persistence. Used internally by the\n * stable path and as a fallback when no file path is available.\n * Each line is hashed with xxHash32 over its canonical form (trailing\n * whitespace and CR characters stripped). If the base hash collides with a\n * hash already assigned to an earlier line, a retry counter (`:R{retry}`)\n * is appended to the canonical content and the hash is recomputed until a\n * unique anchor is found. This perfect-hashing step guarantees every line\n * in a file receives a distinct anchor, even when multiple lines contain\n * identical text (e.g. repeated `}` or `import` statements).\n */\nexport function _lineHashesPure(content: string): string[] {\n\tconst lines = content.split(\"\\n\");\n\tconst hashes = new Array<string>(lines.length);\n\tconst assigned = new Set<string>();\n\tfor (let i = 0; i < lines.length; i++) {\n\t\tconst c = canon(lines[i]!);\n\t\tlet hash = h2s(xxh32(c));\n\t\tlet retry = 0;\n\t\twhile (assigned.has(hash)) {\n\t\t\tretry++;\n\t\t\thash = h2s(xxh32(`${c}:R${retry}`));\n\t\t}\n\t\tassigned.add(hash);\n\t\thashes[i] = hash;\n\t}\n\treturn hashes;\n}\n\ninterface PreviousLineHashSnapshot {\n\tcontent: string;\n\thashes: string[];\n\tremovedHashes?: Set<string>;\n}\n\n/**\n * Stable, persistent-aware hash computation.\n *\n * When `path` is provided, uses the persistent hash store to preserve\n * hashes for unchanged lines across edits. When `previous` is also\n * provided (called from the replace pipeline), diffs the previous content\n * against the new content and copies hashes for unchanged lines to their\n * new positions. New/changed lines allocate fresh hashes with collision\n * avoidance against the preserved set.\n *\n * When `path` is provided without `previous` (called from read), loads\n * the stored snapshot for that path. If the content matches, returns the\n * saved hashes. Otherwise computes fresh hashes via `_lineHashesPure` and\n * saves a new snapshot.\n *\n * When `path` is not provided, falls back to `_lineHashesPure` (for\n * backward compatibility and tests that don't need persistence).\n */\nexport async function lineHashes(\n\tcontent: string,\n\tpath?: string,\n\tprevious?: PreviousLineHashSnapshot,\n): Promise<string[]> {\n\tif (!path) {\n\t\treturn _lineHashesPure(content);\n\t}\n\n\tconst store = await loadHashStore();\n\n\t// Case 1: previous content provided (replace pipeline) — diff and preserve\n\tif (previous) {\n\t\tconst newHashes = mapStableHashes(previous.content, previous.hashes, content, previous.removedHashes);\n\t\tstore.snapshots[path] = { content, hashes: newHashes };\n\t\tawait saveHashStore(store);\n\t\treturn newHashes;\n\t}\n\n\t// Case 2: no previous — check snapshot or compute fresh\n\tconst snapshot = store.snapshots[path];\n\tif (snapshot && snapshot.content === content) {\n\t\treturn snapshot.hashes;\n\t}\n\n\t// Compute fresh hashes\n\tconst newHashes = _lineHashesPure(content);\n\tstore.snapshots[path] = { content, hashes: newHashes };\n\tawait saveHashStore(store);\n\treturn newHashes;\n}\n\ninterface PreviousLineHashCandidate {\n\tindex: number;\n\thash: string;\n}\n\ninterface ReusedLineHashes {\n\thashes: string[];\n\tused: Set<string>;\n}\n\nfunction buildPreviousLineHashCandidates(\n\toldContent: string,\n\toldHashes: string[],\n): Map<string, PreviousLineHashCandidate[]> {\n\tconst candidatesByContent = new Map<string, PreviousLineHashCandidate[]>();\n\tconst oldLines = oldContent.split(\"\\n\");\n\tfor (let index = 0; index < oldLines.length; index++) {\n\t\tconst line = oldLines[index]!;\n\t\tconst candidate = { index, hash: oldHashes[index]! };\n\t\tconst candidates = candidatesByContent.get(line);\n\t\tif (candidates) candidates.push(candidate);\n\t\telse candidatesByContent.set(line, [candidate]);\n\t}\n\treturn candidatesByContent;\n}\n\nfunction takePreferredPreviousLineHash(\n\tcandidates: PreviousLineHashCandidate[],\n\tremovedHashes: Set<string> | undefined,\n): string {\n\tlet preferredIndex = 0;\n\tif (removedHashes && removedHashes.size > 0) {\n\t\tfor (let index = 0; index < candidates.length; index++) {\n\t\t\tif (!removedHashes.has(candidates[index]!.hash)) {\n\t\t\t\tpreferredIndex = index;\n\t\t\t\tbreak;\n\t\t\t}\n\t\t}\n\t}\n\treturn candidates.splice(preferredIndex, 1)[0]!.hash;\n}\n\nfunction reusePreviousLineHashes(\n\tnewLines: string[],\n\tcandidatesByContent: Map<string, PreviousLineHashCandidate[]>,\n\tremovedHashes: Set<string> | undefined,\n): ReusedLineHashes {\n\tconst hashes = new Array<string>(newLines.length);\n\tconst used = new Set<string>();\n\tfor (let index = 0; index < newLines.length; index++) {\n\t\tconst candidates = candidatesByContent.get(newLines[index]!);\n\t\tif (!candidates || candidates.length === 0) continue;\n\t\tconst hash = takePreferredPreviousLineHash(candidates, removedHashes);\n\t\thashes[index] = hash;\n\t\tused.add(hash);\n\t}\n\treturn { hashes, used };\n}\n\nfunction fillFreshLineHashes(newLines: string[], hashes: string[], used: Set<string>): void {\n\tfor (let index = 0; index < newLines.length; index++) {\n\t\tif (hashes[index]) continue;\n\t\tconst canonicalLine = canon(newLines[index]!);\n\t\tlet retry = 0;\n\t\tlet hash = h2s(xxh32(canonicalLine));\n\t\twhile (used.has(hash)) {\n\t\t\tretry++;\n\t\t\thash = h2s(xxh32(`${canonicalLine}:R${retry}`));\n\t\t}\n\t\tused.add(hash);\n\t\thashes[index] = hash;\n\t}\n}\n\n/**\n * Maps old hashes to new positions using hash-aware content matching.\n * Unlike Diff.diffLines (which is content-only and cannot distinguish\n * identical lines at different positions), this algorithm uses the\n * removedHashes set to disambiguate: when a line appears multiple times\n * in the old content and one occurrence was targeted by the edit,\n * the surviving occurrence is matched to the non-removed hash.\n * New/changed lines allocate fresh hashes with collision avoidance.\n */\nfunction mapStableHashes(\n\toldContent: string,\n\toldHashes: string[],\n\tnewContent: string,\n\tremovedHashes?: Set<string>,\n): string[] {\n\tconst newLines = newContent.split(\"\\n\");\n\tconst candidatesByContent = buildPreviousLineHashCandidates(oldContent, oldHashes);\n\tconst { hashes, used } = reusePreviousLineHashes(newLines, candidatesByContent, removedHashes);\n\tfillFreshLineHashes(newLines, hashes, used);\n\treturn hashes;\n}\n\nexport { ALPH_RE };\n"]}

package/dist/core/tools/hashline/parse.d.ts

@@ -0,0 +1,8 @@
+export type Anchor = {
+    hash: string;
+};
+declare function parseRef(ref: string): Anchor;
+export declare const parseHashRef: typeof parseRef;
+export declare function parseText(edit: string[] | string | null): string[];
+export {};
+//# sourceMappingURL=parse.d.ts.map

package/dist/core/tools/hashline/parse.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"parse.d.ts","sourceRoot":"","sources":["../../../../src/core/tools/hashline/parse.ts"],"names":[],"mappings":"AAEA,MAAM,MAAM,MAAM,GAAG;IAAE,IAAI,EAAE,MAAM,CAAA;CAAE,CAAC;AAoBtC,iBAAS,QAAQ,CAAC,GAAG,EAAE,MAAM,GAAG,MAAM,CAQrC;AAED,eAAO,MAAM,YAAY,iBAAW,CAAC;AAarC,wBAAgB,SAAS,CAAC,IAAI,EAAE,MAAM,EAAE,GAAG,MAAM,GAAG,IAAI,GAAG,MAAM,EAAE,CAQlE","sourcesContent":["import { ALPH_RE, ANCHOR_LEN, DIFF_MINUS_RE, HL_PREFIX_PLUS_RE } from \"./hash.ts\";\n\nexport type Anchor = { hash: string };\n\nfunction diagRef(ref: string): string {\n\tconst trimmed = ref.trim();\n\n\tif (!trimmed.length) {\n\t\treturn `[E_BAD_REF] Invalid anchor. Expected a 3-char base64 anchor (e.g. \"aB3\").`;\n\t}\n\n\tif (/^\\d+/.test(trimmed)) {\n\t\treturn `[E_BAD_REF] Invalid anchor. Use the hash alone (e.g. \"aB3\") — no line numbers or trailing content.`;\n\t}\n\n\tif (trimmed.includes(\"│\")) {\n\t\treturn `[E_BAD_REF] Invalid anchor \"${trimmed}\". hash_range_inclusive must contain the 3-char hash only — remove everything from \"│\" onward.`;\n\t}\n\n\treturn `[E_BAD_REF] Invalid anchor \"${trimmed}\". Expected a 3-char base64 anchor (e.g. \"aB3\").`;\n}\n\nfunction parseRef(ref: string): Anchor {\n\tconst trimmed = ref.trim();\n\n\tif (trimmed.length === ANCHOR_LEN && ALPH_RE.test(trimmed)) {\n\t\treturn { hash: trimmed };\n\t}\n\n\tthrow new Error(diagRef(ref));\n}\n\nexport const parseHashRef = parseRef;\n\nfunction assertNoPrefixes(lines: string[]): void {\n\tfor (const line of lines) {\n\t\tif (!line.length) continue;\n\t\tif (HL_PREFIX_PLUS_RE.test(line) || DIFF_MINUS_RE.test(line)) {\n\t\t\tthrow new Error(\n\t\t\t\t`[E_INVALID_PATCH] \"content_lines\" must contain literal file content. Offending line looks like the diff preview's +HASH│ row: ${JSON.stringify(line)}. Use literal file content only — plain + or - lines are written literally.`,\n\t\t\t);\n\t\t}\n\t}\n}\n\nexport function parseText(edit: string[] | string | null): string[] {\n\tif (edit === null) return [];\n\tconst lines =\n\t\ttypeof edit === \"string\"\n\t\t\t? (edit.endsWith(\"\\n\") ? edit.slice(0, -1) : edit).replaceAll(\"\\r\", \"\").split(\"\\n\")\n\t\t\t: edit;\n\tassertNoPrefixes(lines);\n\treturn lines;\n}\n"]}