pi-hashline-edit-pro 2.8.3 → 3.0.0

package/src/hashline/hash.ts

@@ -7,36 +7,20 @@ import {
   persistSnapshot,
 } from "../hash-store";
 import { xxh32, initHasher } from "./hasher";
-import { HASH_LEN, ALPH, ALPH_RE, HASH_CLASS, HASH_RUN } from "./alphabet";
-export { initHasher, HASH_LEN, ALPH_RE, HASH_CLASS, HASH_RUN };
+import { HASH_LEN, ANCHOR_COUNT, anchorAt, anchorIndex, HASH_CLASS, HASH_RUN } from "./alphabet";
+export { initHasher, HASH_LEN, HASH_CLASS, HASH_RUN };
 
 export const ANCHOR_LEN = HASH_LEN;
 
 export const HASH_SEP = "│";
 
-export const HASH_SPACE = ALPH.length ** HASH_LEN;
+export const HASH_SPACE = ANCHOR_COUNT;
 export const MAX_HASH_LINES = HASH_SPACE;
 
-export const HASH_PROBE_STRIDE = ALPH.length ** 2 + ALPH.length + 1;
-
-function idxToHash(idx: number): string {
-  let out = "";
-  for (let j = 0; j < HASH_LEN; j++) {
-    out = ALPH[idx % ALPH.length]! + out;
-    idx = Math.floor(idx / ALPH.length);
-  }
-  return out;
-}
-
-const hashCache = new Map<number, string>();
+export const HASH_PROBE_STRIDE = 571;
 
 function hashAt(idx: number): string {
-  let hash = hashCache.get(idx);
-  if (hash === undefined) {
-    hash = idxToHash(idx);
-    hashCache.set(idx, hash);
-  }
-  return hash;
+  return anchorAt(idx);
 }
 
 export const HL_PREFIX_PLUS_RE = new RegExp(
@@ -182,13 +166,7 @@ export async function lineHashes(
 }
 
 function hashToIndex(hash: string): number {
-  let idx = 0;
-  for (let j = 0; j < HASH_LEN; j++) {
-    const charIdx = ALPH.indexOf(hash[j]!);
-    if (charIdx < 0) return -1;
-    idx = idx * ALPH.length + charIdx;
-  }
-  return idx;
+  return anchorIndex(hash);
 }
 
 function nearestNew(

package/src/hashline/parse.ts

@@ -1,8 +1,8 @@
 import {
 	ANCHOR_LEN,
-	ALPH_RE,
 	HASH_CLASS,
 } from "./hash";
+import { ALPH_RE } from "./alphabet";
 import { NEW_CONTENT_NOT_ARRAY_MSG } from "../constants";
 
 const HASH_EXTRACT_RE = new RegExp(HASH_CLASS);
@@ -13,11 +13,11 @@ function diagRef(ref: string): string {
 	const trimmed = ref.trim();
 
 	if (!trimmed.length) {
-		return `[E_BAD_REF] Invalid anchor. Expected a 3-char alphanumeric anchor (e.g. "aB3").`;
+		return `[E_BAD_REF] Invalid anchor. Expected a 4-char alphanumeric anchor (e.g. "Hasu").`;
 	}
 
 	if (/^\d+/.test(trimmed)) {
-		return `[E_BAD_REF] Invalid anchor. Use the anchor alone (e.g. "aB3"): no line numbers or trailing content.`;
+		return `[E_BAD_REF] Invalid anchor. Use the anchor alone (e.g. "Hasu"): no line numbers or trailing content.`;
 	}
 	if (trimmed.includes("│") && trimmed.includes("\n")) {
 		const lines = trimmed.split(/\r?\n/);
@@ -26,16 +26,16 @@ function diagRef(ref: string): string {
 		const hashRe = HASH_EXTRACT_RE;
 		const firstMatch = first.match(hashRe);
 		const lastMatch = last.match(hashRe);
-		const firstHash = firstMatch?.[0] ?? "aB3";
-		const lastHash = lastMatch?.[0] ?? "aB3";
+		const firstHash = firstMatch?.[0] ?? "Hasu";
+		const lastHash = lastMatch?.[0] ?? "Hasu";
 		const preview = first.slice(0, 60);
-		return `[E_BAD_REF] Invalid anchor — remove_from and remove_to must each be a single bare 3-char hash (e.g. "aB3"), not a block with HASH│content. Received ${lines.length} lines starting "${preview}…" — use only the first hash "${firstHash}" as remove_from and "${lastHash}" as remove_to, and put the new content (without HASH│) in replacement_lines.`;
+		return `[E_BAD_REF] Invalid anchor — remove_from and remove_to must each be a single bare 4-char hash (e.g. "Hasu"), not a block with HASH│content. Received ${lines.length} lines starting "${preview}…" — use only the first hash "${firstHash}" as remove_from and "${lastHash}" as remove_to, and put the new content (without HASH│) in replacement_lines.`;
 	}
 	if (trimmed.includes("│")) {
-		return `[E_BAD_REF] Invalid anchor "${trimmed}": use only the 3-char anchor, drop everything from "│" onward.`;
+		return `[E_BAD_REF] Invalid anchor "${trimmed}": use only the 4-char anchor, drop everything from "│" onward.`;
 	}
 
-	return `[E_BAD_REF] Invalid anchor "${trimmed}". Expected a 3-char alphanumeric anchor (e.g. "aB3").`;
+	return `[E_BAD_REF] Invalid anchor "${trimmed}". Expected a 4-char alphanumeric anchor (e.g. "Hasu").`;
 }
 
 function parseRef(ref: string): Anchor {
@@ -53,6 +53,23 @@ function parseRef(ref: string): Anchor {
 
 export const parseHashRef = parseRef;
 
+const JSON_ENVELOPE_RE = /^\s*\["(.*)"\]\.\s*$/;
+
+function unwrapJsonEnvelope(line: string, warnings?: string[]): string {
+  const match = line.match(JSON_ENVELOPE_RE);
+  if (!match) return line;
+  const withoutDot = line.trim().slice(0, -1);
+  try {
+    JSON.parse(withoutDot);
+    return line;
+  } catch {
+    warnings?.push(
+      '[E_BAD_SHAPE] Unwrapped JSON array syntax from a replacement_lines element.',
+    );
+    return match[1]!;
+  }
+}
+
 export function parseText(edit: string[], warnings?: string[]): string[] {
   if (!Array.isArray(edit) || edit.some((line) => typeof line !== "string")) {
     throw new Error(NEW_CONTENT_NOT_ARRAY_MSG);
@@ -60,13 +77,14 @@ export function parseText(edit: string[], warnings?: string[]): string[] {
   const out: string[] = [];
   let split = false;
   for (const line of edit) {
-    const normalized = line.replace(/\r\n/g, "\n").replace(/\r/g, "\n");
-    if (normalized !== line) split = true;
+    const unwrapped = unwrapJsonEnvelope(line, warnings);
+    const normalized = unwrapped.replace(/\r\n/g, "\n").replace(/\r/g, "\n");
+    if (normalized !== unwrapped) split = true;
     out.push(...normalized.split("\n"));
   }
   if (split) {
     warnings?.push(
-      "[E_BAD_SHAPE] Autocorrected: split embedded newlines in replacement_lines into separate lines.",
+      "[E_BAD_SHAPE] replacement_lines contained embedded newlines; split into one line each.",
     );
   }
   return out;

package/src/hashline/resolve.ts

@@ -159,12 +159,12 @@ function assertItem(edit: Record<string, unknown>): void {
 
   if ("remove_from" in edit && typeof edit.remove_from !== "string") {
     throw new Error(
-      `[E_BAD_SHAPE] Field "remove_from" must be an anchor string (3-char anchor).`,
+      `[E_BAD_SHAPE] Field "remove_from" must be an anchor string (4-char anchor).`,
     );
   }
   if ("remove_to" in edit && typeof edit.remove_to !== "string") {
     throw new Error(
-      `[E_BAD_SHAPE] Field "remove_to" must be an anchor string (3-char anchor).`,
+      `[E_BAD_SHAPE] Field "remove_to" must be an anchor string (4-char anchor).`,
     );
   }
   if (!("replacement_lines" in edit)) {
@@ -175,7 +175,7 @@ function assertItem(edit: Record<string, unknown>): void {
   }
   if (typeof edit.remove_from !== "string" || typeof edit.remove_to !== "string") {
     throw new Error(
-      `[E_BAD_SHAPE] The edit requires "remove_from" and "remove_to" anchor strings (3-char anchors from read output).`,
+      `[E_BAD_SHAPE] The edit requires "remove_from" and "remove_to" anchor strings (4-char anchors from read output).`,
     );
   }
 }
@@ -195,7 +195,7 @@ export function stripAnchorRow(
 			: match[1] === "-"
 				? 'leading "-" marker'
 				: '"anchor│" prefix';
-	warnings?.push(`[E_BAD_REF] Stripped ${marker} from ${entryLabel} "${trimmed}".`);
+	warnings?.push(`[E_BAD_REF] Stripped ${marker} from ${entryLabel} "${clipLine(trimmed, 48)}".`);
 	return match[2]!;
 }
 
@@ -240,13 +240,8 @@ export function stripBarePrefixes(
 	const locations = stripped
 		.map((s) => `replacement_lines line ${s.lineIndex + 1}`)
 		.join(", ");
-	const matchedCount = stripped.filter((s) => s.matched).length;
-	const guidance =
-		matchedCount === 0
-			? " Verify it was pasted from read output."
-			: "";
 	warnings.push(
-		`[E_BARE_HASH_PREFIX] Stripped "anchor│" prefix from ${locations}.${guidance}`
+		`[E_BARE_HASH_PREFIX] Stripped "anchor│" prefix from ${locations}.`
 	);
 	return { ...edit, content_lines: contentLines };
 }
@@ -290,7 +285,7 @@ export function swapReversedRanges(
 		return edit;
 	}
 	warnings.push(
-		`[E_BAD_OP] Autocorrected: remove_from/remove_to were reversed; swapped them.`
+		`[E_BAD_OP] Swapped reversed remove_from/remove_to.`
 	);
 	return { ...edit, hash_bounds: [endRef, startRef] as [Anchor, Anchor] };
 }

package/src/insert.ts

@@ -31,7 +31,7 @@ export function assertInsertReq(request: unknown): asserts request is InsertReq
     throw new Error('[E_BAD_SHAPE] Insert request requires a non-empty "path" string.');
   }
   if (typeof request.anchor !== "string" || request.anchor.length === 0) {
-    throw new Error('[E_BAD_SHAPE] Insert request requires an "anchor" string (3-char anchor from read output).');
+    throw new Error('[E_BAD_SHAPE] Insert request requires an "anchor" string (4-char anchor from read output).');
   }
   if (request.direction !== "before" && request.direction !== "after") {
     throw new Error('[E_BAD_SHAPE] Insert request "direction" must be "before" or "after".');
@@ -49,23 +49,23 @@ const insertToolSchema = Type.Object(
     }),
     anchor: Type.String({
       description:
-        'Bare 3-char anchor only (e.g. "aB3"): copy just the anchor from the leftmost column of a read row like `aB3│content`; never the line content. A pasted diff row like `+aB3│x` or an `anchor│` prefix is stripped automatically with a warning. The anchored line is preserved; the new lines go after or before it.',
+        'Bare 4-char anchor from a read row like `Hasu│content`, never the content. A pasted `+Hasu│x` diff row or `anchor│` prefix is stripped with a warning. The anchor line is preserved; lines go after or before it.',
     }),
     direction: Type.Union(
       [
-        Type.Literal("after", { description: "Insert the lines after the anchor line" }),
-        Type.Literal("before", { description: "Insert the lines before the anchor line" }),
+        Type.Literal("after"),
+        Type.Literal("before"),
       ],
       { description: '"after" or "before"' },
     ),
     lines: Type.Array(
       Type.String({
         description:
-          "One line to insert. Each element is exactly one line; do not embed \\n inside an element: use separate elements.",
+          "One line to insert; never embed \\n inside an element.",
       }),
       {
         description:
-          'Lines to insert as an array of strings, one element per line. Use [""] for a blank line. The anchor line is preserved; never include it in lines.',
+          'One string per line; [""] is a blank line; never include the anchor line.',
       }
     ),
   },

package/src/payload-contract.ts

@@ -4,22 +4,22 @@ import { isRec, normalizeFilePath, rejectUnknownFields } from "./utils";
 const replacementLinesSchema = Type.Array(
   Type.String({
     description:
-      "One replacement line. Each element is exactly one line; do not embed \\n inside an element: use separate elements.",
+      "One replacement line; never embed \\n inside an element.",
   }),
   {
     description:
-      "Replacement lines as an array of strings, one element per line. Use [] to delete the range.",
+      "One string per line. Use [] to delete the range.",
   },
 );
 
 const removeFromSchema = Type.String({
   description:
-    "Bare 3-char anchor only (e.g. \"aB3\"): copy just the anchor from the leftmost column of a read row like `aB3│content`; never the line content. Marks the FIRST line to remove (inclusive)",
+    "Bare 4-char anchor from a read row like `Hasu│content` (the leftmost column), never the row content. Marks the FIRST line to remove (inclusive)",
 });
 
 const removeToSchema = Type.String({
   description:
-    "Bare 3-char anchor only (e.g. \"aB3\"): copy just the anchor from the leftmost column of a read row like `aB3│content`; never the line content. Marks the LAST line to remove (inclusive)",
+    "Bare 4-char anchor from a read row like `Hasu│content` (the leftmost column), never the row content. Marks the LAST line to remove (inclusive)",
 });
 
 export const editToolSchema = Type.Object(
@@ -27,7 +27,7 @@ export const editToolSchema = Type.Object(
     path: Type.Optional(
       Type.String({
         description:
-          "Path to edit. Required: always provide it explicitly; it is only auto-resolved from the anchors as a fallback when omitted by mistake.",
+          "Path to edit; always provide it explicitly — it is only auto-resolved from the anchors as a fallback.",
       }),
     ),
     remove_from: removeFromSchema,

package/src/replace-response.ts

@@ -100,7 +100,7 @@ export function buildNoop(input: NoopInput, noopNoun = "Replacement"): TResult {
 		: "The edit produced identical content.";
 	const dedupNote =
 		boundaryRemovedLines !== undefined && boundaryRemovedLines > 0
-			? `\nBoundary dedup removed ${boundaryRemovedLines} line(s) from the replacement. Send the same edit again to apply it literally.`
+			? `\nBoundary dedup removed ${boundaryRemovedLines} line(s); resend the same edit to apply it literally.`
 			: "";
 
 	const text = `No changes made to ${path}\nClassification: noop\n${noopDetailsText}${dedupNote}${warnBlock(warnings)}`;

package/src/replace-undo.ts

@@ -146,7 +146,7 @@ export function regUndo(pi: ExtensionAPI): void {
             content: [
               {
                 type: "text",
-                text: `[E_UNDO_STALE] Cannot undo last change on ${path}: the file changed after the edit. The undo record is kept; once the file matches the edited state again, undo_last_change will succeed. Call read() to inspect the current state.`
+                text: `[E_UNDO_STALE] Cannot undo last change on ${path}: the file was modified after the edit, so nothing was reverted. The current content already contains your applied edit plus that external change and is most likely the correct state. Do not modify the file to make an undo possible and do not revert your own edit. The undo record is kept. Call read() to verify the current state, then stop.`
               },
             ],
             isError: true,

package/src/replace.ts

@@ -63,6 +63,7 @@ export interface PipelineResult {
   totalRemovedLines: number;
   hadBoundaryDedup: boolean;
   boundaryRemovedLines: number;
+  boundaryRemovedLineTexts: string[];
   identity: FileIdentity;
 }
 
@@ -91,7 +92,7 @@ async function resolveMissingPath(
   if (matches.length === 1) {
     return {
       path: matches[0]!,
-      warning: `[E_BAD_SHAPE] Autocorrected: missing "path" resolved to ${matches[0]}.`,
+      warning: `[E_BAD_SHAPE] Missing "path" resolved to ${matches[0]}.`,
     };
   }
   if (matches.length > 1) {
@@ -226,6 +227,7 @@ export async function execPipeline(
     totalRemovedLines,
     hadBoundaryDedup: (anchorResult.autoFixes?.length ?? 0) > 0,
     boundaryRemovedLines: anchorResult.autoFixes?.length ?? 0,
+    boundaryRemovedLineTexts: anchorResult.autoFixes?.map((fix) => fix.removedLine) ?? [],
     identity,
   };
 }

package/src/utils.ts

@@ -114,7 +114,7 @@ export function getCached<K, V>(map: Map<K, V>, key: K, compute: (key: K) => V):
 }
 
 export function isHashRow(line: string): boolean {
-	return /^[A-Za-z0-9]{3}│/.test(line);
+	return /^[A-Za-z0-9]{4}│/.test(line);
 }
 
 function gutterWidth(max: number, fallback: number): number {