pi-hashline-edit-pro 4.3.7 → 4.3.8

package/README.md

@@ -73,7 +73,7 @@ Edge cases:
 | --- | --- |
 | `remove_from` | 4-char anchor marking the FIRST line to remove (inclusive). |
 | `remove_to` | 4-char anchor marking the LAST line to remove (inclusive). |
-| `replacement_lines` | Replacement lines, one element per line. Mirror the removed lines exactly, blank lines included: `[]` deletes the range, `[""]` is a single blank line, `["a", ""]` is a line followed by a blank line. Never embed `\n` inside an element. |
+| `replacement_lines` | Replacement lines, one element per line. Mirror the removed lines exactly, blank lines included: `[]` deletes the range, `[""]` is a single blank line, `["a", ""]` is a line followed by a blank line. Never embed `\n` inside an element. A lone string is accepted too: it is split on newlines, and stringified array text is unwrapped. |
 
 Example: read showed `Hasu│old` and `arvm│old2`; to replace both:
 
@@ -89,7 +89,7 @@ Single line: use the same anchor for `remove_from` and `remove_to`. `replace_fro
 
 The request is checked before any file I/O, so a bad request never touches the file.
 
-Common copy-paste slips are fixed automatically: a leftover `anchor│` prefix in `replacement_lines` or the anchor fields (a prefix of 4 to 5 letters before `│`, for example `abde│`), diff-preview rows pasted into the replacement, and a boundary line pasted twice are reported as warnings, while a reversed range, a JSON-array wrapper, and embedded newlines are corrected silently. New lines that re-include a block adjacent to the range are stripped when that block is unique in the file. The whole run is stripped as one unit, so re-including an unchanged block next to the range never duplicates it. Boundary dedup has three modes in `/hashline-config`: `on` strips with a warning, `off` applies edits literally, and `strict` rejects the edit with `[E_BOUNDARY_STRICT]` when any replacement line would be stripped.
+Common copy-paste slips are fixed automatically: a leftover `anchor│` prefix in `replacement_lines` or the anchor fields (a prefix of 4 to 5 letters before `│`, for example `abde│`), diff-preview rows pasted into the replacement, and a boundary line pasted twice are reported as warnings, while a reversed range, stringified array text (even with a trailing JS method call, for example `[…].map(s => s)`), and embedded newlines are corrected silently. New lines that re-include a block adjacent to the range are stripped when that block is unique in the file. The whole run is stripped as one unit, so re-including an unchanged block next to the range never duplicates it. Boundary dedup has three modes in `/hashline-config`: `on` strips with a warning, `off` applies edits literally, and `strict` rejects the edit with `[E_BOUNDARY_STRICT]` when any replacement line would be stripped.
 Content containing a NUL byte (`U+0000`) is rejected with `[E_BAD_SHAPE]` before any file I/O: writing it would make the file binary, so use an empty replacement to delete. This applies to `replace`'s `replacement_lines` and `insert`'s `lines`.
 
 Every line in the removed range must match what was last shown to you. The extension records the `anchor│content` rows it serves (`read` output, `anchor_grep` output, the auto-read block after `write`, the `+anchor│` and ` anchor│` rows of post-edit diffs, the current-range rows of `[E_RANGE_STALE]` feedback, and the context rows of stale-anchor feedback) and verifies the whole range against that record before writing. A line that changed on disk since it was shown, or an anchor that is not owned in this session, refuses the edit with `[E_RANGE_STALE]` or `[E_STALE_ANCHOR]` and returns the current range with fresh anchors, so the retry needs no `read`. An owned anchor enters the served record when its row is shown (after a restart, restored ownership counts as shown), so a file with no owned anchors cannot be edited by anchor at all; call `read` first. An owned line that was never shown — for example beyond an auto-read preview's truncation cap — is refused with `[E_RANGE_STALE]` and returns the current range, so the retry still needs no `read`.
@@ -110,7 +110,7 @@ Batched calls must target disjoint ranges; overlapping ranges, or any failing ca
 | --- | --- |
 | `anchor` | 4-char anchor marking the line next to which the lines go. The anchor line is preserved. A pasted `+Hasu│x` diff row or `anchor│` prefix is stripped automatically with a warning. |
 | `direction` | `"after"` inserts below the anchor line, `"before"` above it. |
-| `lines` | Lines to insert, one element per line. `[""]` is a blank line. Never include the anchor line, and never embed `\n` inside an element. |
+| `lines` | Lines to insert, one element per line. `[""]` is a blank line. Never include the anchor line, and never embed `\n` inside an element. A lone string is split on newlines, and stringified array text is unwrapped. |
 
 Lines are applied literally: nothing is removed, and a line that duplicates its neighbor is kept. `replace`'s boundary anti-duplication never runs for `insert`. Inserting nothing (`lines: []`) reports a noop. To seed an empty file, read it and insert after the `anchor│` empty-line row.
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "pi-hashline-edit-pro",
-  "version": "4.3.7",
+  "version": "4.3.8",
   "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/utils.ts

@@ -36,6 +36,7 @@ export function normalizeRequest(input: unknown): unknown {
   const record: Record<string, unknown> = { ...input };
   normalizeFilePath(record);
   normalizeAnchors(record);
+  normalizeEditLines(record);
   return record;
 }
 
@@ -211,6 +212,47 @@ function stripCodeFence(text: string): string {
 	return fenced ? fenced[1]!.trim() : trimmed;
 }
 
+function arrayLiteralEnd(text: string): number {
+	let depth = 0;
+	let quote: string | undefined;
+	let escaped = false;
+	for (let index = 0; index < text.length; index++) {
+		const char = text[index]!;
+		if (escaped) {
+			escaped = false;
+			continue;
+		}
+		if (char === "\\") {
+			escaped = true;
+			continue;
+		}
+		if (quote !== undefined) {
+			if (char === quote) quote = undefined;
+			continue;
+		}
+		if (char === '"' || char === "'") {
+			quote = char;
+			continue;
+		}
+		if (char === "[") depth += 1;
+		else if (char === "]") {
+			depth -= 1;
+			if (depth === 0) return index + 1;
+		}
+	}
+	return -1;
+}
+
+function stripTrailingMemberCall(text: string): string {
+	if (!text.startsWith("[")) return text;
+	const end = arrayLiteralEnd(text);
+	if (end < 0) return text;
+	const rest = text.slice(end);
+	if (rest.trim().length === 0) return text;
+	if (!rest.trimStart().startsWith(".") || !rest.trimEnd().endsWith(")")) return text;
+	return text.slice(0, end);
+}
+
 function jsonStringArray(text: string): string[] | undefined {
 	try {
 		const parsed: unknown = JSON.parse(text);
@@ -288,7 +330,7 @@ function scanArrayText(inner: string): string[] | undefined {
 
 function decodeArrayText(value: unknown): string[] | undefined {
 	if (typeof value !== "string") return undefined;
-	const trimmed = stripCodeFence(value);
+	const trimmed = stripTrailingMemberCall(stripCodeFence(value));
 	if (!trimmed.startsWith("[") || !trimmed.endsWith("]")) return undefined;
 	const decoded = jsonStringArray(trimmed);
 	if (decoded !== undefined && decoded.length > 0) return decoded;
@@ -298,8 +340,8 @@ function decodeArrayText(value: unknown): string[] | undefined {
 
 function looksLikeStringArray(value: unknown): boolean {
 	if (typeof value !== "string") return false;
-	const trimmed = stripCodeFence(value);
-	return trimmed.endsWith("]") && /^\[\s*['"]/.test(trimmed);
+	const trimmed = stripTrailingMemberCall(stripCodeFence(value));
+	return /^\[\s*['"]/.test(trimmed) && !trimmed.endsWith("].");
 }
 
 export function decodeStringArray(value: unknown, warnings?: string[], label = "replacement_lines"): string[] | undefined {
@@ -318,3 +360,28 @@ export function decodeStringArray(value: unknown, warnings?: string[], label = "
 	}
 	return undefined;
 }
+
+function splitEditLines(text: string): string[] {
+	return text.replace(/\r\n/g, "\n").replace(/\r/g, "\n").split("\n");
+}
+
+function normalizeLineFieldValue(value: unknown): 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 = decodeStringArray(candidate);
+	if (decoded !== undefined) return decoded;
+	if (/^\[\s*\]$/.test(stripTrailingMemberCall(stripCodeFence(candidate)))) return [];
+	return splitEditLines(candidate);
+}
+
+function normalizeEditLines(record: Record<string, unknown>): void {
+	for (const key of ["replacement_lines", "lines"]) {
+		if (!(key in record)) continue;
+		const lines = normalizeLineFieldValue(record[key]);
+		if (lines !== undefined) record[key] = lines;
+	}
+}