gsd-pi 2.9.0 → 2.10.1

package/packages/pi-coding-agent/dist/core/tools/hashline-read.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"hashline-read.js","sourceRoot":"","sources":["../../../src/core/tools/hashline-read.ts"],"names":[],"mappings":"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","sourcesContent":["/**\n * Hashline read tool — reads files with LINE#ID prefix on each line.\n *\n * Produces output like:\n *   1#QQ:function hello() {\n *   2#KX:  return 42;\n *   3#NW:}\n *\n * These tags are used by the hashline_edit tool to address lines precisely.\n */\nimport type { AgentTool } from \"@gsd/pi-agent-core\";\nimport type { ImageContent, TextContent } from \"@gsd/pi-ai\";\nimport { type Static, Type } from \"@sinclair/typebox\";\nimport { constants } from \"fs\";\nimport { access as fsAccess, readFile as fsReadFile } from \"fs/promises\";\nimport { formatDimensionNote, resizeImage } from \"../../utils/image-resize.js\";\nimport { detectSupportedImageMimeTypeFromFile } from \"../../utils/mime.js\";\nimport { formatHashLines } from \"./hashline.js\";\nimport { resolveReadPath } from \"./path-utils.js\";\nimport { DEFAULT_MAX_BYTES, DEFAULT_MAX_LINES, formatSize, type TruncationResult, truncateHead } from \"./truncate.js\";\n\nconst readSchema = Type.Object({\n\tpath: Type.String({ description: \"Path to the file to read (relative or absolute)\" }),\n\toffset: Type.Optional(Type.Number({ description: \"Line number to start reading from (1-indexed)\" })),\n\tlimit: Type.Optional(Type.Number({ description: \"Maximum number of lines to read\" })),\n});\n\nexport type HashlineReadToolInput = Static<typeof readSchema>;\n\nexport interface HashlineReadToolDetails {\n\ttruncation?: TruncationResult;\n}\n\n/**\n * Pluggable operations for the hashline read tool.\n */\nexport interface HashlineReadOperations {\n\treadFile: (absolutePath: string) => Promise<Buffer>;\n\taccess: (absolutePath: string) => Promise<void>;\n\tdetectImageMimeType?: (absolutePath: string) => Promise<string | null | undefined>;\n}\n\nconst defaultReadOperations: HashlineReadOperations = {\n\treadFile: (path) => fsReadFile(path),\n\taccess: (path) => fsAccess(path, constants.R_OK),\n\tdetectImageMimeType: detectSupportedImageMimeTypeFromFile,\n};\n\nexport interface HashlineReadToolOptions {\n\tautoResizeImages?: boolean;\n\toperations?: HashlineReadOperations;\n}\n\nexport function createHashlineReadTool(cwd: string, options?: HashlineReadToolOptions): AgentTool<typeof readSchema> {\n\tconst autoResizeImages = options?.autoResizeImages ?? true;\n\tconst ops = options?.operations ?? defaultReadOperations;\n\n\treturn {\n\t\tname: \"read\",\n\t\tlabel: \"read\",\n\t\tdescription: `Read a file with LINE#ID hash anchors on each line. These anchors are used by hashline_edit for precise edits. Output format: LINENUM#HASH:CONTENT. Supports text files and images. For text files, output is truncated to ${DEFAULT_MAX_LINES} lines or ${DEFAULT_MAX_BYTES / 1024}KB. Use offset/limit for large files.`,\n\t\tparameters: readSchema,\n\t\texecute: async (\n\t\t\t_toolCallId: string,\n\t\t\t{ path, offset, limit }: { path: string; offset?: number; limit?: number },\n\t\t\tsignal?: AbortSignal,\n\t\t) => {\n\t\t\tconst absolutePath = resolveReadPath(path, cwd);\n\n\t\t\treturn new Promise<{ content: (TextContent | ImageContent)[]; details: HashlineReadToolDetails | undefined }>(\n\t\t\t\t(resolve, reject) => {\n\t\t\t\t\tif (signal?.aborted) {\n\t\t\t\t\t\treject(new Error(\"Operation aborted\"));\n\t\t\t\t\t\treturn;\n\t\t\t\t\t}\n\n\t\t\t\t\tlet aborted = false;\n\t\t\t\t\tconst onAbort = () => {\n\t\t\t\t\t\taborted = true;\n\t\t\t\t\t\treject(new Error(\"Operation aborted\"));\n\t\t\t\t\t};\n\t\t\t\t\tif (signal) {\n\t\t\t\t\t\tsignal.addEventListener(\"abort\", onAbort, { once: true });\n\t\t\t\t\t}\n\n\t\t\t\t\t(async () => {\n\t\t\t\t\t\ttry {\n\t\t\t\t\t\t\tawait ops.access(absolutePath);\n\n\t\t\t\t\t\t\tif (aborted) return;\n\n\t\t\t\t\t\t\tconst mimeType = ops.detectImageMimeType ? await ops.detectImageMimeType(absolutePath) : undefined;\n\n\t\t\t\t\t\t\tlet content: (TextContent | ImageContent)[];\n\t\t\t\t\t\t\tlet details: HashlineReadToolDetails | undefined;\n\n\t\t\t\t\t\t\tif (mimeType) {\n\t\t\t\t\t\t\t\t// Image handling (identical to standard read tool)\n\t\t\t\t\t\t\t\tconst buffer = await ops.readFile(absolutePath);\n\t\t\t\t\t\t\t\tconst base64 = buffer.toString(\"base64\");\n\n\t\t\t\t\t\t\t\tif (autoResizeImages) {\n\t\t\t\t\t\t\t\t\tconst resized = await resizeImage({ type: \"image\", data: base64, mimeType });\n\t\t\t\t\t\t\t\t\tconst dimensionNote = formatDimensionNote(resized);\n\t\t\t\t\t\t\t\t\tlet textNote = `Read image file [${resized.mimeType}]`;\n\t\t\t\t\t\t\t\t\tif (dimensionNote) {\n\t\t\t\t\t\t\t\t\t\ttextNote += `\\n${dimensionNote}`;\n\t\t\t\t\t\t\t\t\t}\n\t\t\t\t\t\t\t\t\tcontent = [\n\t\t\t\t\t\t\t\t\t\t{ type: \"text\", text: textNote },\n\t\t\t\t\t\t\t\t\t\t{ type: \"image\", data: resized.data, mimeType: resized.mimeType },\n\t\t\t\t\t\t\t\t\t];\n\t\t\t\t\t\t\t\t} else {\n\t\t\t\t\t\t\t\t\tcontent = [\n\t\t\t\t\t\t\t\t\t\t{ type: \"text\", text: `Read image file [${mimeType}]` },\n\t\t\t\t\t\t\t\t\t\t{ type: \"image\", data: base64, mimeType },\n\t\t\t\t\t\t\t\t\t];\n\t\t\t\t\t\t\t\t}\n\t\t\t\t\t\t\t} else {\n\t\t\t\t\t\t\t\t// Text file — format with hashline prefixes\n\t\t\t\t\t\t\t\tconst buffer = await ops.readFile(absolutePath);\n\t\t\t\t\t\t\t\tconst textContent = buffer.toString(\"utf-8\");\n\t\t\t\t\t\t\t\tconst allLines = textContent.split(\"\\n\");\n\t\t\t\t\t\t\t\tconst totalFileLines = allLines.length;\n\n\t\t\t\t\t\t\t\tconst startLine = offset ? Math.max(0, offset - 1) : 0;\n\t\t\t\t\t\t\t\tconst startLineDisplay = startLine + 1;\n\n\t\t\t\t\t\t\t\tif (startLine >= allLines.length) {\n\t\t\t\t\t\t\t\t\tthrow new Error(`Offset ${offset} is beyond end of file (${allLines.length} lines total)`);\n\t\t\t\t\t\t\t\t}\n\n\t\t\t\t\t\t\t\tlet selectedContent: string;\n\t\t\t\t\t\t\t\tlet userLimitedLines: number | undefined;\n\t\t\t\t\t\t\t\tif (limit !== undefined) {\n\t\t\t\t\t\t\t\t\tconst endLine = Math.min(startLine + limit, allLines.length);\n\t\t\t\t\t\t\t\t\tselectedContent = allLines.slice(startLine, endLine).join(\"\\n\");\n\t\t\t\t\t\t\t\t\tuserLimitedLines = endLine - startLine;\n\t\t\t\t\t\t\t\t} else {\n\t\t\t\t\t\t\t\t\tselectedContent = allLines.slice(startLine).join(\"\\n\");\n\t\t\t\t\t\t\t\t}\n\n\t\t\t\t\t\t\t\t// Apply truncation\n\t\t\t\t\t\t\t\tconst truncation = truncateHead(selectedContent);\n\n\t\t\t\t\t\t\t\tlet outputText: string;\n\n\t\t\t\t\t\t\t\tif (truncation.firstLineExceedsLimit) {\n\t\t\t\t\t\t\t\t\tconst firstLineSize = formatSize(Buffer.byteLength(allLines[startLine], \"utf-8\"));\n\t\t\t\t\t\t\t\t\toutputText = `[Line ${startLineDisplay} is ${firstLineSize}, exceeds ${formatSize(DEFAULT_MAX_BYTES)} limit. Use bash: sed -n '${startLineDisplay}p' ${path} | head -c ${DEFAULT_MAX_BYTES}]`;\n\t\t\t\t\t\t\t\t\tdetails = { truncation };\n\t\t\t\t\t\t\t\t} else if (truncation.truncated) {\n\t\t\t\t\t\t\t\t\tconst endLineDisplay = startLineDisplay + truncation.outputLines - 1;\n\t\t\t\t\t\t\t\t\tconst nextOffset = endLineDisplay + 1;\n\n\t\t\t\t\t\t\t\t\t// Format with hashline prefixes\n\t\t\t\t\t\t\t\t\toutputText = formatHashLines(truncation.content, startLineDisplay);\n\n\t\t\t\t\t\t\t\t\tif (truncation.truncatedBy === \"lines\") {\n\t\t\t\t\t\t\t\t\t\toutputText += `\\n\\n[Showing lines ${startLineDisplay}-${endLineDisplay} of ${totalFileLines}. Use offset=${nextOffset} to continue.]`;\n\t\t\t\t\t\t\t\t\t} else {\n\t\t\t\t\t\t\t\t\t\toutputText += `\\n\\n[Showing lines ${startLineDisplay}-${endLineDisplay} of ${totalFileLines} (${formatSize(DEFAULT_MAX_BYTES)} limit). Use offset=${nextOffset} to continue.]`;\n\t\t\t\t\t\t\t\t\t}\n\t\t\t\t\t\t\t\t\tdetails = { truncation };\n\t\t\t\t\t\t\t\t} else if (userLimitedLines !== undefined && startLine + userLimitedLines < allLines.length) {\n\t\t\t\t\t\t\t\t\tconst remaining = allLines.length - (startLine + userLimitedLines);\n\t\t\t\t\t\t\t\t\tconst nextOffset = startLine + userLimitedLines + 1;\n\n\t\t\t\t\t\t\t\t\toutputText = formatHashLines(truncation.content, startLineDisplay);\n\t\t\t\t\t\t\t\t\toutputText += `\\n\\n[${remaining} more lines in file. Use offset=${nextOffset} to continue.]`;\n\t\t\t\t\t\t\t\t} else {\n\t\t\t\t\t\t\t\t\toutputText = formatHashLines(truncation.content, startLineDisplay);\n\t\t\t\t\t\t\t\t}\n\n\t\t\t\t\t\t\t\tcontent = [{ type: \"text\", text: outputText }];\n\t\t\t\t\t\t\t}\n\n\t\t\t\t\t\t\tif (aborted) return;\n\n\t\t\t\t\t\t\tif (signal) signal.removeEventListener(\"abort\", onAbort);\n\t\t\t\t\t\t\tresolve({ content, details });\n\t\t\t\t\t\t} catch (error: any) {\n\t\t\t\t\t\t\tif (signal) signal.removeEventListener(\"abort\", onAbort);\n\t\t\t\t\t\t\tif (!aborted) {\n\t\t\t\t\t\t\t\treject(error);\n\t\t\t\t\t\t\t}\n\t\t\t\t\t\t}\n\t\t\t\t\t})();\n\t\t\t\t},\n\t\t\t);\n\t\t},\n\t};\n}\n\n/** Default hashline read tool using process.cwd() */\nexport const hashlineReadTool = createHashlineReadTool(process.cwd());\n"]}

