pi-hashline-edit-pro 4.2.4 → 4.2.6

package/README.md

@@ -192,7 +192,7 @@ On non-Windows platforms the directory honors `XDG_CONFIG_HOME` when set (fallin
 
 ## How anchors work
 
-Anchors are allocated, never derived. Every line that is served to you, by `read`, `anchor_grep`, the auto-read block after `write`, or a post-edit diff, gets the next free anchor from the session's pool, claimed by walking the table with a large stride (roughly the golden ratio of the anchor space) coprime to it, so consecutively minted anchors land in unrelated regions of the table instead of sharing leading characters. Ownership is exclusive: an anchor is owned by one file's line until it is freed (the line was edited, the file was written or deleted, or you ran `/clear-anchors`). Minting prefers anchors the session has never used; when every unused anchor has been spent, freed anchors are recycled after their stale served records are purged, so an anchor is never shared by two live lines. Because ownership is exclusive, an anchor resolves to exactly one file. Two byte-identical lines never share an anchor, and that guarantee sets the file size cap: at most 1,353,139 lines per file, beyond which `read`, `replace`, and `insert` reject with `[E_FILE_TOO_LARGE]` (use `write` for very large files).
+Anchors are allocated, never derived. Every line that is served to you, by `read`, `anchor_grep`, the auto-read block after `write`, or a post-edit diff, gets the next free anchor from the session's pool, claimed by walking the table with a large stride (roughly the golden ratio of the anchor space) coprime to it, so consecutively minted anchors land in unrelated regions of the table instead of sharing leading characters. Each session seeds its walk from its own offset (derived from the session key and the process id), so concurrent sessions mint disjoint sequences instead of identical ones: an anchor minted in one session is unknown in another and is rejected with `[E_STALE_ANCHOR]` rather than resolving to a different file. Ownership is exclusive: an anchor is owned by one file's line until it is freed (the line was edited, the file was written or deleted, or you ran `/clear-anchors`). Minting prefers anchors the session has never used; when every unused anchor has been spent, freed anchors are recycled after their stale served records are purged, so an anchor is never shared by two live lines. Because ownership is exclusive, an anchor resolves to exactly one file. Two byte-identical lines never share an anchor, and that guarantee sets the file size cap: at most 1,353,139 lines per file, beyond which `read`, `replace`, and `insert` reject with `[E_FILE_TOO_LARGE]` (use `write` for very large files).
 
 The table is curated for tokenizers, not for humans. Every anchor is the concatenation of two 2-character pieces that each encode as a single token, and beside the `│` separator the whole 5-character `anchor│` unit is verified to tokenize as exactly three tokens in each of eight modern open-weights tokenizers (Qwen 3.5, DeepSeek V4, Gemma 4, GLM 5.3 Flash, Tencent Hy4-preview, MiniMax M3, MiMo V2.5, Kimi K3). The shipped table is the intersection that satisfies the criterion on all of them; Nemotron 3 Ultra is the one modern tokenizer excluded. An anchor therefore costs 2 tokens on a read row and 2 in an edit call, with the `│` separator as the third. Anchors are letters only. The table is shipped as `src/hashline/anchor-table.json`.
 
@@ -218,7 +218,7 @@ Codes starting with `E_` are errors: nothing was written — except `File was wr
 | Code | Meaning |
 | --- | --- |
 | `[E_BAD_SHAPE]` | Request envelope or edit item has unknown, missing, or wrongly-typed fields (for example `replacement_lines` must be an array of strings, one element per line). |
-| `[W_BAD_SHAPE]` | Auto-corrected request slip reported as a warning (for example unwrapped JSON array syntax or embedded newlines split into lines). |
+| `[W_BAD_SHAPE]` | Auto-corrected request slip reported as a warning (for example unwrapped JSON array syntax, embedded newlines split into lines, or stringified array text that could not be parsed and was kept as one literal line). |
 | `[E_BAD_REF]` | An anchor in `remove_from`/`remove_to` is not a bare 4-char anchor. |
 | `[W_BAD_REF]` | A pasted `anchor│` or diff-preview marker was stripped from an anchor field with a warning. |
 | `[E_STALE_ANCHOR]` | An anchor is not owned in this session (it was never shown to you, or its line was edited or the file was rewritten); call `read` for fresh anchors. |
@@ -236,6 +236,7 @@ Codes starting with `E_` are errors: nothing was written — except `File was wr
 | `[E_BOUNDARY_STRICT]` | Strict boundary dedup rejected the edit because replacement lines re-include edge lines; resend without those lines. |
 | `[E_FILE_TOO_LARGE]` | The file exceeds the 1,353,139-line hashline limit or the 100MB size limit. |
 | `[E_REGISTRY]` | The anchor registry was not initialized; a serve or edit ran outside an initialized session. |
+| `[E_STORE_UNAVAILABLE]` | No SQLite runtime could be loaded: the host exposes neither `node:sqlite` (Node 22.19+) nor `bun:sqlite`. The pi release binary's bundled Bun lacks `node:sqlite`; run pi under Node or a Bun build that ships SQLite. |
 | `[E_WRITE_HASH_ECHO]` | A `write` `content` line begins with the exact `anchor│` served for this file at the same line. The write is refused, file byte-identical; retry with bare content (remove the copied anchors). |
 | `[E_PATH_CHANGED]` | A write target changed identity after it was read; the write was refused to avoid following a swapped symlink or overwriting a replacement file. |
 | `[E_BATCH_OVERLAP]` | Batched `replace`/`insert` calls target overlapping ranges; the whole batch was refused. Retry with disjoint ranges. |

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "pi-hashline-edit-pro",
-  "version": "4.2.4",
+  "version": "4.2.6",
   "type": "module",
   "description": "Hash-anchored read/replace/insert/grep tools for pi-coding-agent. Every line gets a unique 4-char tokenizer-friendly anchor that stays stable across edits; stale or ambiguous anchors are rejected, never fuzzy-matched. Undo persists across restarts.",
   "main": "index.ts",

package/src/anchor-registry.ts

@@ -60,8 +60,8 @@ function seedServedFromOwned(state: SessionState): void {
 	}
 }
 
