pi-hashline-edit-pro 2.6.4 → 2.7.0

package/src/insert.ts

@@ -0,0 +1,222 @@
+import type { ExtensionAPI, ToolDefinition } from "@earendil-works/pi-coding-agent";
+import { withFileMutationQueue } from "@earendil-works/pi-coding-agent";
+import { Type } from "typebox";
+import { constants } from "fs";
+import { execPipeline, type ReqParams, type ReplaceDetails } from "./replace";
+import { commitEdit } from "./commit";
+import { readNormFile, type NormFile } from "./file-reader";
+import { resolveTarget } from "./fs-write";
+import { MAX_HASH_LINES, parseHashRef, resolveAnchorLine, type Anchor } from "./hashline";
+import { stripAnchorRow } from "./hashline/resolve";
+import { toCwd } from "./paths";
+import { loadP, loadGuide } from "./prompts";
+import { normReq } from "./replace-normalize";
+import { genDiff } from "./replace-diff";
+import { makeRenderCall, renderEditResult, type RPreview, type RRState } from "./replace-render";
+import { abortIf, isRec, makePrepareArguments, rejectUnknownFields, splitLines } from "./utils";
+import { clearBoundaryBypass } from "./boundary-bypass";
+
+const INSERT_KS = new Set(["path", "anchor", "direction", "lines"]);
+
+export interface InsertReq {
+  path: string;
+  anchor: string;
+  direction: "before" | "after";
+  lines: string[];
+}
+
+export function assertInsertReq(request: unknown): asserts request is InsertReq {
+  if (!isRec(request)) {
+    throw new Error("[E_BAD_SHAPE] Insert request must be an object.");
+  }
+  rejectUnknownFields(request, INSERT_KS, "Insert request");
+  if (typeof request.path !== "string" || request.path.length === 0) {
+    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 hash from read output).');
+  }
+  if (request.direction !== "before" && request.direction !== "after") {
+    throw new Error('[E_BAD_SHAPE] Insert request "direction" must be "before" or "after".');
+  }
+  if (!Array.isArray(request.lines) || request.lines.some((line) => typeof line !== "string")) {
+    throw new Error('[E_BAD_SHAPE] Insert request requires "lines" as an array of strings, one element per line.');
+  }
+}
+
+const insertToolSchema = Type.Object(
+  {
+    path: Type.String({
+      description:
+        "Path to the file to edit",
+    }),
+    anchor: Type.String({
+      description:
+        'Bare 3-char HASH only (e.g. "aB3"): copy just the hash from the leftmost column of a read row like `aB3│content`; never the line content. A pasted diff row like `+aB3│x` or a `HASH│` prefix is stripped automatically with a warning. The anchored line is preserved; the new 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" }),
+      ],
+      { 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.",
+      }),
+      {
+        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.',
+      }
+    ),
+  },
+  { additionalProperties: false },
+);
+
+function parseInsertAnchor(raw: string): { ref: Anchor; warnings: string[] } {
+  const trimmedAnchor = raw.trim();
+  const warnings: string[] = [];
+  const anchorText = stripAnchorRow(trimmedAnchor, "anchor entry", warnings);
+  return { ref: parseHashRef(anchorText), warnings };
+}
+
+function buildInsertEdit(
+  req: InsertReq,
+  preload: NormFile,
+  ref: Anchor,
+): { editParams: ReqParams; anchorLine: string | undefined } {
+  const fileLines = splitLines(preload.normalized);
+  const line = resolveAnchorLine(ref, fileLines, preload.fileHashes, req.path);
+  const anchorLine = preload.normalized.length === 0 ? undefined : fileLines[line - 1];
+  const editParams: ReqParams = {
+    path: req.path,
+    remove_from: ref.hash,
+    remove_to: ref.hash,
+    replacement_lines:
+      anchorLine === undefined
+        ? [...req.lines]
+        : req.direction === "after"
+          ? [anchorLine, ...req.lines]
+          : [...req.lines, anchorLine],
+  };
+  return { editParams, anchorLine };
+}
+
+export async function insertPreview(request: unknown, cwd: string): Promise<RPreview> {
+  try {
+    const normalized = normReq(request);
+    assertInsertReq(normalized);
+    const { ref } = parseInsertAnchor(normalized.anchor);
+    const preload = await readNormFile(normalized.path, cwd, {
+      accessMode: constants.R_OK,
+      maxLines: MAX_HASH_LINES,
+      noPersist: true,
+    });
+    const { editParams } = buildInsertEdit(normalized, preload, ref);
+    const pipe = await execPipeline(editParams, cwd, {
+      accessMode: constants.R_OK,
+      noPersist: true,
+      preloadedNorm: preload,
+      skipBoundaryDedup: true,
+    });
+    if (pipe.originalNormalized === pipe.result) {
+      return { error: `No changes made to ${normalized.path}. The edit produced identical content.` };
+    }
+    return { diff: genDiff(pipe.originalNormalized, pipe.result, 4, pipe.resultHashes, pipe.originalHashes).diff };
+  } catch (error: unknown) {
+    return { error: error instanceof Error ? error.message : String(error) };
+  }
+}
+
+function getInsertInput(args: unknown): { path?: string; anchor?: string; direction?: "before" | "after"; lines?: string[] } | null {
+  let normalized: unknown;
+  try {
+    normalized = normReq(args);
+  } catch {
+    return null;
+  }
+  if (!isRec(normalized) || typeof normalized.path !== "string") return null;
+  if (
+    typeof normalized.anchor !== "string" ||
+    (normalized.direction !== "before" && normalized.direction !== "after") ||
+    !Array.isArray(normalized.lines) ||
+    normalized.lines.some((line) => typeof line !== "string")
+  ) {
+    return null;
+  }
+  return {
+    path: normalized.path,
+    anchor: normalized.anchor,
+    direction: normalized.direction,
+    lines: normalized.lines,
+  };
+}
+
+type InsertToolDef = ToolDefinition<any, ReplaceDetails, RRState> & { renderShell?: "default" | "self" };
+
+export function buildInsertToolDef(): InsertToolDef {
+  return {
+    name: "insert",
+    label: "Insert",
+    description: loadP("../prompts/insert.md"),
+    promptSnippet: loadP("../prompts/insert-snippet.md"),
+    promptGuidelines: loadGuide("../prompts/insert-guidelines.md"),
+    prepareArguments: makePrepareArguments(),
+    parameters: insertToolSchema,
+    renderShell: "default",
+    renderCall: makeRenderCall(insertPreview, { getInput: getInsertInput, toolName: "insert" }),
+    renderResult(result, { isPartial }, theme, context) {
+      return renderEditResult(
+        result as {
+          content?: Array<{ type: string; text?: string }>;
+          details?: ReplaceDetails;
+        },
+        isPartial,
+        theme,
+        context,
+      );
+    },
+
+    async execute(_toolCallId, params, signal, _onUpdate, ctx) {
+      const canonical = normReq(params);
+      assertInsertReq(canonical);
+      const req = canonical;
+      const path = req.path;
+      const { ref, warnings: anchorWarnings } = parseInsertAnchor(req.anchor);
+      const absolutePath = toCwd(path, ctx.cwd);
+      const mutationTargetPath = await resolveTarget(absolutePath);
+      return withFileMutationQueue(mutationTargetPath, async () => {
+        abortIf(signal);
+        const preload = await readNormFile(path, ctx.cwd, {
+          signal,
+          accessMode: constants.R_OK | constants.W_OK,
+          maxLines: MAX_HASH_LINES,
+        });
+        const { editParams, anchorLine } = buildInsertEdit(req, preload, ref);
+        const pipe = await execPipeline(editParams, ctx.cwd, {
+          accessMode: constants.R_OK | constants.W_OK,
+          signal,
+          preloadedNorm: preload,
+          skipBoundaryDedup: true,
+        });
+        return commitEdit(pipe, {
+          path,
+          absolutePath,
+          mutationTargetPath,
+          signal,
+          verb: "inserted",
+          noopNoun: "Insertion",
+          foldedAnchorLines: anchorLine === undefined ? 0 : 1,
+          prefixWarnings: anchorWarnings,
+          onApplied: () => clearBoundaryBypass(mutationTargetPath),
+        });
+      });
+    },
+  };
+}
+
+export function regInsert(pi: ExtensionAPI): void {
+  pi.registerTool(buildInsertToolDef());
+}