package/packages/pi-coding-agent/dist/core/tools/hashline.d.ts

@@ -0,0 +1,114 @@
+/**
+ * Hashline edit mode — a line-addressable edit format using content-hash anchors.
+ *
+ * Each line in a file is identified by its 1-indexed line number and a short
+ * hash derived from the normalized line text (xxHash32, truncated to 2 chars
+ * from a custom nibble alphabet).
+ *
+ * The combined `LINE#ID` reference acts as both an address and a staleness check:
+ * if the file has changed since the caller last read it, hash mismatches are caught
+ * before any mutation occurs.
+ *
+ * Displayed format: `LINENUM#HASH:TEXT`
+ * Reference format: `"LINENUM#HASH"` (e.g. `"5#QQ"`)
+ *
+ * Adapted from Oh My Pi's hashline implementation for Node.js (no Bun dependency).
+ */
+export type Anchor = {
+    line: number;
+    hash: string;
+};
+export type HashlineEdit = {
+    op: "replace";
+    pos: Anchor;
+    end?: Anchor;
+    lines: string[];
+} | {
+    op: "append";
+    pos?: Anchor;
+    lines: string[];
+} | {
+    op: "prepend";
+    pos?: Anchor;
+    lines: string[];
+};
+/**
+ * Compute a short hash of a single line.
+ *
+ * Uses xxHash32 on a trailing-whitespace-trimmed, CR-stripped line, truncated to 2 chars
+ * from the nibble alphabet. For lines containing no alphanumeric characters (only
+ * punctuation/symbols/whitespace), the line number is mixed in to reduce hash collisions.
+ */
+export declare function computeLineHash(idx: number, line: string): string;
+/**
+ * Formats a tag given the line number and text.
+ */
+export declare function formatLineTag(line: number, text: string): string;
+/**
+ * Format file text with hashline prefixes for display.
+ *
+ * Each line becomes `LINENUM#HASH:TEXT` where LINENUM is 1-indexed.
+ */
+export declare function formatHashLines(text: string, startLine?: number): string;
+/**
+ * Parse a line reference string like `"5#QQ"` into structured form.
+ *
+ * @throws Error if the format is invalid
+ */
+export declare function parseTag(ref: string): Anchor;
+export interface HashMismatch {
+    line: number;
+    expected: string;
+    actual: string;
+}
+/**
+ * Error thrown when one or more hashline references have stale hashes.
+ * Displays grep-style output with `>>>` markers on mismatched lines,
+ * showing the correct `LINE#ID` so the caller can fix all refs at once.
+ */
+export declare class HashlineMismatchError extends Error {
+    readonly mismatches: HashMismatch[];
+    readonly fileLines: string[];
+    readonly remaps: ReadonlyMap<string, string>;
+    constructor(mismatches: HashMismatch[], fileLines: string[]);
+    static formatMessage(mismatches: HashMismatch[], fileLines: string[]): string;
+}
+/**
+ * Validate that a line reference points to an existing line with a matching hash.
+ */
+export declare function validateLineRef(ref: Anchor, fileLines: string[]): void;
+/**
+ * Strip hashline display prefixes and diff `+` markers from replacement lines.
+ *
+ * Models frequently copy the `LINE#ID` prefix from read output into their
+ * replacement content. This strips them heuristically before application.
+ */
+export declare function stripNewLinePrefixes(lines: string[]): string[];
+/**
+ * Parse edit content — handles string, array, or null input.
+ * Strips hashline prefixes and diff markers from model output.
+ */
+export declare function hashlineParseText(edit: string[] | string | null): string[];
+/**
+ * Apply an array of hashline edits to file content.
+ *
+ * Each edit operation identifies target lines directly (`replace`,
+ * `append`, `prepend`). Line references are resolved via parseTag
+ * and hashes validated before any mutation.
+ *
+ * Edits are sorted bottom-up (highest effective line first) so earlier
+ * splices don't invalidate later line numbers.
+ *
+ * @returns The modified content and the 1-indexed first changed line number
+ */
+export declare function applyHashlineEdits(text: string, edits: HashlineEdit[]): {
+    lines: string;
+    firstChangedLine: number | undefined;
+    warnings?: string[];
+    noopEdits?: Array<{
+        editIndex: number;
+        loc: string;
+        current: string;
+    }>;
+};
+//# sourceMappingURL=hashline.d.ts.map