-export function foldRegistryEvents(events: RegistryEvent[]): SessionState {
-  const state = newSessionState();
+export function foldRegistryEvents(events: RegistryEvent[], seed?: string): SessionState {
+  const state = newSessionState(seed);
   for (const event of events) {
     if (event.kind === "clear") {
       state.owned.clear();
@@ -157,7 +157,7 @@ export async function initRegistry(sessionFile: string | undefined): Promise<voi
   if (!sessionFile) {
     currentKey = `__ephemeral__-${Date.now()}-${Math.random().toString(36).slice(2)}`;
     currentSidecar = undefined;
-    registries.set(currentKey, newSessionState());
+    registries.set(currentKey, newSessionState(currentKey));
     return;
   }
   const key = sidecarKeyFor(sessionFile);
@@ -173,7 +173,7 @@ export async function initRegistry(sessionFile: string | undefined): Promise<voi
       console.error("Failed to read anchor registry sidecar:", error);
     }
   }
-  const folded = foldRegistryEvents(events);
+  const folded = foldRegistryEvents(events, `${key}:${process.pid}`);
   seedServedFromOwned(folded);
   registries.set(key, folded);
   if (rawLog.length > 0) {

package/src/config.ts

@@ -46,10 +46,10 @@ export function normalizeDiffContextLines(value: unknown): number {
 
 function parseConfig(content: string): Config {
   const parsed = JSON.parse(content) as unknown;
-  const autoRead = isRec(parsed) ? parsed.autoRead : undefined;
-  if (typeof autoRead !== "boolean") {
+  if (!isRec(parsed) || (parsed.autoRead !== undefined && typeof parsed.autoRead !== "boolean")) {
     throw new Error("config.json must be an object with a boolean autoRead field");
   }
+  const autoRead = parsed.autoRead;
   const anchorGrepEnabled = isRec(parsed) ? parsed.anchorGrepEnabled : undefined;
   const requirePath = isRec(parsed) ? parsed.requirePath : undefined;
   const strictInput = isRec(parsed) ? parsed.strictInput : undefined;
@@ -57,7 +57,7 @@ function parseConfig(content: string): Config {
   const legacyBoundaryDedup = isRec(parsed) ? parsed.boundaryDedupEnabled : undefined;
   const diffContextLines = isRec(parsed) ? parsed.diffContextLines : undefined;
   return {
-    autoRead,
+    autoRead: typeof autoRead === "boolean" ? autoRead : DEFAULT_CONFIG.autoRead,
     anchorGrepEnabled: typeof anchorGrepEnabled === "boolean" ? anchorGrepEnabled : DEFAULT_CONFIG.anchorGrepEnabled,
     requirePath: typeof requirePath === "boolean" ? requirePath : DEFAULT_CONFIG.requirePath,
     strictInput: typeof strictInput === "boolean" ? strictInput : DEFAULT_CONFIG.strictInput,

package/src/hash-store.ts

@@ -39,10 +39,81 @@ interface RawDb {
   close(): void;
   readonly isOpen: boolean;
 }
-export type SqliteEngine = "node:sqlite";
-const sqliteEngine: SqliteEngine = "node:sqlite";
-const { DatabaseSync } = await import("node:sqlite");
-const openDbFn = (path: string): RawDb => new DatabaseSync(path, { timeout: HASH_STORE_BUSY_TIMEOUT }) as unknown as RawDb;
+export type SqliteEngine = "node:sqlite" | "bun:sqlite";
+
+interface BunStatementLike {
+  get(...params: SqlParams): unknown;
+  all(...params: SqlParams): unknown[];
+  run(...params: SqlParams): unknown;
+}
+
+interface BunDbLike {
+  exec(sql: string): void;
+  prepare(sql: string): BunStatementLike;
+  close(): void;
+}
+
+function wrapBunDatabase(mod: { Database: new (path: string) => BunDbLike }): (path: string) => RawDb {
+  return (path) => {
+    const db = new mod.Database(path);
+    db.exec(`PRAGMA busy_timeout = ${HASH_STORE_BUSY_TIMEOUT}`);
+    let closed = false;
+    return {
+      exec: (sql) => db.exec(sql),
+      prepare: (sql) => {
+        const stmt = db.prepare(sql);
+        return {
+          get: (...params) => stmt.get(...params) ?? undefined,
+          all: (...params) => stmt.all(...params),
+          run: (...params) => stmt.run(...params),
+        };
+      },
+      close: () => {
+        if (!closed) {
+          closed = true;
+          db.close();
+        }
+      },
+      get isOpen() {
+        return !closed;
+      },
+    };
+  };
+}
+
+async function loadNodeEngine(): Promise<{ engine: SqliteEngine; open: (path: string) => RawDb }> {
+  const { DatabaseSync } = await import("node:sqlite");
+  return {
+    engine: "node:sqlite",
+    open: (path) => new DatabaseSync(path, { timeout: HASH_STORE_BUSY_TIMEOUT }) as unknown as RawDb,
+  };
+}
+
+async function loadBunEngine(): Promise<{ engine: SqliteEngine; open: (path: string) => RawDb }> {
+  const specifier = "bun:sqlite";
+  const mod = await import(specifier) as { Database: new (path: string) => BunDbLike };
+  return { engine: "bun:sqlite", open: wrapBunDatabase(mod) };
+}
+
+const isBunRuntime = typeof process !== "undefined" && typeof (process.versions as Record<string, string | undefined>).bun === "string";
+
+async function selectSqliteEngine(): Promise<{ engine: SqliteEngine; open: (path: string) => RawDb }> {
+  const candidates = isBunRuntime ? [loadBunEngine, loadNodeEngine] : [loadNodeEngine, loadBunEngine];
+  let lastError: unknown;
+  for (const candidate of candidates) {
+    try {
+      return await candidate();
+    } catch (error) {
+      lastError = error;
+    }
+  }
+  const detail = lastError instanceof Error ? lastError.message : String(lastError);
+  throw new Error(`[E_STORE_UNAVAILABLE] No SQLite runtime available (node:sqlite and bun:sqlite both failed to load): ${detail}`);
+}
+
+const selectedEngine = await selectSqliteEngine();
+const sqliteEngine: SqliteEngine = selectedEngine.engine;
+const openDbFn = selectedEngine.open;
 
 interface Prepared {
   get: (...params: SqlParams) => Record<string, unknown> | undefined;

package/src/hashline/resolve.ts

@@ -1,4 +1,4 @@
-import { abortIf, rejectUnknownFields, firstNonEmptyIndex, lastNonEmptyIndex, clipLine, getCached } from "../utils";
+import { abortIf, rejectUnknownFields, firstNonEmptyIndex, lastNonEmptyIndex, clipLine, getCached, decodeStringArray } from "../utils";
 import { parseHashRef, parseText, type Anchor } from "./parse";
 import { HASH_SEP, stripRowPrefix, canon } from "./hash";
 import { HASH_RUN } from "./alphabet";
@@ -171,7 +171,7 @@ export function stripAnchorRow(
 export function resEdit(edit: HTEdit, warnings?: string[]): HEdit {
   assertItem(edit as Record<string, unknown>);
 
-  const replaceLines = parseText(edit.replacement_lines, warnings);
+  const replaceLines = parseText(decodeStringArray(edit.replacement_lines, warnings) ?? edit.replacement_lines, warnings);
   const bounds = [edit.remove_from, edit.remove_to].map((ref) => {
     return stripAnchorRow(ref.trim(), "remove_from/remove_to entry", warnings);
   }) as [string, string];

package/src/insert.ts

@@ -95,11 +95,8 @@ export async function insertPreview(request: unknown, cwd: string, signal?: Abor
     const normalized = normReq(request);
     const previewFixes: string[] = [];
     if (isRec(normalized)) {
-      const expanded = decodeStringArray(normalized.lines);
-      if (expanded) {
-        previewFixes.push('[W_BAD_SHAPE] Unwrapped JSON array syntax from a lines element.');
-        normalized.lines = expanded;
-      }
+      const expanded = decodeStringArray(normalized.lines, previewFixes, "lines");
+      if (expanded) normalized.lines = expanded;
     }
     assertInsertReq(normalized);
     const previewReq = normalized as InsertReq;
@@ -178,11 +175,8 @@ export function buildInsertToolDef(flags: EditToolFlags = DEFAULT_EDIT_FLAGS): I
       const canonical = normReq(params);
       const insertWarnings: string[] = [];
       if (isRec(canonical)) {
-        const expanded = decodeStringArray(canonical.lines);
-        if (expanded) {
-          insertWarnings.push('[W_BAD_SHAPE] Unwrapped JSON array syntax from a lines element.');
-          canonical.lines = expanded;
-        }
+        const expanded = decodeStringArray(canonical.lines, insertWarnings, "lines");
+        if (expanded) canonical.lines = expanded;
       }
       assertInsertReq(canonical);
       const req = canonical;

package/src/replace.ts

@@ -11,7 +11,7 @@ import {
 } from "./replace-diff";
 import { readNormFile, type NormFile } from "./file-reader";
 import { editToolSchema, buildEditToolSchema, type ReqParams, assertReq, normReq } from "./payload-contract";
-import { decodeStringArray, splitLines } from "./utils";
+import { splitLines } from "./utils";
 import { loadP, loadGuide } from "./prompts";
 import { type FileIdentity } from "./fs-write";
 import { applyEdit,
@@ -118,17 +118,11 @@ function countLineChanges(
 
 export function buildReplaceHEdit(params: ReqParams): { edit: HEdit; warnings: string[] } {
   const editWarnings: string[] = [];
-  let replacementLines = params.replacement_lines;
-  const expandedReplacement = decodeStringArray(replacementLines);
-  if (expandedReplacement) {
-    editWarnings.push('[W_BAD_SHAPE] Unwrapped JSON array syntax from a replacement_lines element.');
-    replacementLines = expandedReplacement;
-  }
   const edit = resEdit(
     {
       remove_from: params.remove_from,
       remove_to: params.remove_to,
-      replacement_lines: replacementLines,
+      replacement_lines: params.replacement_lines,
     },
     editWarnings,
   );

package/src/utils.ts

@@ -181,83 +181,117 @@ function formatLineLimit(displayPath: string, limit: number, count: number | und
 	return `[E_FILE_TOO_LARGE] ${displayPath} ${detail} lines, exceeding the ${limit}-line hashline limit. For very large files, use write.`;
 }
 
-function escapeRawControl(value: string): string {
-	if (value === "\b") return "\\b";
-	if (value === "\t") return "\\t";
-	if (value === "\n") return "\\n";
-	if (value === "\f") return "\\f";
-	if (value === "\r") return "\\r";
-	const hex = value.charCodeAt(0).toString(16).padStart(4, "0");
-	return `\\u${hex}`;
+function stripCodeFence(text: string): string {
+	const trimmed = text.trim();
+	const fenced = /^```[^\n]*\n([\s\S]*?)\n?```$/.exec(trimmed);
+	return fenced ? fenced[1]!.trim() : trimmed;
 }
 
-function escapeControls(value: string): string {
-	let out = "";
-	for (const char of value) {
-		out += char.charCodeAt(0) < 32 ? escapeRawControl(char) : char;
+function jsonStringArray(text: string): string[] | undefined {
+	try {
+		const parsed: unknown = JSON.parse(text);
+		if (Array.isArray(parsed) && parsed.every((entry) => typeof entry === "string")) {
+			return parsed as string[];
+		}
+	} catch {
 	}
-	return out;
+	return undefined;
 }
 
-function decodeArraySegment(segment: string): string | undefined {
-	const trimmed = segment.trim();
-	if (trimmed.length < 2 || !trimmed.startsWith('"') || !trimmed.endsWith('"')) return undefined;
-	try {
-		const cleaned = escapeControls(trimmed);
-		const parsed: unknown = JSON.parse(cleaned);
-		return typeof parsed === "string" ? parsed : undefined;
-	} catch {
-		return undefined;
+function decodeEscape(char: string): string | undefined {
+	switch (char) {
+		case "\"": return "\"";
+		case "'": return "'";
+		case "\\": return "\\";
+		case "/": return "/";
+		case "b": return "\b";
+		case "f": return "\f";
+		case "n": return "\n";
+		case "r": return "\r";
+		case "t": return "\t";
+		default: return undefined;
 	}
 }
 
-function splitArraySegments(inner: string): string[] | undefined {
-	const segments: string[] = [];
-	let current = "";
-	let inQuotes = false;
-	let escaped = false;
-	for (const char of inner) {
-		if (inQuotes) {
-			current += char;
-			if (escaped) escaped = false;
-			else if (char === "\\") escaped = true;
-			else if (char === '"') inQuotes = false;
-			continue;
-		}
-		if (char === '"') {
-			inQuotes = true;
-			current += char;
-			continue;
-		}
-		if (char === ",") {
-			segments.push(current);
-			current = "";
+function scanQuotedSegment(inner: string, start: number): { value: string; next: number } | undefined {
+	const quote = inner[start]!;
+	let out = "";
+	let index = start + 1;
+	while (index < inner.length) {
+		const char = inner[index]!;
+		if (char === "\\") {
+			const escaped = inner[index + 1];
+			if (escaped === undefined) return undefined;
+			if (escaped === "u") {
+				const hex = inner.slice(index + 2, index + 6);
+				if (!/^[0-9a-fA-F]{4}$/.test(hex)) return undefined;
+				out += String.fromCharCode(Number.parseInt(hex, 16));
+				index += 6;
+				continue;
+			}
+			const decoded = decodeEscape(escaped);
+			if (decoded === undefined) return undefined;
+			out += decoded;
+			index += 2;
 			continue;
 		}
-		current += char;
+		if (char === quote) return { value: out, next: index + 1 };
+		out += char;
+		index += 1;
+	}
+	return undefined;
+}
+
+function scanArrayText(inner: string): string[] | undefined {
+	const values: string[] = [];
+	let index = 0;
+	while (index < inner.length && /\s/.test(inner[index]!)) index += 1;
+	if (index >= inner.length) return [];
+	for (;;) {
+		if (inner[index] !== "\"" && inner[index] !== "'") return undefined;
+		const segment = scanQuotedSegment(inner, index);
+		if (!segment) return undefined;
+		values.push(segment.value);
+		index = segment.next;
+		while (index < inner.length && /\s/.test(inner[index]!)) index += 1;
+		if (index >= inner.length) return values;
+		if (inner[index] !== ",") return undefined;
+		index += 1;
+		while (index < inner.length && /\s/.test(inner[index]!)) index += 1;
+		if (index >= inner.length) return values;
 	}
-	if (inQuotes || escaped) return undefined;
-	segments.push(current);
-	return segments;
 }
 
 function decodeArrayText(value: unknown): string[] | undefined {
 	if (typeof value !== "string") return undefined;
-	const trimmed = value.trim();
+	const trimmed = stripCodeFence(value);
 	if (!trimmed.startsWith("[") || !trimmed.endsWith("]")) return undefined;
-	const segments = splitArraySegments(trimmed.slice(1, -1));
-	if (!segments) return undefined;
-	const decoded: string[] = [];
-	for (const segment of segments) {
-		const part = decodeArraySegment(segment);
-		if (part === undefined) return undefined;
-		decoded.push(part);
-	}
-	return decoded.length > 0 ? decoded : undefined;
+	const decoded = jsonStringArray(trimmed);
+	if (decoded !== undefined && decoded.length > 0) return decoded;
+	const scanned = scanArrayText(trimmed.slice(1, -1));
+	return scanned !== undefined && scanned.length > 0 ? scanned : undefined;
+}
+
+function looksLikeStringArray(value: unknown): boolean {
+	if (typeof value !== "string") return false;
+	const trimmed = stripCodeFence(value);
+	return trimmed.endsWith("]") && /^\[\s*['"]/.test(trimmed);
 }
 
-export function decodeStringArray(value: unknown): string[] | undefined {
-	if (typeof value === "string") return decodeArrayText(value);
-	if (Array.isArray(value) && value.length === 1) return decodeArrayText(value[0]);
+export function decodeStringArray(value: unknown, warnings?: string[], label = "replacement_lines"): string[] | undefined {
+	const candidate = typeof value === "string"
+		? value
+		: Array.isArray(value) && value.length === 1 && typeof value[0] === "string"
+			? value[0]
+			: undefined;
+	if (candidate === undefined) return undefined;
+	const decoded = decodeArrayText(candidate);
+	if (decoded !== undefined) {
+		warnings?.push(`[W_BAD_SHAPE] Unwrapped JSON array syntax from a ${label} element.`);
+		return decoded;
+	}
+	if (looksLikeStringArray(candidate)) {
+		warnings?.push(`[W_BAD_SHAPE] ${label} looked like a JSON array but could not be parsed; kept as one literal line: ${clipLine(candidate, 60)}`);
+	}
 	return undefined;
 }