@d3ara1n/pi-hashline-edit 0.1.0 → 0.1.2

package/src/pi/edit-tool.ts

@@ -1,88 +1,109 @@
 /**
- * Override edit：只接受 hashline patch（`input`）。
+ * Override edit: hashline ops via structured `edits` (LINE#HASH anchors).
  *
- * 不兼容旧 oldText/newText——发现旧格式输入时明确报错，让开发者知道
- * 模型没用新方案，而非静默降级。容错仅限不影响结果的格式归一化
- * （parse 层的可选冒号、CRLF 等）；范式级兼容一概拒绝。
+ * Each op in `edits` references line anchors copied from read output (or from a
+ * prior edit's "Updated anchors"). The core verifies each anchor live against
+ * the current file content — no snapshot, no global stale check: a cited line
+ * that changed (or was misremembered) fails its own anchor; unchanged lines
+ * elsewhere never block the edit. Legacy oldText/newText is not accepted — the
+ * schema requires an `op` discriminator, so legacy payloads are rejected at the
+ * schema layer (a visible failure, never a silent degradation).
  *
- * 并发安全：read-modify-write 包在 withFileMutationQueue 里，串行化同文件
- * 的多次 edit，防止 pi 默认并行执行下丢数据。响应 AbortSignal——读后/写前
- * 检查，用户取消时不落盘。
+ * On success the result carries fresh `LINE#HASH` anchors for the lines this
+ * edit produced (and the line that shifted into a deletion gap), so the model
+ * can chain edits without a re-read.
+ *
+ * Concurrency safety: read-modify-write is wrapped in withFileMutationQueue.
+ * AbortSignal is honored — checked after read / before write.
  *
  * @module pi-hashline-edit/pi
  */
 
-import { createEditTool, generateDiffString, generateUnifiedPatch, withFileMutationQueue } from "@earendil-works/pi-coding-agent";
+import { createEditTool, generateDiffString, generateUnifiedPatch, withFileMutationQueue, type EditToolDetails } from "@earendil-works/pi-coding-agent";
 import { Type, type Static } from "typebox";
+import { Text } from "@earendil-works/pi-tui";
 import { readFile, writeFile } from "node:fs/promises";
-import { applyEdits, parsePatch } from "../core/index.ts";
-import type { Edit, FileSnapshot, PatchError } from "../core/types.ts";
+import { applyEdits, hashFileLines } from "../core/index.ts";
+import { splitLines } from "../core/lines.ts";
+import type { Edit, PatchError } from "../core/types.ts";
 import { canonicalPath } from "./read-tool.ts";
-import { getState, getSnapshot, putSnapshot, recordSnapshot } from "./state.ts";
+import { getState } from "./state.ts";
+
+/** Cap on the number of updated anchors returned inline (bounds token cost for large inserts). */
+const MAX_ANCHOR_LINES = 40;
+
+const anchorSchema = Type.Object({
+	line: Type.Number({ description: "1-based line number" }),
+	hash: Type.String({ description: "Line content hash copied from read output (the #HASH after the line number)" }),
+});
 
-// schema 不声明 additionalProperties:false：模型误发旧 edits/oldText/newText
-// 时，这些额外字段原样到达 execute，由 missingInputError 检测并明确拒绝。
-// 依赖 typebox 默认允许额外属性 + pi validation 不 strip —— 勿改这两点。
+const editOpSchema = Type.Object({
+	op: Type.Union(
+		[
+			Type.Literal("replace"),
+			Type.Literal("delete"),
+			Type.Literal("insert_after"),
+			Type.Literal("insert_before"),
+			Type.Literal("append"),
+			Type.Literal("prepend"),
+		],
+		{ description: "Operation kind" },
+	),
+	anchor: Type.Optional(anchorSchema),
+	end: Type.Optional(anchorSchema),
+	body: Type.Optional(Type.Array(Type.String(), { description: "New content lines (required for replace/insert/append/prepend; omit for delete)" })),
+});
 
 const editSchema = Type.Object({
 	path: Type.String({ description: "Path to the file to edit (relative or absolute)" }),
-	input: Type.Optional(
-		Type.String({
-			description:
-				"Hashline patch referencing LINE#HASH anchors from your latest read. Ops: replace / delete / insert_after / insert_before / append / prepend. Body rows start with `+`. This tool does NOT accept legacy oldText/newText.",
-		}),
-	),
+	edits: Type.Array(editOpSchema, { description: "Hashline ops, each referencing LINE#HASH anchors from your latest read or edit result" }),
 });
 