package/src/read.ts

@@ -72,7 +72,7 @@ export async function fmtReadPreview(
 			};
 		}
 		return {
-			text: `Offset ${startLine} is beyond end of file (0 lines total). The file is empty. Use replace to insert content.`,
+			text: `Offset ${startLine} is beyond end of file (0 lines). Use replace to insert content.`,
 			servedHashes: [],
 		};
 	}
@@ -114,7 +114,7 @@ export async function fmtReadPreview(
 		const lineLabel = oversized.length === 1 ? `Line ${oversized[0]!.lineNumber}` : `Lines ${oversized.map((row) => row.lineNumber).join(", ")}`;
 		const verb = oversized.length === 1 ? "exceeds" : "exceed";
 		const addresses = oversized.map((row) => `${row.lineNumber}p`).join(";");
-		const warning = `[${lineLabel} ${verb} ${formatSize(maxBytes)}; content not shown because hashline anchors require full lines. Inspect with bash: sed -n '${addresses}' <path> | head -c ${maxBytes}]`;
+		const warning = `[${lineLabel} ${verb} ${formatSize(maxBytes)}; content not shown. Inspect with bash: sed -n '${addresses}' <path> | head -c ${maxBytes}]`;
 		let preview = skippedTruncation.content;
 		let nextOffset: number | undefined;
 		if (shownRowCount > 0 && (skippedTruncation.truncated || lastShownLine < totalLines)) {

package/src/replace-diff.ts

@@ -47,6 +47,10 @@ function fmtDiffLine(
   return `${prefix}${hash}${HASH_SEP}${line}`;
 }
 
+function isBlankLine(line: string): boolean {
+  return line.trim().length === 0;
+}
+
 const ELLIPSIS_MARKER: unique symbol = Symbol("ellipsis");
 const isEllipsisMarker = (line: string | symbol): line is symbol =>
   line === ELLIPSIS_MARKER;
@@ -99,15 +103,52 @@ export function genDiff(
       let skipTail = 0;
 
       if (!lastWasChange) {
-        skipStart = Math.max(0, displayLines.length - contextLines);
+        let count = contextLines;
+        if (
+          contextLines > 0 &&
+          displayLines.length > count &&
+          isBlankLine(displayLines[displayLines.length - 1]!)
+        ) {
+          count += 1;
+        }
+        count = Math.min(count, displayLines.length);
+        skipStart = displayLines.length - count;
         linesToShow = displayLines.slice(skipStart);
       } else if (nextPartIsChange && displayLines.length > contextLines * 2) {
-        const tail = displayLines.slice(-contextLines);
-        linesToShow = [...displayLines.slice(0, contextLines), ELLIPSIS_MARKER, ...tail];
-        skipMiddle = displayLines.length - contextLines * 2;
+        let headCount = contextLines;
+        let tailCount = contextLines;
+        if (
+          contextLines > 0 &&
+          displayLines.length - headCount > tailCount &&
+          isBlankLine(displayLines[headCount - 1]!)
+        ) {
+          headCount += 1;
+        }
+        if (
+          contextLines > 0 &&
+          displayLines.length - tailCount > headCount &&
+          isBlankLine(displayLines[displayLines.length - tailCount]!)
+        ) {
+          tailCount += 1;
+        }
+        const middleLen = displayLines.length - headCount - tailCount;
+        if (middleLen > 0) {
+          linesToShow = [
+            ...displayLines.slice(0, headCount),
+            ELLIPSIS_MARKER,
+            ...displayLines.slice(displayLines.length - tailCount),
+          ];
+          skipMiddle = middleLen;
+        } else {
+          linesToShow = displayLines;
+        }
       } else if (!nextPartIsChange && linesToShow.length > contextLines) {
-        linesToShow = linesToShow.slice(0, contextLines);
-        skipTail = displayLines.length - contextLines;
+        let count = contextLines;
+        const firstLine = linesToShow[0];
+        if (contextLines > 0 && typeof firstLine === "string" && isBlankLine(firstLine)) count += 1;
+        count = Math.min(count, linesToShow.length);
+        linesToShow = linesToShow.slice(0, count);
+        skipTail = displayLines.length - count;
       }
 
       if (skipStart > 0) {

package/src/replace-render.ts

@@ -1,3 +1,4 @@
+import { Markdown, Text } from "@earendil-works/pi-tui";
 import type { Theme } from "@earendil-works/pi-coding-agent";
 import { normReq } from "./replace-normalize";
 import type { ReqParams, ReplaceDetails } from "./replace";
@@ -89,17 +90,18 @@ export function fmtResult(diff: string, theme: FgT): string {
 }
 
 export function fmtCall(
-	args: ReqParams | undefined,
+	args: { path?: string } | undefined,
 	state: RRState,
 	expanded: boolean,
 	theme: CallT,
+	toolName = "replace",
 ): string {
 	const path = args?.path;
 	const pathDisplay =
 		typeof path === "string" && path.length > 0
 			? theme.fg("accent", path)
 			: theme.fg("toolOutput", "...");
-	let text = `${theme.fg("toolTitle", theme.bold("replace"))} ${pathDisplay}`;
+	let text = `${theme.fg("toolTitle", theme.bold(toolName))} ${pathDisplay}`;
 
 	if (!state.preview) {
 		return text;
@@ -209,3 +211,116 @@ export function mkMdTheme(theme: MdTheme) {
 			}),
 	};
 }
+
+export const PREVIEW_DEBOUNCE_MS = 150;
+
+export function reuseText(context: any, content: string): Text {
+	const t = context.lastComponent instanceof Text
+		? context.lastComponent
+		: new Text("", 0, 0);
+	t.setText(content);
+	return t;
+}
+
+export function reuseMarkdown(context: any, content: string, theme: any): Markdown {
+	const m = context.lastComponent instanceof Markdown
+		? context.lastComponent
+		: new Markdown("", 0, 0, mkMdTheme(theme));
+	m.setText(content);
+	return m;
+}
+
+export function makeRenderCall(
+	preview: (args: unknown, cwd: string) => Promise<RPreview>,
+	options: { getInput?: (args: unknown) => { path?: string } | null; toolName?: string } = {},
+) {
+	const getInput = options.getInput ?? getPreviewInput;
+	const toolName = options.toolName ?? "replace";
+	return (args: any, theme: CallT, context: any): Text => {
+		const previewInput = getInput(args);
+		const cancelPendingPreview = () => {
+			if (context.state.previewTimer) {
+				clearTimeout(context.state.previewTimer);
+				context.state.previewTimer = undefined;
+			}
+		};
+		if (context.executionStarted) {
+			cancelPendingPreview();
+			context.state.argsKey = undefined;
+			context.state.preview = undefined;
+			context.state.previewGeneration = (context.state.previewGeneration ?? 0) + 1;
+		} else if (!context.argsComplete || !previewInput) {
+			cancelPendingPreview();
+			context.state.argsKey = undefined;
+			context.state.preview = undefined;
+			context.state.previewGeneration = (context.state.previewGeneration ?? 0) + 1;
+		} else {
+			const argsKey = JSON.stringify(previewInput);
+			if (context.state.argsKey !== argsKey) {
+				cancelPendingPreview();
+				context.state.argsKey = argsKey;
+				context.state.preview = undefined;
+				const previewGeneration = (context.state.previewGeneration ?? 0) + 1;
+				context.state.previewGeneration = previewGeneration;
+				context.state.previewTimer = setTimeout(() => {
+					context.state.previewTimer = undefined;
+					preview(args, context.cwd)
+						.then((result) => {
+							if (
+								context.state.argsKey === argsKey &&
+								context.state.previewGeneration === previewGeneration
+							) {
+								context.state.preview = result;
+								context.invalidate();
+							}
+						})
+						.catch((err: unknown) => {
+							if (
+								context.state.argsKey === argsKey &&
+								context.state.previewGeneration === previewGeneration
+							) {
+								context.state.preview = {
+									error: err instanceof Error ? err.message : String(err),
+								};
+								context.invalidate();
+							}
+						});
+				}, PREVIEW_DEBOUNCE_MS);
+			}
+		}
+		const text = (context.lastComponent as Text | undefined) ?? new Text("", 0, 0);
+		text.setText(fmtCall(getInput(args) ?? undefined, context.state as RRState, context.expanded, theme, toolName));
+		return text;
+	};
+}
+
+export function renderEditResult(
+	result: { content?: Array<{ type: string; text?: string }>; details?: ReplaceDetails },
+	isPartial: boolean,
+	theme: FgT,
+	context: any,
+): Text | Markdown {
+	if (isPartial) return reuseText(context, theme.fg("warning", "Editing..."));
+	const renderedText = getResultText(result);
+	const renderState = context.state as RRState | undefined;
+	if (renderState) {
+		if (renderState.previewTimer) {
+			clearTimeout(renderState.previewTimer);
+			renderState.previewTimer = undefined;
+		}
+		renderState.preview = undefined;
+		renderState.previewGeneration = (renderState.previewGeneration ?? 0) + 1;
+	}
+	if (context.isError) {
+		return renderedText
+			? reuseText(context, `\n${theme.fg("error", renderedText)}`)
+			: new Text("", 0, 0);
+	}
+	if (isApplied(result.details)) {
+		const appliedText = buildAppliedText(renderedText, result.details, theme);
+		return appliedText ? reuseText(context, appliedText) : new Text("", 0, 0);
+	}
+	if (!renderedText) return new Text("", 0, 0);
+	return reuseMarkdown(context, fmtResultMd(renderedText), theme);
+}
+

package/src/replace-response.ts

@@ -2,7 +2,7 @@ import type { ReplaceDetails } from "./replace";
 import { genDiff, genPatch } from "./replace-diff";
 import { visLines, clipLine } from "./utils";
 
-type TResult = {
+export type TResult = {
 	content: Array<{ type: "text"; text: string }>;
 	isError?: boolean;
 	details: ReplaceDetails;
@@ -38,6 +38,7 @@ export interface NoopInput {
 	snapshotId?: string;
 	editMeta: RMeta;
 	warnings: string[] | undefined;
+	boundaryRemovedLines?: number;
 }
 
 export interface SuccessInput {
@@ -88,20 +89,25 @@ function warnBlock(warnings: string[] | undefined): string {
 	return warnings?.length ? `\n\nWarnings:\n${warnings.join("\n")}` : "";
 }
 
-export function buildNoop(input: NoopInput): TResult {
+export function buildNoop(input: NoopInput, noopNoun = "Replacement"): TResult {
 	const {
 		path,
 		noopEdit,
 		snapshotId,
 		editMeta,
 		warnings,
+		boundaryRemovedLines,
 	} = input;
 
 	const noopDetailsText = noopEdit
-		? `Replacement for ${noopEdit.loc} is identical to current content:\n  ${noopEdit.loc}: ${clipLine(noopEdit.currentContent)}`
+		? `${noopNoun} for ${noopEdit.loc} is identical to current content:\n  ${noopEdit.loc}: ${clipLine(noopEdit.currentContent)}`
 		: "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.`
+			: "";
 
-	const text = `No changes made to ${path}\nClassification: noop\n${noopDetailsText}${warnBlock(warnings)}`;
+	const text = `No changes made to ${path}\nClassification: noop\n${noopDetailsText}${dedupNote}${warnBlock(warnings)}`;
 
 	const metrics = buildMetrics({
 		classification: "noop",
@@ -123,14 +129,14 @@ export function buildNoop(input: NoopInput): TResult {
 	};
 }
 
-export function buildChanged(input: SuccessInput): TResult {
+export function buildChanged(input: SuccessInput, verb = "replaced"): TResult {
   const { path, result, warnings, snapshotId, originalNormalized, originalHashes, editMeta, resultHashes } = input;
   const resultLines = visLines(result);
   const diffResult = genDiff(originalNormalized, result, 1, resultHashes, originalHashes);
   const addedLines = editMeta.addedLines;
   const removedLines = editMeta.removedLines;
   const warningsBlock = warnBlock(warnings);
-  const successPrefix = `Successfully replaced in ${path}.`;
+  const successPrefix = `Successfully ${verb} in ${path}.`;
   const lineSummary = addedLines > 0 || removedLines > 0
     ? ` Added ${addedLines} line(s), removed ${removedLines} line(s).`
     : "";

package/src/replace-undo.ts

@@ -85,13 +85,13 @@ export async function clearUndo(path: string): Promise<void> {
   }
 }
 
-export function regReplaceUndo(pi: ExtensionAPI): void {
+export function regUndo(pi: ExtensionAPI): void {
   pi.registerTool({
-    name: "undo_last_replace",
-    label: "Undo Last Replace",
-    description: loadP("../prompts/undo-last-replace.md"),
-    promptSnippet: loadP("../prompts/undo-last-replace-snippet.md"),
-    promptGuidelines: loadGuide("../prompts/undo-last-replace-guidelines.md"),
+    name: "undo_last_change",
+    label: "Undo Last Change",
+    description: loadP("../prompts/undo-last-change.md"),
+    promptSnippet: loadP("../prompts/undo-last-change-snippet.md"),
+    promptGuidelines: loadGuide("../prompts/undo-last-change-guidelines.md"),
     prepareArguments: makePrepareArguments(),
     parameters: Type.Object({
       path: Type.String({
@@ -110,7 +110,7 @@ export function regReplaceUndo(pi: ExtensionAPI): void {
           content: [
             {
               type: "text",
-              text: `No undo history for ${path}. There is no previous replace to revert.`,
+              text: `No undo history for ${path}.`,
             },
           ],
           isError: true,
@@ -132,7 +132,7 @@ export function regReplaceUndo(pi: ExtensionAPI): void {
             content: [
               {
                 type: "text",
-                text: `[E_UNDO_STALE] Cannot undo last replace on ${path}: the file no longer exists. Call read() to inspect the current state.`
+                text: `[E_UNDO_STALE] Cannot undo last change on ${path}: the file no longer exists.`
               },
             ],
             isError: true,
@@ -145,7 +145,7 @@ export function regReplaceUndo(pi: ExtensionAPI): void {
             content: [
               {
                 type: "text",
-                text: `[E_UNDO_STALE] Cannot undo last replace on ${path}: the file was modified after the replace, so undoing would overwrite those changes. Call read() to inspect the current state.`
+                text: `[E_UNDO_STALE] Cannot undo last change on ${path}: the file changed after the edit. Call read() to inspect the current state.`
               },
             ],
             isError: true,
@@ -178,15 +178,15 @@ export function regReplaceUndo(pi: ExtensionAPI): void {
         await clearUndo(mutationTargetPath);
 
         const parts: string[] = [
-          `Undone last replace on ${path}.`,
+          `Undone last change on ${path}.`,
         ];
         if (linesAddedByReplace > 0 || linesRemovedByReplace > 0) {
           parts.push(
-            `Removed ${linesAddedByReplace} line(s) that were added and restored ${linesRemovedByReplace} line(s) that were removed.`,
+            `Removed ${linesAddedByReplace} line(s), restored ${linesRemovedByReplace} line(s).`,
           );
         }
         parts.push(
-          "File reverted to previous state. Call `read` to get fresh anchors for follow-up edits.",
+          "Call read for fresh anchors.",
         );
 
         return {