@d3ara1n/pi-hashline-edit 0.3.0 → 0.3.1

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@d3ara1n/pi-hashline-edit",
-  "version": "0.3.0",
+  "version": "0.3.1",
   "type": "module",
   "description": "Hashline-style file editing for pi — line-anchored edits verified by content hash, replacing oldText/newText matching",
   "keywords": [

package/src/pi/edit-tool.ts

@@ -209,7 +209,9 @@ export function makeEditOverride(cwd: string) {
 			}
 			const diff: string | undefined = result.details?.diff;
 			if (!diff) {
-				const t = content?.type === "text" ? content.text : "Edited";
+				// No net diff (e.g. a successful but non-mutating edit): show only the summary
+				// line — content.text also carries `Updated anchors` (hashline) for the model.
+				const t = content?.type === "text" ? content.text.split("\n")[0] : "Edited";
 				return new Text(theme.fg("success", t), 0, 0);
 			}
 			// details.diff is pi-format (+N/-N/<space>N content); color by leading char

package/src/pi/grep-tool.ts

@@ -33,6 +33,7 @@ import { hashFileLines } from "../core/hash.ts";
 import { splitLines } from "../core/lines.ts";
 import { getState } from "./state.ts";
 import { canonicalPath } from "./read-tool.ts";
+import { parseHashline } from "./render.ts";
 
 const DEFAULT_LIMIT = 100;
 /** Max chars per result line for display (mirrors pi's truncate.ts; not exported there). */
@@ -89,9 +90,9 @@ function toDisplayLines(raw: string, theme: any): string[] {
 			const group: { lineNo: string; content: string }[] = [];
 			let j = i + 1;
 			while (j < lines.length) {
-				const a = lines[j].match(/^(\d+)#[A-Za-z0-9]+│(.*)$/);
+				const a = parseHashline(lines[j]);
 				if (!a) break;
-				group.push({ lineNo: a[1], content: a[2] });
+				group.push({ lineNo: a.lineNo, content: a.content });
 				j++;
 			}
 			// common base = min leading whitespace across the group; fold it into a marker

package/src/pi/read-tool.ts

@@ -9,13 +9,15 @@
  * @module pi-hashline-edit/pi
  */
 
-import { createReadTool } from "@earendil-works/pi-coding-agent";
+import { createReadTool, getLanguageFromPath, highlightCode } from "@earendil-works/pi-coding-agent";
+import { Text } from "@earendil-works/pi-tui";
 import { readFile } from "node:fs/promises";
 import { join, resolve } from "node:path";
 import { homedir } from "node:os";
 import { hashFileLines } from "../core/hash.ts";
 import { splitLines } from "../core/lines.ts";
 import { getState } from "./state.ts";
+import { parseHashline } from "./render.ts";
 
 const MAX_LINES = 2000;
 const MAX_BYTES = 256 * 1024;
@@ -37,6 +39,70 @@ function expandTilde(p: string): string {
 	return p;
 }
 
+/** Offset/limit range suffix for the read call line, e.g. `:50-99` (mirrors pi core's read tool). */
+function formatReadLineRange(args: any, theme: any): string {
+	if (args?.offset === undefined && args?.limit === undefined) return "";
+	const start = args.offset ?? 1;
+	const end = args.limit !== undefined ? start + args.limit - 1 : "";
+	return theme.fg("warning", `:${start}${end ? `-${end}` : ""}`);
+}
+
+/**
+ * Render the expanded read body for the TUI: color the header, strip the
+ * `LINE#HASH│` prefix from every anchor line to `   N: content`, and
+ * syntax-highlight the code block by the file's language (falls back to a
+ * single `toolOutput` color when the language is unknown or the highlight
+ * line count diverges). Trailing notices (e.g. truncation) are shown in
+ * `warning`.
+ */
+function renderReadBody(raw: string, path: string, theme: any): string {
+	const lines = raw.split("\n");
+	if (lines.length === 0) return "";
+	const out: string[] = [];
+
+	// Header: "<path> · <N> lines" optionally followed by " (from line <offset>)".
+	let bodyStart = 0;
+	const h = lines[0].match(/^(.+?) · (\d+ lines(?: \(from line \d+\))?)$/);
+	if (h) {
+		out.push(theme.fg("success", h[1]) + theme.fg("dim", ` · ${h[2]}`));
+		bodyStart = 1;
+	}
+
+	// Collect anchor rows (full content); the first non-anchor line begins the tail.
+	const lineNos: string[] = [];
+	const codeContents: string[] = [];
+	let tailStart = lines.length;
+	for (let i = bodyStart; i < lines.length; i++) {
+		const row = parseHashline(lines[i]);
+		if (!row) {
+			tailStart = i;
+			break;
+		}
+		lineNos.push(row.lineNo);
+		codeContents.push(row.content);
+	}
+
+	// Syntax-highlight the whole block so multi-line constructs stay correct.
+	const detabbed = codeContents.map((l) => l.replace(/\t/g, "   "));
+	const lang = getLanguageFromPath(path);
+	let rendered: string[];
+	if (lang) {
+		const hl = highlightCode(detabbed.join("\n"), lang);
+		// Guard against highlighters that reshape line count: fall back to plain.
+		rendered = hl.length === detabbed.length ? hl : detabbed.map((l) => theme.fg("toolOutput", l));
+	} else {
+		rendered = detabbed.map((l) => theme.fg("toolOutput", l));
+	}
+	for (let i = 0; i < rendered.length && i < lineNos.length; i++) {
+		out.push(theme.fg("dim", `   ${lineNos[i]}: `) + rendered[i]);
+	}
+
+	for (let i = tailStart; i < lines.length; i++) {
+		out.push(theme.fg("warning", lines[i]));
+	}
+	return out.join("\n");
+}
+
 /** Build the read override (a ToolDefinition fragment for registerTool). */
 export function makeReadOverride(cwd: string) {
 	const builtin = createReadTool(cwd);
@@ -52,6 +118,29 @@ export function makeReadOverride(cwd: string) {
 			"Pass `path`; optionally `offset` (1-indexed start line) and `limit` (max lines). Prefer read over cat/sed for files you intend to edit.",
 		],
 		parameters: builtin.parameters,
+		renderShell: "default" as const,
+
+		renderCall(args: any, theme: any) {
+			const pathDisplay = String(args?.path ?? "");
+			let text = theme.fg("toolTitle", theme.bold("read")) + " " + theme.fg("accent", pathDisplay);
+			const range = formatReadLineRange(args, theme);
+			if (range) text += range;
+			return new Text(text, 0, 0);
+		},
+
+		renderResult(result: any, { isPartial, expanded }: any, theme: any, context: any) {
+			if (isPartial) return new Text(theme.fg("warning", "Reading…"), 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);
+			}
+			// Collapsed (not expanded): show nothing — the call line carries the
+			// title, matching the built-in read's fold behavior.
+			if (!expanded) return new Text("", 0, 0);
+			const raw = content?.type === "text" ? content.text : "";
+			return new Text(renderReadBody(raw, String(context?.args?.path ?? ""), theme), 0, 0);
+		},
 
 		async execute(toolCallId: string, params: any, signal: AbortSignal | undefined, onUpdate: any) {
 			// Not enabled OR user cancelled → delegate to the built-in (builtin handles abort itself)

package/src/pi/render.ts

@@ -0,0 +1,30 @@
+/**
+ * Shared anchor-parsing helper for the hashline-aware tool renderers.
+ *
+ * The model-facing `content` text uses the `LINE#HASH│content` anchor format so
+ * an anchor can be copied straight into an edit op. The user-facing TUI
+ * renderers (read, grep) strip that prefix back to a clean `   N: content` form.
+ * Parsing the anchor format in one place keeps read and grep in sync.
+ *
+ * @module pi-hashline-edit/pi
+ */
+
+const HASHLINE_RE = /^(\d+)#[A-Za-z0-9]+│(.*)$/;
+
+export interface HashlineRow {
+	/** Line number as written in the anchor (string form). */
+	lineNo: string;
+	/** Line content with the `LINE#HASH│` prefix removed. */
+	content: string;
+}
+
+/**
+ * Parse a `LINE#HASH│content` anchor line.
+ *
+ * @returns the row, or `null` for non-anchor lines (headers, notices, free
+ *   text) so callers can fall through to their own formatting.
+ */
+export function parseHashline(line: string): HashlineRow | null {
+	const m = line.match(HASHLINE_RE);
+	return m ? { lineNo: m[1], content: m[2] } : null;
+}

package/src/pi/replace-tool.ts

@@ -180,7 +180,9 @@ export function makeReplaceTool(cwd: string) {
 			}
 			const diff: string | undefined = result.details?.diff;
 			if (!diff) {
-				const t = content?.type === "text" ? content.text : "Replaced";
+				// No net diff: show only the summary line — content.text also carries
+				// `Updated anchors` (hashline) for the model.
+				const t = content?.type === "text" ? content.text.split("\n")[0] : "Replaced";
 				return new Text(theme.fg("success", t), 0, 0);
 			}
 			// details.diff is pi-format (+N/-N/<space>N content); color by leading char