pi-hashline-edit-pro 4.2.5 → 4.2.6

package/README.md

@@ -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.5",
+  "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/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;
 }