package/packages/pi-coding-agent/dist/core/tools/hashline.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"hashline.d.ts","sourceRoot":"","sources":["../../../src/core/tools/hashline.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;GAeG;AA6EH,MAAM,MAAM,MAAM,GAAG;IAAE,IAAI,EAAE,MAAM,CAAC;IAAC,IAAI,EAAE,MAAM,CAAA;CAAE,CAAC;AACpD,MAAM,MAAM,YAAY,GACrB;IAAE,EAAE,EAAE,SAAS,CAAC;IAAC,GAAG,EAAE,MAAM,CAAC;IAAC,GAAG,CAAC,EAAE,MAAM,CAAC;IAAC,KAAK,EAAE,MAAM,EAAE,CAAA;CAAE,GAC7D;IAAE,EAAE,EAAE,QAAQ,CAAC;IAAC,GAAG,CAAC,EAAE,MAAM,CAAC;IAAC,KAAK,EAAE,MAAM,EAAE,CAAA;CAAE,GAC/C;IAAE,EAAE,EAAE,SAAS,CAAC;IAAC,GAAG,CAAC,EAAE,MAAM,CAAC;IAAC,KAAK,EAAE,MAAM,EAAE,CAAA;CAAE,CAAC;AAYpD;;;;;;GAMG;AACH,wBAAgB,eAAe,CAAC,GAAG,EAAE,MAAM,EAAE,IAAI,EAAE,MAAM,GAAG,MAAM,CAQjE;AAED;;GAEG;AACH,wBAAgB,aAAa,CAAC,IAAI,EAAE,MAAM,EAAE,IAAI,EAAE,MAAM,GAAG,MAAM,CAEhE;AAED;;;;GAIG;AACH,wBAAgB,eAAe,CAAC,IAAI,EAAE,MAAM,EAAE,SAAS,SAAI,GAAG,MAAM,CAQnE;AAED;;;;GAIG;AACH,wBAAgB,QAAQ,CAAC,GAAG,EAAE,MAAM,GAAG,MAAM,CAU5C;AAMD,MAAM,WAAW,YAAY;IAC5B,IAAI,EAAE,MAAM,CAAC;IACb,QAAQ,EAAE,MAAM,CAAC;IACjB,MAAM,EAAE,MAAM,CAAC;CACf;AAID;;;;GAIG;AACH,qBAAa,qBAAsB,SAAQ,KAAK;IAC/C,QAAQ,CAAC,UAAU,EAAE,YAAY,EAAE,CAAC;IACpC,QAAQ,CAAC,SAAS,EAAE,MAAM,EAAE,CAAC;IAC7B,QAAQ,CAAC,MAAM,EAAE,WAAW,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;gBAE5C,UAAU,EAAE,YAAY,EAAE,EAC1B,SAAS,EAAE,MAAM,EAAE;IAcpB,MAAM,CAAC,aAAa,CAAC,UAAU,EAAE,YAAY,EAAE,EAAE,SAAS,EAAE,MAAM,EAAE,GAAG,MAAM;CA0C7E;AAED;;GAEG;AACH,wBAAgB,eAAe,CAAC,GAAG,EAAE,MAAM,EAAE,SAAS,EAAE,MAAM,EAAE,GAAG,IAAI,CAQtE;AAYD;;;;;GAKG;AACH,wBAAgB,oBAAoB,CAAC,KAAK,EAAE,MAAM,EAAE,GAAG,MAAM,EAAE,CAqB9D;AAED;;;GAGG;AACH,wBAAgB,iBAAiB,CAAC,IAAI,EAAE,MAAM,EAAE,GAAG,MAAM,GAAG,IAAI,GAAG,MAAM,EAAE,CAO1E;AA2CD;;;;;;;;;;;GAWG;AACH,wBAAgB,kBAAkB,CACjC,IAAI,EAAE,MAAM,EACZ,KAAK,EAAE,YAAY,EAAE,GACnB;IACF,KAAK,EAAE,MAAM,CAAC;IACd,gBAAgB,EAAE,MAAM,GAAG,SAAS,CAAC;IACrC,QAAQ,CAAC,EAAE,MAAM,EAAE,CAAC;IACpB,SAAS,CAAC,EAAE,KAAK,CAAC;QAAE,SAAS,EAAE,MAAM,CAAC;QAAC,GAAG,EAAE,MAAM,CAAC;QAAC,OAAO,EAAE,MAAM,CAAA;KAAE,CAAC,CAAC;CACvE,CA8NA"}