-/** 把 PatchError 转成对模型有用的提示文本。 */
+type EditOpInput = Static<typeof editOpSchema>;
+
+/** Turn a PatchError into helpful hint text for the model. */
 function errorText(e: PatchError, path: string): string {
 	switch (e.kind) {
-		case "stale":
-			return `File ${path} changed since your last read. Re-read it before editing.`;
 		case "anchor":
 			return `Anchor mismatch: ${e.message}. Re-read ${path} to get current line hashes (LINE#HASH).`;
-		case "collision":
-			return `Hash collision: ${e.message}. Re-read ${path}.`;
 		case "range":
 			return `Bad range: ${e.message}`;
 		case "noop":
 			return `Edit produced no change: ${e.message}`;
-		case "parse":
-			return `Parse error${e.line ? ` at line ${e.line}` : ""}: ${e.message}`;
 	}
 }
 
-/** 取应用后首个变更行（用于 firstChangedLine / TUI 跳转）。insert_after 取锚 +1。 */
-function minAnchorLine(edits: readonly Edit[]): number | undefined {
-	let min: number | undefined;
-	for (const e of edits) {
-		let line: number | undefined;
-		if (e.op === "replace" || e.op === "delete") line = e.start.line;
-		else if (e.op === "insert_after") line = e.anchor.line + 1;
-		else if (e.op === "insert_before") line = e.anchor.line;
-		else if (e.op === "prepend") line = 1;
-		// append 无锚，跳过（末尾追加）
-		if (line !== undefined && (min === undefined || line < min)) min = line;
+/** Translate JSON edit ops into core Edit[]. Validates conditional required fields (anchor/body per op). */
+function toCoreEdits(ops: readonly EditOpInput[]): { ok: true; edits: Edit[] } | { ok: false; error: string } {
+	const edits: Edit[] = [];
+	for (const o of ops) {
+		switch (o.op) {
+			case "replace":
+				if (!o.anchor) return { ok: false, error: "replace needs `anchor` {line, hash}" };
+				if (!o.body) return { ok: false, error: "replace needs `body`" };
+				edits.push({ op: "replace", start: o.anchor, end: o.end, body: o.body });
+				break;
+			case "delete":
+				if (!o.anchor) return { ok: false, error: "delete needs `anchor` {line, hash}" };
+				edits.push({ op: "delete", start: o.anchor, end: o.end });
+				break;
+			case "insert_after":
+			case "insert_before":
+				if (!o.anchor) return { ok: false, error: `${o.op} needs \`anchor\` {line, hash}` };
+				if (!o.body) return { ok: false, error: `${o.op} needs \`body\`` };
+				edits.push({ op: o.op, anchor: o.anchor, body: o.body });
+				break;
+			case "append":
+			case "prepend":
+				if (!o.body) return { ok: false, error: `${o.op} needs \`body\`` };
+				edits.push({ op: o.op, body: o.body });
+				break;
+		}
 	}
-	return min;
+	return { ok: true, edits };
 }
 
-/**
- * 模型未用 hashline（发了旧 oldText/newText 或缺 input）→ 明确告知，不静默降级。
- * 导出以便测试。params 用 any 以便检测 schema 外的旧格式字段。
- */
-export function missingInputError(path: string, params: any): string {
-	const legacy =
-		Array.isArray(params?.edits) ||
-		typeof params?.oldText === "string" ||
-		typeof params?.newText === "string";
-	if (legacy) {
-		return `⚠ ${path}: you sent the legacy oldText/newText format, but this edit tool ONLY accepts hashline \`input\`. The legacy path was intentionally removed so this is surfaced, not silently degraded. Re-read ${path} to get LINE#HASH anchors, then send \`input\` (e.g. \`replace 4#aF3:\` followed by \`+\` body rows).`;
-	}
-	return `Edit ${path}: missing \`input\` (hashline patch). Read ${path} first, then send \`input\` referencing LINE#HASH anchors.`;
-}
-
-/** 构造错误 result（带 isError: true，让 TUI/agent loop 识别失败而非当成功）。 */
+/** Build an error result (isError: true so the TUI/agent loop treats it as a failure). */
 function errResult(text: string) {
 	return {
 		isError: true as const,
@@ -91,6 +112,21 @@ function errResult(text: string) {
 	};
 }
 
+/**
+ * Format the updated anchors (fresh LINE#HASH│content) for the touched new-file
+ * lines, so the model can chain edits without a re-read. Capped to bound tokens.
+ */
+function formatUpdatedAnchors(newText: string, touched: readonly number[], hashLen: number): string {
+	const newLines = splitLines(newText);
+	const newHashes = hashFileLines(newLines, hashLen);
+	const idxs = [...new Set(touched)].sort((a, b) => a - b);
+	if (idxs.length === 0) return "";
+	const rows = idxs.map((i) => `${i + 1}#${newHashes[i]}│${newLines[i]}`);
+	const shown = rows.length > MAX_ANCHOR_LINES ? rows.slice(0, MAX_ANCHOR_LINES) : rows;
+	const more = rows.length > MAX_ANCHOR_LINES ? `\n… (${rows.length - MAX_ANCHOR_LINES} more; re-read for full anchors)` : "";
+	return `\nUpdated anchors (use these for the next edit):\n${shown.join("\n")}${more}`;
+}
+
 export function makeEditOverride(cwd: string) {
 	const builtin = createEditTool(cwd);
 
@@ -98,38 +134,72 @@ export function makeEditOverride(cwd: string) {
 		name: "edit" as const,
 		label: "edit",
 		description:
-			"Edit a file via hashline patch (LINE#HASH anchors, content-verified). Does NOT accept legacy oldText/newText.",
-		promptSnippet: "Edit files via hashline LINE#HASH anchors (input patch); legacy oldText/newText not accepted",
+			"Edit a file via hashline ops (LINE#HASH anchors, content-verified). Each op in `edits` references line anchors from your latest read or edit result.",
+		promptSnippet: "Edit files via hashline ops (edits[] with LINE#HASH anchors from read)",
 		promptGuidelines: [
-			"Pass `input`: a hashline patch referencing `LINE#HASH` anchors copied from your latest read output (e.g. `replace 12#aF3:`).",
-			"Ops: `replace LINE#HASH[..LINE#HASH]:` · `delete LINE#HASH` · `insert_after LINE#HASH:` · `insert_before LINE#HASH:` · `append:` · `prepend:`.",
-			"Body rows start with `+` followed by the literal line. `+` alone = blank line. Literal `+`/`-` lines become `++`/`+-`.",
-			"After each successful edit, re-ground: line numbers shift, so take the next edit's anchors from a fresh read.",
-			"This tool does NOT accept legacy oldText/newText — sending those returns an error (intentional, so it's visible).",
+			"Pass `edits`: an array of ops. Each op = {op, anchor?, end?, body?}.",
+			"op ∈ replace | delete | insert_after | insert_before | append | prepend.",
+			"anchor & end = {line, hash} copied from your latest read or edit result (the `#HASH` after each line number). replace/delete take anchor (+ optional end for a range); insert_after/insert_before take anchor; append/prepend take neither.",
+			"body = string[] of new content lines (required for replace/insert/append/prepend; omit for delete).",
+			"A successful edit returns `Updated anchors` for the changed lines — use those (not stale line numbers) for the next edit to the same file; re-read only if you need lines outside that set.",
 		],
 		parameters: editSchema,
-		renderShell: "self" as const,
+		renderShell: "default" as const,
+
+		renderCall(args: Static<typeof editSchema>, theme: any) {
+			let text = theme.fg("toolTitle", theme.bold("edit "));
+			text += theme.fg("accent", args.path);
+			const n = args.edits?.length ?? 0;
+			if (n) text += theme.fg("dim", ` — ${n} op${n > 1 ? "s" : ""}: ${args.edits[0].op}`);
+			return new Text(text, 0, 0);
+		},
+
+		renderResult(result: any, { isPartial, expanded }: any, theme: any, context: any) {
+			if (isPartial) return new Text(theme.fg("warning", "Editing…"), 0, 0);
+			const content = result.content?.[0];
+			if (context.isError) {
+				const t = content?.type === "text" ? content.text.split("\n")[0] : "Error";
+				return new Text(theme.fg("error", t), 0, 0);
+			}
+			const diff: string | undefined = result.details?.diff;
+			if (!diff) {
+				const t = content?.type === "text" ? content.text : "Edited";
+				return new Text(theme.fg("success", t), 0, 0);
+			}
+			// details.diff is pi-format (+N/-N/<space>N content); color by leading char
+			const allLines = diff.split("\n");
+			const shown = expanded ? allLines : allLines.slice(0, 24);
+			const body = shown
+				.map((line: string) => {
+					if (line.startsWith("+")) return theme.fg("success", line);
+					if (line.startsWith("-")) return theme.fg("error", line);
+					return theme.fg("dim", line);
+				})
+				.join("\n");
+			const more = !expanded && allLines.length > 24 ? `\n${theme.fg("dim", `… (${allLines.length - 24} more)`)}` : "";
+			return new Text(body + more, 0, 0);
+		},
 
 		async execute(toolCallId: string, params: Static<typeof editSchema>, signal: AbortSignal | undefined, onUpdate: any) {
 			const state = getState();
-			// 用户主动关闭 hashline（config.enabled=false）→ 透传内置
+			// hashline disabled by the user (config.enabled=false) → delegate to the built-in
 			if (!state.config.enabled) return builtin.execute(toolCallId, params as any, signal, onUpdate);
 
 			const path = params.path;
 			const absPath = canonicalPath(cwd, path);
-			const input = params.input;
 
-			// 无 input → 明确告知（区分旧格式 vs 缺失），不静默降级
-			if (typeof input !== "string" || input.trim() === "") {
-				return errResult(missingInputError(path, params as any));
+			if (!params.edits?.length) {
+				return errResult(`Edit ${path}: \`edits\` is empty or missing.`);
 			}
-			// withFileMutationQueue 串行化同文件的 read-modify-write，防并行 edit 丢数据
-			return await withFileMutationQueue(absPath, () => runHashline(absPath, path, input, signal));
+			// withFileMutationQueue serializes read-modify-write for the same file, preventing parallel-edit data loss
+			return await withFileMutationQueue(absPath, () => runHashline(absPath, path, params.edits, signal));
 		},
 	};
 }
 
-async function runHashline(absPath: string, displayPath: string, input: string, signal: AbortSignal | undefined) {
+async function runHashline(absPath: string, displayPath: string, editOps: readonly EditOpInput[], signal: AbortSignal | undefined) {
+	const hashLen = getState().config.hashLen;
+
 	let currentText: string;
 	try {
 		currentText = (await readFile(absPath)).toString("utf-8");
@@ -137,25 +207,21 @@ async function runHashline(absPath: string, displayPath: string, input: string,
 		const msg = e instanceof Error ? e.message : String(e);
 		return errResult(`Error reading ${displayPath}: ${msg}`);
 	}
-	// 读后检查取消：用户 abort 则不继续 parse/apply，文件不变
+	// Check for cancel after read: if the user aborted, don't proceed to parse/apply; the file stays untouched
 	if (signal?.aborted) return errResult(`Edit ${displayPath} aborted before apply.`);
 
-	// 取已记录快照；若无（模型未 read）则用当前文件建立——anchor 校验仍会强制
-	// 模型用真实 hash（没读过就猜不对），自然引导它先 read。
-	const snap: FileSnapshot = getSnapshot(absPath) ?? recordSnapshot(absPath, currentText);
-
-	// input 不含 file 头，prepend 一个让 parsePatch 通过（path 仅作标签）
-	const parsed = parsePatch(`file: ${absPath}\n\n${input}`);
-	if (!parsed.ok) {
-		return errResult(errorText(parsed.error, displayPath));
-	}
+	const translated = toCoreEdits(editOps);
+	if (!translated.ok) return errResult(translated.error);
 
-	const result = applyEdits(currentText, parsed.patch.edits, snap);
+	// Anchors are verified against the current content. A line that changed (or a
+	// hash the model didn't actually read) fails its own anchor — steering it to
+	// read first. Unrelated changes elsewhere never block the edit.
+	const result = applyEdits(currentText, translated.edits, hashLen);
 	if (!result.ok) {
 		return errResult(errorText(result.error, displayPath));
 	}
 
-	// 写前检查取消：abort 则不落盘，文件不变
+	// Check for cancel before write: if aborted, don't touch the disk; the file stays untouched
 	if (signal?.aborted) return errResult(`Edit ${displayPath} aborted before write.`);
 
 	try {
@@ -165,19 +231,16 @@ async function runHashline(absPath: string, displayPath: string, input: string,
 		return errResult(`Error writing ${displayPath}: ${msg}`);
 	}
 
-	// 更新快照：连续 edit 无需重读（result.newSnapshot 基于新文本），走 LRU
-	putSnapshot(absPath, result.newSnapshot);
-
+	// pi's generateDiffString returns the display diff (colored by the renderer) and the first changed line
+	const { diff, firstChangedLine } = generateDiffString(currentText, result.text);
+	const details: EditToolDetails = {
+		diff,
+		patch: generateUnifiedPatch(displayPath, currentText, result.text),
+		firstChangedLine,
+	};
+	const anchors = formatUpdatedAnchors(result.text, result.touchedLines, hashLen);
 	return {
-		content: [
-			{ type: "text" as const, text: `Edited ${displayPath} (${parsed.patch.edits.length} op(s)).` },
-		],
-		details: {
-			// details.diff 必须用 pi 的 generateDiffString（+N content 格式），
-			// 内置 renderer 的 parseDiffLine 只认这个格式；core 的标准 unified diff 会被当纯文本灰显
-			diff: generateDiffString(currentText, result.text),
-			patch: generateUnifiedPatch(displayPath, currentText, result.text),
-			firstChangedLine: minAnchorLine(parsed.patch.edits),
-		},
+		content: [{ type: "text" as const, text: `Edited ${displayPath} (${translated.edits.length} op(s)).${anchors}` }],
+		details,
 	};
 }