@xynogen/pix-edit 0.2.7 → 0.2.8

package/package.json

@@ -1,7 +1,7 @@
 {
 	"name": "@xynogen/pix-edit",
-	"version": "0.2.7",
-	"description": "Pi tool — precise text replacement edit with diff rendering",
+	"version": "0.2.8",
+	"description": "Pi tool \u2014 precise text replacement edit with diff rendering",
 	"type": "module",
 	"main": "src/index.ts",
 	"exports": {
@@ -39,8 +39,8 @@
 		"access": "public"
 	},
 	"dependencies": {
-		"@xynogen/pix-pretty": "^1.25.0",
-		"@xynogen/pix-runtime": "^0.12.2"
+		"@xynogen/pix-pretty": "^1.30.0",
+		"@xynogen/pix-runtime": "^0.13.0"
 	},
 	"peerDependencies": {
 		"@earendil-works/pi-coding-agent": "*",

package/src/edit.ts

@@ -1,10 +1,14 @@
-import { existsSync, readFileSync } from "node:fs";
+import { constants } from "node:fs";
+import { access, readFile, writeFile } from "node:fs/promises";
+import { resolve } from "node:path";
+import { fileURLToPath } from "node:url";
 import type {
 	AgentToolUpdateCallback,
 	EditToolInput,
 	ExtensionContext,
 	ToolRenderResultOptions,
 } from "@earendil-works/pi-coding-agent";
+import { withFileMutationQueue } from "@earendil-works/pi-coding-agent";
 import { resolveBaseBackground } from "@xynogen/pix-pretty/ansi";
 import { MAX_RENDER_LINES } from "@xynogen/pix-pretty/config";
 import type { ToolContext } from "@xynogen/pix-pretty/context";
@@ -28,8 +32,10 @@ import type {
 	ToolResultLike,
 } from "@xynogen/pix-pretty/types";
 import {
+	BODY_PAD,
 	dotJoin,
 	fillToolBackground,
+	formatToolCallTitle,
 	frameToolResult,
 	getErrorMessage,
 	getTextContent,
@@ -42,6 +48,9 @@ import {
 	unframeToolResult,
 } from "@xynogen/pix-pretty/utils";
 import { type CollapseState, tickCollapse } from "@xynogen/pix-runtime/collapse";
+import { decodeLines, hashLine, parseAnchor, type SourceLine } from "@xynogen/pix-runtime/hashline";
+import { expandHome } from "@xynogen/pix-runtime/paths";
+import { Type } from "typebox";
 
 // ── Helpers ────────────────────────────────────────────────────────────
 
@@ -79,18 +88,257 @@ export function getEditOperations(input: EditParams): EditOperation[] {
 	return oldText && oldText !== newText ? [{ oldText, newText }] : [];
 }
 
-// 1-based file line where `needle` begins post-edit, for absolute diff gutters.
-// 0 = file unreadable or needle not found (renderer falls back to relative).
-// Duplicate identical edits collapse to the first match — acceptable.
-function opEditLine(filePath: string, needle: string): number {
-	try {
-		if (!filePath || !existsSync(filePath)) return 0;
-		const f = readFileSync(filePath, "utf-8");
-		const idx = f.indexOf(needle);
-		return idx >= 0 ? f.slice(0, idx).split("\n").length : 0;
-	} catch {
-		return 0;
+type HashEdit = {
+	op: "replace" | "insert_before" | "insert_after";
+	pos: string;
+	end?: string;
+	lines: string[];
+};
+type HashParams = { path: string; edits: HashEdit[] };
+type ExactParams = { path: string; edits: EditOperation[] };
+type EditInput = HashParams | ExactParams;
+
+const hashFields = {
+	pos: Type.String({
+		pattern: "^[1-9][0-9]*#[0-9A-F]{3}$",
+		description: "Original LINE#HASH anchor from read",
+	}),
+	lines: Type.Array(
+		Type.String({
+			description:
+				"One literal source line per item. No newline or LINE#HASH| prefix. Empty array deletes.",
+		}),
+	),
+};
+const editSchema = Type.Object(
+	{
+		path: Type.String({ minLength: 1 }),
+		// ponytail: union whole arrays so the schema rejects mixed formats before execution.
+		edits: Type.Union(
+			[
+				Type.Array(
+					Type.Union([
+						Type.Object(
+							{
+								op: Type.Literal("replace"),
+								...hashFields,
+								end: Type.Optional(
+									Type.String({
+										pattern: "^[1-9][0-9]*#[0-9A-F]{3}$",
+										description: "Inclusive end anchor. Omit for one line.",
+									}),
+								),
+							},
+							{ additionalProperties: false },
+						),
+						Type.Object(
+							{
+								op: Type.Union([Type.Literal("insert_before"), Type.Literal("insert_after")]),
+								...hashFields,
+							},
+							{ additionalProperties: false },
+						),
+					]),
+					{ minItems: 1 },
+				),
+				Type.Array(
+					Type.Object(
+						{
+							oldText: Type.String({
+								minLength: 1,
+								description: "Exact source text. Include enough context to match once.",
+							}),
+							newText: Type.String({ description: "Replacement text. Empty string deletes." }),
+						},
+						{ additionalProperties: false },
+					),
+					{ minItems: 1 },
+				),
+			],
+			{
+				description:
+					"Use only hash edits or only exact-text edits in this array. Never mix formats.",
+			},
+		),
+	},
+	{ additionalProperties: false },
+);
+
+export function prepareHashArguments(input: unknown): unknown {
+	if (!input || typeof input !== "object" || Array.isArray(input)) return input;
+	const args = { ...input } as Record<string, unknown>;
+	if (typeof args.edits === "string") args.edits = JSON.parse(args.edits);
+	if (args.edits && typeof args.edits === "object" && !Array.isArray(args.edits))
+		args.edits = [args.edits];
+	return args;
+}
+
+export function editPath(path: string, cwd: string): string {
+	let value = path.replace(/[\u00A0\u2000-\u200A\u202F\u205F\u3000]/g, " ").replace(/^@/, "");
+	if (
+		process.platform === "win32" &&
+		value.startsWith("/") &&
+		!value.startsWith("//") &&
+		!value.includes("\\")
+	) {
+		value = value.replace(
+			/^\/(?:mnt\/|cygdrive\/)?([a-z])(?:\/(.*))?$/i,
+			(_all, drive: string, tail: string | undefined) =>
+				`${drive.toUpperCase()}:\\${(tail ?? "").replaceAll("/", "\\")}`,
+		);
+	}
+	value = expandHome(value);
+	if (value.startsWith("file://")) value = fileURLToPath(value);
+	return resolve(cwd, value);
+}
+
+function applyHashEdits(bytes: Buffer, input: unknown) {
+	const args = prepareHashArguments(input) as HashParams;
+	if (
+		!args ||
+		typeof args.path !== "string" ||
+		!args.path ||
+		!Array.isArray(args.edits) ||
+		!args.edits.length
+	)
+		throw new Error("Invalid hashline edit input");
+	if (Object.keys(args).some((key) => !["path", "edits"].includes(key)))
+		throw new Error("Legacy exact-text fields are not supported");
+	const source = decodeLines(bytes);
+	const check = (value: unknown) => {
+		const parsed = parseAnchor(value);
+		const line = source.lines[parsed.line - 1];
+		if (!line) throw new Error(`Anchor out of bounds: ${String(value)}`);
+		if (hashLine(line.text) !== parsed.hash)
+			throw new Error(`Stale anchor: ${String(value)}. Read the file again.`);
+		return parsed.line;
+	};
+	const replacements: Array<{ start: number; end: number; lines: string[] }> = [];
+	const gaps = new Map<number, string[]>();
+	for (const edit of args.edits) {
+		if (
+			!edit ||
+			typeof edit !== "object" ||
+			Object.keys(edit).some((key) => !["op", "pos", "end", "lines"].includes(key))
+		)
+			throw new Error("Legacy or invalid edit fields");
+		if (
+			!["replace", "insert_before", "insert_after"].includes(edit.op) ||
+			!Array.isArray(edit.lines) ||
+			edit.lines.some(
+				(line) =>
+					typeof line !== "string" ||
+					/[\r\n\0]|^[1-9]\d*#[0-9A-F]{3}\|/.test(line) ||
+					/[\uD800-\uDBFF](?![\uDC00-\uDFFF])|(?<![\uD800-\uDBFF])[\uDC00-\uDFFF]/u.test(line),
+			)
+		)
+			throw new Error("Invalid edit operation or source lines");
+		const start = check(edit.pos);
+		if (edit.op === "replace") {
+			const end = edit.end === undefined ? start : check(edit.end);
+			if (end < start) throw new Error("Reversed replacement range");
+			replacements.push({ start, end, lines: edit.lines });
+		} else {
+			if (edit.end !== undefined) throw new Error("end is only allowed for replace");
+			const gap = edit.op === "insert_before" ? start - 1 : start;
+			gaps.set(gap, [...(gaps.get(gap) ?? []), ...edit.lines]);
+		}
+	}
+	replacements.sort((a, b) => a.start - b.start);
+	for (let i = 0; i < replacements.length; i++) {
+		const range = replacements[i]!;
+		if (i && replacements[i - 1]!.end >= range.start)
+			throw new Error("Overlapping replacement ranges");
+		for (const gap of gaps.keys())
+			if (gap >= range.start && gap < range.end)
+				throw new Error("Insertion overlaps a replacement range");
+	}
+	const output: SourceLine[] = [];
+	const ops: Array<EditOperation & { editLine: number }> = [];
+	const append = (lines: string[]) =>
+		output.push(...lines.map((text) => ({ text, ending: source.delimiter })));
+	let rangeIndex = 0;
+	for (let gap = 0; gap <= source.lines.length; ) {
+		const insertion = gaps.get(gap);
+		if (insertion?.length) {
+			const context = source.lines[Math.max(0, gap - 1)]!.text;
+			ops.push({
+				oldText: context,
+				newText:
+					gap === 0 ? [...insertion, context].join("\n") : [context, ...insertion].join("\n"),
+				editLine: Math.max(1, output.length + (gap === 0 ? 1 : 0)),
+			});
+			append(insertion);
+		}
+		if (gap === source.lines.length) break;
+		const range = replacements[rangeIndex];
+		if (range?.start === gap + 1) {
+			ops.push({
+				oldText: source.lines
+					.slice(gap, range.end)
+					.map((line) => line.text)
+					.join("\n"),
+				newText: range.lines.join("\n"),
+				editLine: output.length + 1,
+			});
+			append(range.lines);
+			gap = range.end;
+			rangeIndex++;
+		} else {
+			output.push({ ...source.lines[gap]! });
+			gap++;
+		}
+	}
+	for (let i = 0; i < output.length; i++) {
+		if (i === output.length - 1)
+			output[i]!.ending = source.finalNewline ? output[i]!.ending || source.delimiter : "";
+		else if (!output[i]!.ending) output[i]!.ending = source.delimiter;
 	}
+	return { content: source.bom + output.map((line) => line.text + line.ending).join(""), ops };
+}
+
+function applyExactEdits(bytes: Buffer, args: ExactParams) {
+	if (Object.keys(args).some((key) => !["path", "edits"].includes(key)))
+		throw new Error("Invalid exact-text edit fields");
+	const source = decodeLines(bytes);
+	const original = source.lines.map((line) => line.text + line.ending).join("");
+	// ponytail: exact bytes only. Add newline normalization only if callers need it.
+	const ranges = args.edits
+		.map((edit) => {
+			if (
+				!edit ||
+				typeof edit !== "object" ||
+				Object.keys(edit).some((key) => !["oldText", "newText"].includes(key)) ||
+				typeof edit.oldText !== "string" ||
+				!edit.oldText ||
+				typeof edit.newText !== "string" ||
+				[edit.oldText, edit.newText].some((text) =>
+					/\0|[\uD800-\uDBFF](?![\uDC00-\uDFFF])|(?<![\uD800-\uDBFF])[\uDC00-\uDFFF]/u.test(text),
+				)
+			)
+				throw new Error("Invalid exact-text edit");
+			const start = original.indexOf(edit.oldText);
+			if (start < 0) throw new Error("oldText was not found. Use exact source text.");
+			if (original.indexOf(edit.oldText, start + 1) >= 0)
+				throw new Error("oldText matches more than once. Include more context.");
+			return { ...edit, start, end: start + edit.oldText.length };
+		})
+		.sort((a, b) => a.start - b.start);
+	let content = "";
+	let offset = 0;
+	const ops: Array<EditOperation & { editLine: number }> = [];
+	for (const range of ranges) {
+		if (range.start < offset) throw new Error("Overlapping exact-text edits");
+		content += original.slice(offset, range.start);
+		ops.push({
+			oldText: range.oldText,
+			newText: range.newText,
+			editLine: (content.match(/\r\n|\r|\n/g)?.length ?? 0) + 1,
+		});
+		content += range.newText;
+		offset = range.end;
+	}
+	return { content: source.bom + content + original.slice(offset), ops };
 }
 
 export function summarizeEditOperations(operations: EditOperation[]) {
@@ -119,31 +367,57 @@ export function registerEditTool(
 	pi.registerTool({
 		...origEdit,
 		name: "edit",
-		// The edit description and schema already carry these rules. Drop the <rules> copy (~110 tokens/turn).
+		description:
+			"Edit using one format per call: hash anchors {op,pos,end?,lines} or exact text {oldText,newText}. Exact oldText must match once. All edits target the original file and must not overlap. Hash ops: replace, insert_before, insert_after. Empty lines or newText delete. Insertions may touch range boundaries, not interiors. Same-gap inserts follow input order. Use write for empty files or complete rewrites.",
+		parameters: editSchema,
+		promptSnippet: "Edit with hash anchors or exact text",
 		promptGuidelines: [],
+		prepareArguments: prepareHashArguments,
+		constrainedSampling: { type: "json_schema", strict: "prefer" },
 		renderShell: "self",
 
 		async execute(
-			tid: string,
-			params: EditParams,
+			_tid: string,
+			params: EditInput,
 			sig: AbortSignal | undefined,
-			upd: AgentToolUpdateCallback<unknown> | undefined,
+			_upd: AgentToolUpdateCallback<unknown> | undefined,
 			toolCtx: ExtensionContext,
 		) {
-			const fp = params.path ?? params.file_path ?? "";
-			const operations = getEditOperations(params);
+			const fp = typeof params?.path === "string" ? params.path : "";
+			let operations: Array<EditOperation & { editLine: number }> = [];
 			const fileLang = lang(fp);
 
 			let result: ToolResultLike;
 			try {
-				result = (await origEdit.execute(
-					tid,
-					// SAFETY: EditParams preserves the built-in edit schema and only adds legacy aliases.
-					params as unknown as Parameters<typeof origEdit.execute>[1],
-					sig,
-					upd,
-					toolCtx,
-				)) as ToolResultLike;
+				if (!fp) throw new Error("path must be a nonempty string");
+				const absolutePath = editPath(fp, toolCtx?.cwd || cwd);
+				result = await withFileMutationQueue(absolutePath, async () => {
+					const abort = () => {
+						if (sig?.aborted) throw new Error("Operation aborted");
+					};
+					abort();
+					await access(absolutePath, constants.R_OK | constants.W_OK);
+					abort();
+					const bytes = await readFile(absolutePath);
+					abort();
+					const args = prepareHashArguments(params) as EditInput;
+					if (!Array.isArray(args.edits) || !args.edits.length)
+						throw new Error("edits must be a nonempty array");
+					const applied = args.edits.every(
+						(edit) => edit && typeof edit === "object" && "oldText" in edit,
+					)
+						? applyExactEdits(bytes, args as ExactParams)
+						: applyHashEdits(bytes, args);
+					operations = applied.ops;
+					abort();
+					// ponytail: in-place writes preserve links and mode, not crash atomicity. Use a separate atomic-write design if needed.
+					await writeFile(absolutePath, applied.content, "utf8");
+					abort();
+					return {
+						content: [{ type: "text", text: `Edited ${fp}: ${operations.length} operations.` }],
+						details: undefined,
+					};
+				});
 			} catch (error) {
 				const text = getErrorMessage(error);
 				if (sig?.aborted || /aborted/i.test(text)) throw error;
@@ -172,7 +446,7 @@ export function registerEditTool(
 				setResultDetails(result, {
 					_type: "editInfo",
 					summary,
-					editLine: opEditLine(fp, op0.newText),
+					editLine: op0.editLine,
 					oldContent: op0.oldText,
 					newContent: op0.newText,
 					language: fileLang,
@@ -191,13 +465,17 @@ export function registerEditTool(
 					newContent: op.newText,
 					language: fileLang,
 					filePath: fp,
-					editLine: opEditLine(fp, op.newText),
+					editLine: op.editLine,
 				})),
 			});
 			return result;
 		},
 
-		renderCall(args: EditParams, theme: ThemeLike, renderCtx: RenderContextLike<EditRenderState>) {
+		renderCall(
+			args: EditParams & Partial<HashParams>,
+			theme: ThemeLike,
+			renderCtx: RenderContextLike<EditRenderState>,
+		) {
 			resolveBaseBackground(theme);
 			const fp = args?.path ?? args?.file_path ?? "";
 			const operations = getEditOperations(args);
@@ -208,8 +486,14 @@ export function registerEditTool(
 				)
 			)
 				return text;
-			const hdr = `${theme.fg("toolTitle", theme.bold("edit"))} ${theme.fg("dim", sp(fp))}`;
+			const hdr = `${formatToolCallTitle(theme, "edit", renderCtx)} ${theme.fg("dim", sp(fp))}`;
 
+			if (Array.isArray(args.edits) && args.edits.some((edit) => "pos" in edit)) {
+				text.setText(
+					fillToolBackground(dotJoin([hdr, theme.fg("muted", `${args.edits.length} operations`)])),
+				);
+				return text;
+			}
 			if (operations.length === 0) {
 				text.setText(fillToolBackground(hdr));
 				return text;
@@ -222,6 +506,7 @@ export function registerEditTool(
 				[
 					hdr,
 					operations.length > 1 && theme.fg("muted", `${operations.length} edits`),
+					theme.fg("muted", "estimate"),
 					coloredSummary,
 				],
 				paint,
@@ -287,7 +572,7 @@ export function registerEditTool(
 				if (renderCtx.state._edk !== key) {
 					renderCtx.state._edk = key;
 					// ponytail: call already shows `edit <file> <summary>`; don't repeat summary+loc header — gutter carries absolute line
-					renderCtx.state._edt = theme.fg("muted", "  rendering diff…");
+					renderCtx.state._edt = `${BODY_PAD}${theme.fg("muted", "rendering diff…")}`;
 					const dc = resolveDiffColors(theme);
 					const diff = parseDiff(
 						d.oldContent as string,
@@ -303,11 +588,11 @@ export function registerEditTool(
 						})
 						.catch(() => {
 							if (renderCtx.state._edk !== key) return;
-							renderCtx.state._edt = `  ${d.summary}`;
+							renderCtx.state._edt = `${BODY_PAD}${d.summary}`;
 							renderCtx.invalidate();
 						});
 				}
-				text.setText(renderCtx.state._edt ?? `  ${d.summary}`);
+				text.setText(renderCtx.state._edt ?? `${BODY_PAD}${d.summary}`);
 				return isPartial ? text : completed();
 			}
 
@@ -318,7 +603,7 @@ export function registerEditTool(
 				if (renderCtx.state._edk !== key) {
 					renderCtx.state._edk = key;
 					// ponytail: call already shows summary; render diffs directly
-					renderCtx.state._edt = theme.fg("muted", "  rendering diff…");
+					renderCtx.state._edt = `${BODY_PAD}${theme.fg("muted", "rendering diff…")}`;
 					const dc = resolveDiffColors(theme);
 					Promise.all(
 						(
@@ -335,23 +620,25 @@ export function registerEditTool(
 					)
 						.then((rendered) => {
 							if (renderCtx.state._edk !== key) return;
-							const body = rendered.join(`\n${theme.fg("muted", "  ···")}\n`);
+							const body = rendered.join(`\n${`${BODY_PAD}${theme.fg("muted", "···")}`}\n`);
 							renderCtx.state._edt = body;
 							renderCtx.invalidate();
 						})
 						.catch(() => {
 							if (renderCtx.state._edk !== key) return;
-							renderCtx.state._edt = `  ${d.editCount} edits ${d.summary}`;
+							renderCtx.state._edt = `${BODY_PAD}${d.editCount} edits ${d.summary}`;
 							renderCtx.invalidate();
 						});
 				}
-				text.setText(renderCtx.state._edt ?? `  ${d.editCount} edits ${d.summary}`);
+				text.setText(renderCtx.state._edt ?? `${BODY_PAD}${d.editCount} edits ${d.summary}`);
 				return isPartial ? text : completed();
 			}
 
 			const fallback = result.content?.[0];
 			const fallbackText = fallback && isTextContent(fallback) ? fallback.text : "edited";
-			text.setText(fillToolBackground(`  ${theme.fg("dim", String(fallbackText).slice(0, 120))}`));
+			text.setText(
+				fillToolBackground(`${BODY_PAD}${theme.fg("dim", String(fallbackText).slice(0, 120))}`),
+			);
 			return isPartial ? text : completed();
 		},
 	});

package/src/extension.ts

@@ -9,11 +9,13 @@ import { CursorStore, fffState } from "@xynogen/pix-pretty/fff";
 import { attachResizeListener, trackInvalidator } from "@xynogen/pix-pretty/resize";
 import type { PiPrettyApi, ToolFactory } from "@xynogen/pix-pretty/types";
 import { shortPath, viewportTextConstructor } from "@xynogen/pix-pretty/utils";
+import { initHashline } from "@xynogen/pix-runtime/hashline";
 import { once } from "@xynogen/pix-runtime/once";
 import { homeDir } from "@xynogen/pix-runtime/paths";
 import { registerEditTool } from "./edit.ts";
 
-export default function pixEditExtension(pi: ExtensionAPI): void {
+export default async function pixEditExtension(pi: ExtensionAPI): Promise<void> {
+	await initHashline();
 	const prettyPi = pi as unknown as PiPrettyApi;
 	once(pi, "pix-edit", () => {
 		const createEditTool = (createEditToolDefinition ??

package/src/hashline.check.mjs

@@ -0,0 +1,47 @@
+import assert from "node:assert/strict";
+import { mkdtemp, readFile, writeFile } from "node:fs/promises";
+import { join } from "node:path";
+import { createRequire } from "node:module";
+
+const require = createRequire(import.meta.resolve("@earendil-works/pi-coding-agent"));
+const { createJiti } = require("jiti");
+
+const jiti = createJiti(import.meta.url, { moduleCache: false });
+const { tempDir } = await jiti.import("@xynogen/pix-runtime/paths");
+const cwd = await mkdtemp(join(tempDir(), "hashline-node-"));
+const file = join(cwd, "sample.ts");
+await writeFile(file, "const retries = 2;\nawait connect();\n");
+const tools = new Map();
+const pi = { registerTool: (tool) => tools.set(tool.name, tool) };
+const readExtension = await jiti.import("../../pix-read/src/extension.ts", { default: true });
+const editExtension = await jiti.import("./extension.ts", { default: true });
+await readExtension(pi);
+await editExtension(pi);
+const state = globalThis.__pixHashline;
+assert.equal(typeof state.h32, "function");
+const read = tools.get("read");
+const edit = tools.get("edit");
+const result = await read.execute("read", { path: file }, undefined, undefined, { cwd });
+assert.equal(result.isError, undefined);
+const pos = result.content[0].text.split("|")[0];
+assert.match(pos, /^1#[0-9A-F]{3}$/);
+assert.equal(result.details.content, "const retries = 2;\nawait connect();");
+const changed = await edit.execute("edit", {
+	path: file,
+	edits: [{ op: "replace", pos, lines: ["const retries = 5;"] }],
+}, undefined, undefined, { cwd });
+assert.equal(changed.isError, undefined);
+assert.equal(await readFile(file, "utf8"), "const retries = 5;\nawait connect();\n");
+assert.equal(changed.details.editLine, 1);
+const theme = { fg: (_role, text) => text, bold: (text) => text };
+let notify;
+const rendered = new Promise((resolve) => { notify = resolve; });
+const context = { state: {}, expanded: true, isError: false, invalidate: () => notify() };
+const component = edit.renderResult(changed, { isPartial: false }, theme, context);
+await rendered;
+edit.renderResult(changed, { isPartial: false }, theme, { ...context, lastComponent: component });
+const text = component.render(120).join("\n");
+assert.match(text, /retries/);
+assert.match(text, /- -/);
+assert.equal(globalThis.__pixHashline, state);
+console.log("Node Pi extension smoke passed: anchored read, edit, expanded diff, shared WASM.");