package/packages/pi-coding-agent/dist/core/tools/hashline.js

@@ -0,0 +1,522 @@
+/**
+ * Hashline edit mode — a line-addressable edit format using content-hash anchors.
+ *
+ * Each line in a file is identified by its 1-indexed line number and a short
+ * hash derived from the normalized line text (xxHash32, truncated to 2 chars
+ * from a custom nibble alphabet).
+ *
+ * The combined `LINE#ID` reference acts as both an address and a staleness check:
+ * if the file has changed since the caller last read it, hash mismatches are caught
+ * before any mutation occurs.
+ *
+ * Displayed format: `LINENUM#HASH:TEXT`
+ * Reference format: `"LINENUM#HASH"` (e.g. `"5#QQ"`)
+ *
+ * Adapted from Oh My Pi's hashline implementation for Node.js (no Bun dependency).
+ */
+// ═══════════════════════════════════════════════════════════════════════════
+// xxHash32 — pure JS implementation (no native dependencies)
+// ═══════════════════════════════════════════════════════════════════════════
+const PRIME32_1 = 0x9e3779b1;
+const PRIME32_2 = 0x85ebca77;
+const PRIME32_3 = 0xc2b2ae3d;
+const PRIME32_4 = 0x27d4eb2f;
+const PRIME32_5 = 0x165667b1;
+function rotl32(val, bits) {
+    return ((val << bits) | (val >>> (32 - bits))) >>> 0;
+}
+function imul32(a, b) {
+    return Math.imul(a, b) >>> 0;
+}
+/**
+ * Pure JS xxHash32 operating on a UTF-8 encoded string.
+ * Matches Bun.hash.xxHash32(str, seed) behavior.
+ */
+function xxHash32(input, seed) {
+    const buf = Buffer.from(input, "utf-8");
+    const len = buf.length;
+    let h32;
+    let i = 0;
+    if (len >= 16) {
+        let v1 = (seed + PRIME32_1 + PRIME32_2) >>> 0;
+        let v2 = (seed + PRIME32_2) >>> 0;
+        let v3 = (seed + 0) >>> 0;
+        let v4 = (seed - PRIME32_1) >>> 0;
+        while (i <= len - 16) {
+            v1 = (imul32(rotl32((v1 + imul32(buf.readUInt32LE(i), PRIME32_2)) >>> 0, 13), PRIME32_1)) >>> 0;
+            i += 4;
+            v2 = (imul32(rotl32((v2 + imul32(buf.readUInt32LE(i), PRIME32_2)) >>> 0, 13), PRIME32_1)) >>> 0;
+            i += 4;
+            v3 = (imul32(rotl32((v3 + imul32(buf.readUInt32LE(i), PRIME32_2)) >>> 0, 13), PRIME32_1)) >>> 0;
+            i += 4;
+            v4 = (imul32(rotl32((v4 + imul32(buf.readUInt32LE(i), PRIME32_2)) >>> 0, 13), PRIME32_1)) >>> 0;
+            i += 4;
+        }
+        h32 = (rotl32(v1, 1) + rotl32(v2, 7) + rotl32(v3, 12) + rotl32(v4, 18)) >>> 0;
+    }
+    else {
+        h32 = (seed + PRIME32_5) >>> 0;
+    }
+    h32 = (h32 + len) >>> 0;
+    while (i <= len - 4) {
+        h32 = (h32 + imul32(buf.readUInt32LE(i), PRIME32_3)) >>> 0;
+        h32 = imul32(rotl32(h32, 17), PRIME32_4);
+        i += 4;
+    }
+    while (i < len) {
+        h32 = (h32 + imul32(buf[i], PRIME32_5)) >>> 0;
+        h32 = imul32(rotl32(h32, 11), PRIME32_1);
+        i += 1;
+    }
+    h32 = imul32(h32 ^ (h32 >>> 15), PRIME32_2);
+    h32 = imul32(h32 ^ (h32 >>> 13), PRIME32_3);
+    h32 = (h32 ^ (h32 >>> 16)) >>> 0;
+    return h32;
+}
+const NIBBLE_STR = "ZPMQVRWSNKTXJBYH";
+const DICT = Array.from({ length: 256 }, (_, i) => {
+    const h = i >>> 4;
+    const l = i & 0x0f;
+    return `${NIBBLE_STR[h]}${NIBBLE_STR[l]}`;
+});
+const RE_SIGNIFICANT = /[\p{L}\p{N}]/u;
+/**
+ * Compute a short hash of a single line.
+ *
+ * Uses xxHash32 on a trailing-whitespace-trimmed, CR-stripped line, truncated to 2 chars
+ * from the nibble alphabet. For lines containing no alphanumeric characters (only
+ * punctuation/symbols/whitespace), the line number is mixed in to reduce hash collisions.
+ */
+export function computeLineHash(idx, line) {
+    line = line.replace(/\r/g, "").trimEnd();
+    let seed = 0;
+    if (!RE_SIGNIFICANT.test(line)) {
+        seed = idx;
+    }
+    return DICT[xxHash32(line, seed) & 0xff];
+}
+/**
+ * Formats a tag given the line number and text.
+ */
+export function formatLineTag(line, text) {
+    return `${line}#${computeLineHash(line, text)}`;
+}
+/**
+ * Format file text with hashline prefixes for display.
+ *
+ * Each line becomes `LINENUM#HASH:TEXT` where LINENUM is 1-indexed.
+ */
+export function formatHashLines(text, startLine = 1) {
+    const lines = text.split("\n");
+    return lines
+        .map((line, i) => {
+        const num = startLine + i;
+        return `${formatLineTag(num, line)}:${line}`;
+    })
+        .join("\n");
+}
+/**
+ * Parse a line reference string like `"5#QQ"` into structured form.
+ *
+ * @throws Error if the format is invalid
+ */
+export function parseTag(ref) {
+    const match = ref.match(/^\s*[>+-]*\s*(\d+)\s*#\s*([ZPMQVRWSNKTXJBYH]{2})/);
+    if (!match) {
+        throw new Error(`Invalid line reference "${ref}". Expected format "LINE#ID" (e.g. "5#QQ").`);
+    }
+    const line = Number.parseInt(match[1], 10);
+    if (line < 1) {
+        throw new Error(`Line number must be >= 1, got ${line} in "${ref}".`);
+    }
+    return { line, hash: match[2] };
+}
+const MISMATCH_CONTEXT = 2;
+/**
+ * Error thrown when one or more hashline references have stale hashes.
+ * Displays grep-style output with `>>>` markers on mismatched lines,
+ * showing the correct `LINE#ID` so the caller can fix all refs at once.
+ */
+export class HashlineMismatchError extends Error {
+    constructor(mismatches, fileLines) {
+        super(HashlineMismatchError.formatMessage(mismatches, fileLines));
+        this.name = "HashlineMismatchError";
+        this.mismatches = mismatches;
+        this.fileLines = fileLines;
+        const remaps = new Map();
+        for (const m of mismatches) {
+            const actual = computeLineHash(m.line, fileLines[m.line - 1]);
+            remaps.set(`${m.line}#${m.expected}`, `${m.line}#${actual}`);
+        }
+        this.remaps = remaps;
+    }
+    static formatMessage(mismatches, fileLines) {
+        const mismatchSet = new Map();
+        for (const m of mismatches) {
+            mismatchSet.set(m.line, m);
+        }
+        const displayLines = new Set();
+        for (const m of mismatches) {
+            const lo = Math.max(1, m.line - MISMATCH_CONTEXT);
+            const hi = Math.min(fileLines.length, m.line + MISMATCH_CONTEXT);
+            for (let i = lo; i <= hi; i++) {
+                displayLines.add(i);
+            }
+        }
+        const sorted = [...displayLines].sort((a, b) => a - b);
+        const lines = [];
+        lines.push(`${mismatches.length} line${mismatches.length > 1 ? "s have" : " has"} changed since last read. Use the updated LINE#ID references shown below (>>> marks changed lines).`);
+        lines.push("");
+        let prevLine = -1;
+        for (const lineNum of sorted) {
+            if (prevLine !== -1 && lineNum > prevLine + 1) {
+                lines.push("    ...");
+            }
+            prevLine = lineNum;
+            const text = fileLines[lineNum - 1];
+            const hash = computeLineHash(lineNum, text);
+            const prefix = `${lineNum}#${hash}`;
+            if (mismatchSet.has(lineNum)) {
+                lines.push(`>>> ${prefix}:${text}`);
+            }
+            else {
+                lines.push(`    ${prefix}:${text}`);
+            }
+        }
+        return lines.join("\n");
+    }
+}
+/**
+ * Validate that a line reference points to an existing line with a matching hash.
+ */
+export function validateLineRef(ref, fileLines) {
+    if (ref.line < 1 || ref.line > fileLines.length) {
+        throw new Error(`Line ${ref.line} does not exist (file has ${fileLines.length} lines)`);
+    }
+    const actualHash = computeLineHash(ref.line, fileLines[ref.line - 1]);
+    if (actualHash !== ref.hash) {
+        throw new HashlineMismatchError([{ line: ref.line, expected: ref.hash, actual: actualHash }], fileLines);
+    }
+}
+// ═══════════════════════════════════════════════════════════════════════════
+// Prefix Stripping
+// ═══════════════════════════════════════════════════════════════════════════
+/** Pattern matching hashline display format prefixes: `LINE#ID:CONTENT` and `#ID:CONTENT` */
+const HASHLINE_PREFIX_RE = /^\s*(?:>>>|>>)?\s*(?:\d+\s*#\s*|#\s*)[ZPMQVRWSNKTXJBYH]{2}:/;
+/** Pattern matching a unified-diff added-line `+` prefix (but not `++`). */
+const DIFF_PLUS_RE = /^[+](?![+])/;
+/**
+ * Strip hashline display prefixes and diff `+` markers from replacement lines.
+ *
+ * Models frequently copy the `LINE#ID` prefix from read output into their
+ * replacement content. This strips them heuristically before application.
+ */
+export function stripNewLinePrefixes(lines) {
+    let hashPrefixCount = 0;
+    let diffPlusCount = 0;
+    let nonEmpty = 0;
+    for (const l of lines) {
+        if (l.length === 0)
+            continue;
+        nonEmpty++;
+        if (HASHLINE_PREFIX_RE.test(l))
+            hashPrefixCount++;
+        if (DIFF_PLUS_RE.test(l))
+            diffPlusCount++;
+    }
+    if (nonEmpty === 0)
+        return lines;
+    const stripHash = hashPrefixCount > 0 && hashPrefixCount === nonEmpty;
+    const stripPlus = !stripHash && diffPlusCount > 0 && diffPlusCount >= nonEmpty * 0.5;
+    if (!stripHash && !stripPlus)
+        return lines;
+    return lines.map(l => {
+        if (stripHash)
+            return l.replace(HASHLINE_PREFIX_RE, "");
+        if (stripPlus)
+            return l.replace(DIFF_PLUS_RE, "");
+        return l;
+    });
+}
+/**
+ * Parse edit content — handles string, array, or null input.
+ * Strips hashline prefixes and diff markers from model output.
+ */
+export function hashlineParseText(edit) {
+    if (edit === null)
+        return [];
+    if (typeof edit === "string") {
+        const normalizedEdit = edit.endsWith("\n") ? edit.slice(0, -1) : edit;
+        edit = normalizedEdit.replaceAll("\r", "").split("\n");
+    }
+    return stripNewLinePrefixes(edit);
+}
+// ═══════════════════════════════════════════════════════════════════════════
+// Auto-correction Heuristics
+// ═══════════════════════════════════════════════════════════════════════════
+function maybeAutocorrectEscapedTabIndentation(edits, warnings) {
+    for (const edit of edits) {
+        if (edit.lines.length === 0)
+            continue;
+        const hasEscapedTabs = edit.lines.some(line => line.includes("\\t"));
+        if (!hasEscapedTabs)
+            continue;
+        const hasRealTabs = edit.lines.some(line => line.includes("\t"));
+        if (hasRealTabs)
+            continue;
+        let correctedCount = 0;
+        const corrected = edit.lines.map(line => line.replace(/^((?:\\t)+)/, escaped => {
+            correctedCount += escaped.length / 2;
+            return "\t".repeat(escaped.length / 2);
+        }));
+        if (correctedCount === 0)
+            continue;
+        edit.lines = corrected;
+        warnings.push(`Auto-corrected escaped tab indentation in edit: converted leading \\t sequence(s) to real tab characters`);
+    }
+}
+const MIN_AUTOCORRECT_LENGTH = 2;
+function shouldAutocorrect(line, otherLine) {
+    if (!line || line !== otherLine)
+        return false;
+    line = line.trim();
+    if (line.length < MIN_AUTOCORRECT_LENGTH) {
+        return line.endsWith("}") || line.endsWith(")");
+    }
+    return true;
+}
+// ═══════════════════════════════════════════════════════════════════════════
+// Edit Application
+// ═══════════════════════════════════════════════════════════════════════════
+/**
+ * Apply an array of hashline edits to file content.
+ *
+ * Each edit operation identifies target lines directly (`replace`,
+ * `append`, `prepend`). Line references are resolved via parseTag
+ * and hashes validated before any mutation.
+ *
+ * Edits are sorted bottom-up (highest effective line first) so earlier
+ * splices don't invalidate later line numbers.
+ *
+ * @returns The modified content and the 1-indexed first changed line number
+ */
+export function applyHashlineEdits(text, edits) {
+    if (edits.length === 0) {
+        return { lines: text, firstChangedLine: undefined };
+    }
+    const fileLines = text.split("\n");
+    const originalFileLines = [...fileLines];
+    let firstChangedLine;
+    const noopEdits = [];
+    const warnings = [];
+    // Pre-validate: collect all hash mismatches before mutating
+    const mismatches = [];
+    function validateRef(ref) {
+        if (ref.line < 1 || ref.line > fileLines.length) {
+            throw new Error(`Line ${ref.line} does not exist (file has ${fileLines.length} lines)`);
+        }
+        const actualHash = computeLineHash(ref.line, fileLines[ref.line - 1]);
+        if (actualHash === ref.hash) {
+            return true;
+        }
+        mismatches.push({ line: ref.line, expected: ref.hash, actual: actualHash });
+        return false;
+    }
+    for (const edit of edits) {
+        switch (edit.op) {
+            case "replace": {
+                if (edit.end) {
+                    const startValid = validateRef(edit.pos);
+                    const endValid = validateRef(edit.end);
+                    if (!startValid || !endValid)
+                        continue;
+                    if (edit.pos.line > edit.end.line) {
+                        throw new Error(`Range start line ${edit.pos.line} must be <= end line ${edit.end.line}`);
+                    }
+                }
+                else {
+                    if (!validateRef(edit.pos))
+                        continue;
+                }
+                break;
+            }
+            case "append": {
+                if (edit.pos && !validateRef(edit.pos))
+                    continue;
+                if (edit.lines.length === 0) {
+                    edit.lines = [""];
+                }
+                break;
+            }
+            case "prepend": {
+                if (edit.pos && !validateRef(edit.pos))
+                    continue;
+                if (edit.lines.length === 0) {
+                    edit.lines = [""];
+                }
+                break;
+            }
+        }
+    }
+    if (mismatches.length > 0) {
+        throw new HashlineMismatchError(mismatches, fileLines);
+    }
+    maybeAutocorrectEscapedTabIndentation(edits, warnings);
+    // Deduplicate identical edits targeting the same line(s)
+    const seenEditKeys = new Map();
+    const dedupIndices = new Set();
+    for (let i = 0; i < edits.length; i++) {
+        const edit = edits[i];
+        let lineKey;
+        switch (edit.op) {
+            case "replace":
+                lineKey = edit.end ? `r:${edit.pos.line}:${edit.end.line}` : `s:${edit.pos.line}`;
+                break;
+            case "append":
+                lineKey = edit.pos ? `i:${edit.pos.line}` : "ieof";
+                break;
+            case "prepend":
+                lineKey = edit.pos ? `ib:${edit.pos.line}` : "ibef";
+                break;
+        }
+        const dstKey = `${lineKey}:${edit.lines.join("\n")}`;
+        if (seenEditKeys.has(dstKey)) {
+            dedupIndices.add(i);
+        }
+        else {
+            seenEditKeys.set(dstKey, i);
+        }
+    }
+    if (dedupIndices.size > 0) {
+        for (let i = edits.length - 1; i >= 0; i--) {
+            if (dedupIndices.has(i))
+                edits.splice(i, 1);
+        }
+    }
+    // Compute sort key (descending) — bottom-up application
+    const annotated = edits.map((edit, idx) => {
+        let sortLine;
+        let precedence;
+        switch (edit.op) {
+            case "replace":
+                sortLine = edit.end ? edit.end.line : edit.pos.line;
+                precedence = 0;
+                break;
+            case "append":
+                sortLine = edit.pos ? edit.pos.line : fileLines.length + 1;
+                precedence = 1;
+                break;
+            case "prepend":
+                sortLine = edit.pos ? edit.pos.line : 0;
+                precedence = 2;
+                break;
+        }
+        return { edit, idx, sortLine, precedence };
+    });
+    annotated.sort((a, b) => b.sortLine - a.sortLine || a.precedence - b.precedence || a.idx - b.idx);
+    function trackFirstChanged(line) {
+        if (firstChangedLine === undefined || line < firstChangedLine) {
+            firstChangedLine = line;
+        }
+    }
+    // Apply edits bottom-up
+    for (const { edit, idx } of annotated) {
+        switch (edit.op) {
+            case "replace": {
+                if (!edit.end) {
+                    const origLines = originalFileLines.slice(edit.pos.line - 1, edit.pos.line);
+                    const newLines = edit.lines;
+                    if (origLines.length === newLines.length && origLines.every((line, i) => line === newLines[i])) {
+                        noopEdits.push({
+                            editIndex: idx,
+                            loc: `${edit.pos.line}#${edit.pos.hash}`,
+                            current: origLines.join("\n"),
+                        });
+                        break;
+                    }
+                    fileLines.splice(edit.pos.line - 1, 1, ...newLines);
+                    trackFirstChanged(edit.pos.line);
+                }
+                else {
+                    const count = edit.end.line - edit.pos.line + 1;
+                    const newLines = [...edit.lines];
+                    const trailingReplacementLine = newLines[newLines.length - 1]?.trimEnd();
+                    const nextSurvivingLine = fileLines[edit.end.line]?.trimEnd();
+                    if (shouldAutocorrect(trailingReplacementLine, nextSurvivingLine) &&
+                        fileLines[edit.end.line - 1]?.trimEnd() !== trailingReplacementLine) {
+                        newLines.pop();
+                        warnings.push(`Auto-corrected range replace ${edit.pos.line}#${edit.pos.hash}-${edit.end.line}#${edit.end.hash}: removed trailing replacement line "${trailingReplacementLine}" that duplicated next surviving line`);
+                    }
+                    const leadingReplacementLine = newLines[0]?.trimEnd();
+                    const prevSurvivingLine = fileLines[edit.pos.line - 2]?.trimEnd();
+                    if (shouldAutocorrect(leadingReplacementLine, prevSurvivingLine) &&
+                        fileLines[edit.pos.line - 1]?.trimEnd() !== leadingReplacementLine) {
+                        newLines.shift();
+                        warnings.push(`Auto-corrected range replace ${edit.pos.line}#${edit.pos.hash}-${edit.end.line}#${edit.end.hash}: removed leading replacement line "${leadingReplacementLine}" that duplicated preceding surviving line`);
+                    }
+                    fileLines.splice(edit.pos.line - 1, count, ...newLines);
+                    trackFirstChanged(edit.pos.line);
+                }
+                break;
+            }
+            case "append": {
+                const inserted = edit.lines;
+                if (inserted.length === 0) {
+                    noopEdits.push({
+                        editIndex: idx,
+                        loc: edit.pos ? `${edit.pos.line}#${edit.pos.hash}` : "EOF",
+                        current: edit.pos ? originalFileLines[edit.pos.line - 1] : "",
+                    });
+                    break;
+                }
+                if (edit.pos) {
+                    fileLines.splice(edit.pos.line, 0, ...inserted);
+                    trackFirstChanged(edit.pos.line + 1);
+                }
+                else {
+                    if (fileLines.length === 1 && fileLines[0] === "") {
+                        fileLines.splice(0, 1, ...inserted);
+                        trackFirstChanged(1);
+                    }
+                    else {
+                        fileLines.splice(fileLines.length, 0, ...inserted);
+                        trackFirstChanged(fileLines.length - inserted.length + 1);
+                    }
+                }
+                break;
+            }
+            case "prepend": {
+                const inserted = edit.lines;
+                if (inserted.length === 0) {
+                    noopEdits.push({
+                        editIndex: idx,
+                        loc: edit.pos ? `${edit.pos.line}#${edit.pos.hash}` : "BOF",
+                        current: edit.pos ? originalFileLines[edit.pos.line - 1] : "",
+                    });
+                    break;
+                }
+                if (edit.pos) {
+                    fileLines.splice(edit.pos.line - 1, 0, ...inserted);
+                    trackFirstChanged(edit.pos.line);
+                }
+                else {
+                    if (fileLines.length === 1 && fileLines[0] === "") {
+                        fileLines.splice(0, 1, ...inserted);
+                    }
+                    else {
+                        fileLines.splice(0, 0, ...inserted);
+                    }
+                    trackFirstChanged(1);
+                }
+                break;
+            }
+        }
+    }
+    return {
+        lines: fileLines.join("\n"),
+        firstChangedLine,
+        ...(warnings.length > 0 ? { warnings } : {}),
+        ...(noopEdits.length > 0 ? { noopEdits } : {}),
+    };
+}
+//# sourceMappingURL=hashline.js.map