pi-hashline-edit-pro 0.4.3 → 0.6.0

package/src/hashline/hash.ts

@@ -40,7 +40,7 @@ export const DIFF_MINUS_RE = /^-\s*\d+\s{4}/;
 
 export const HASHLINE_BARE_PREFIX_RE = new RegExp(`^\\s*(${HASH_CHARS_CLASS})│`);
 
-const RE_SIGNIFICANT = /[\p{L}\p{N}]/u;
+
 
 // Lazy-initialized xxhash-wasm hasher. Initialization starts at module load
 // time and completes in ~2ms. By the time any tool calls xxh32(), the hasher
@@ -64,50 +64,35 @@ hasherPromise = xxhash().then((h) => {
 
 // Export for tests that need to await readiness.
 export function ensureHasherReady(): Promise<Hasher> {
-	return hasherPromise!;
+	return hasherPromise!
 }
 
 function xxh32(input: string, seed = 0): number {
 	return getHasher().h32(input, seed) >>> 0;
 }
 
-const SYMBOL_DISCRIMINATOR = (lineNumber: number): string => `S${lineNumber}`;
-const CONTENT_DISCRIMINATOR = (occurrence: number): string => `C${occurrence}`;
+const DISCRIMINATOR = (occurrence: number): string => `C${occurrence}`;
 
 function canonicalizeLine(line: string): string {
 	return line.replace(/\r/g, "").trimEnd();
 }
 
-function isSymbolOnly(canonical: string): boolean {
-	return !RE_SIGNIFICANT.test(canonical);
-}
-
 export function computeLineHashes(content: string): string[] {
 	const lines = content.split("\n");
 	const hashes = new Array<string>(lines.length);
 	const counts = new Map<string, number>();
 	for (let i = 0; i < lines.length; i++) {
-		const lineNumber = i + 1;
 		const canonical = canonicalizeLine(lines[i]!);
-		let discriminator: string;
-		if (isSymbolOnly(canonical)) {
-			discriminator = SYMBOL_DISCRIMINATOR(lineNumber);
-		} else {
-			const occurrence = (counts.get(canonical) ?? 0) + 1;
-			counts.set(canonical, occurrence);
-			discriminator = CONTENT_DISCRIMINATOR(occurrence);
-		}
-		hashes[i] = hashToString(xxh32(`${discriminator}:${canonical}`));
+		const occurrence = (counts.get(canonical) ?? 0) + 1;
+		counts.set(canonical, occurrence);
+		hashes[i] = hashToString(xxh32(`${DISCRIMINATOR(occurrence)}:${canonical}`));
 	}
 	return hashes;
 }
 
 export function computeLineHash(idx: number, line: string): string {
 	const canonical = canonicalizeLine(line);
-	const discriminator = isSymbolOnly(canonical)
-		? SYMBOL_DISCRIMINATOR(idx)
-		: CONTENT_DISCRIMINATOR(1);
-	return hashToString(xxh32(`${discriminator}:${canonical}`));
+	return hashToString(xxh32(`${DISCRIMINATOR(1)}:${canonical}`));
 }
 
 export const HASH_FORMAT = {

package/src/hashline/resolve.ts

@@ -10,21 +10,12 @@ export type ResolvedAnchor = {
 	hashMatched: boolean;
 };
 
-export type HashlineEdit =
-	| { op: "replace"; start: Anchor; end: Anchor; lines: string[] }
-	| { op: "append"; pos?: Anchor; lines: string[] }
-	| { op: "prepend"; pos?: Anchor; lines: string[] };
-
-export type ResolvedHashlineEdit =
-	| {
-			op: "replace";
-			start: ResolvedAnchor;
-			end: ResolvedAnchor;
-			lines: string[];
-	  }
-	| { op: "append"; pos?: ResolvedAnchor; lines: string[] }
-	| { op: "prepend"; pos?: ResolvedAnchor; lines: string[] };
-
+export type HashlineEdit = { start: Anchor; end: Anchor; lines: string[] };
+export type ResolvedHashlineEdit = {
+	start: ResolvedAnchor;
+	end: ResolvedAnchor;
+	lines: string[];
+};
 interface HashMismatch {
 	ref: Anchor;
 	kind: "not_found" | "ambiguous";
@@ -38,8 +29,6 @@ export interface NoopEdit {
 }
 
 export type HashlineToolEdit = {
-	op: string;
-	pos?: string;
 	start?: string;
 	end?: string;
 	lines?: string[];
@@ -130,7 +119,7 @@ export function formatMismatchError(
 }
 
 
-const ITEM_KEYS = new Set(["op", "pos", "start", "end", "lines"]);
+const ITEM_KEYS = new Set(["start", "end", "lines"]);
 function isStringArray(value: unknown): value is string[] {
 	return (
 		Array.isArray(value) && value.every((item) => typeof item === "string")
@@ -145,23 +134,6 @@ function assertEditItem(edit: Record<string, unknown>, index: number): void {
 		);
 	}
 
-	if (typeof edit.op !== "string") {
-		throw new Error(`[E_BAD_SHAPE] Edit ${index} requires an "op" string.`);
-	}
-	if (
-		edit.op !== "replace" &&
-		edit.op !== "append" &&
-		edit.op !== "prepend"
-	) {
-		throw new Error(
-			`[E_BAD_OP] Edit ${index} uses unknown op "${edit.op}". Expected "replace", "append", or "prepend".`,
-		);
-	}
-	if ("pos" in edit && typeof edit.pos !== "string" && edit.op !== "replace") {
-		throw new Error(
-			`[E_BAD_SHAPE] Edit ${index} field "pos" must be a string when provided.`,
-		);
-	}
 	if ("start" in edit && typeof edit.start !== "string") {
 		throw new Error(
 			`[E_BAD_SHAPE] Edit ${index} field "start" must be a string when provided.`,
@@ -176,29 +148,17 @@ function assertEditItem(edit: Record<string, unknown>, index: number): void {
 	if ("lines" in edit && !isStringArray(edit.lines)) {
 		throw new Error(`[E_BAD_SHAPE] Edit ${index} field "lines" must be a string array.`);
 	}
-	if (edit.op === "replace") {
-		if ("pos" in edit) {
-			throw new Error(
-				`[E_BAD_OP] Edit ${index} op "replace" uses "pos" — use "start" instead.`
-			);
-		}
-		if (typeof edit.start !== "string") {
-			throw new Error(
-				`[E_BAD_OP] Edit ${index} with op "replace" requires a "start" anchor string.`,
-			);
-		}
-		if (typeof edit.end !== "string") {
-			throw new Error(
-				`[E_BAD_OP] Edit ${index} with op "replace" requires an "end" anchor string.`,
-			);
-		}
+	if (typeof edit.start !== "string") {
+		throw new Error(
+			`[E_BAD_OP] Edit ${index} requires a "start" anchor string.`,
+		);
 	}
-
-	if ((edit.op === "append" || edit.op === "prepend") && "end" in edit) {
+	if (typeof edit.end !== "string") {
 		throw new Error(
-			`[E_BAD_OP] Edit ${index} op "${edit.op}" does not support "end". Use "pos" or omit.`
+			`[E_BAD_OP] Edit ${index} requires an "end" anchor string.`,
 		);
 	}
+
 }
 
 export function resolveEditAnchors(edits: HashlineToolEdit[]): HashlineEdit[] {
@@ -206,45 +166,21 @@ export function resolveEditAnchors(edits: HashlineToolEdit[]): HashlineEdit[] {
 	for (const [index, edit] of edits.entries()) {
 		assertEditItem(edit as Record<string, unknown>, index);
 
-		const op = edit.op;
-		switch (op) {
-			case "replace": {
-				// Normalize lines: [""] to lines: [] for deletion.
-				const replaceLines = hashlineParseText(edit.lines ?? null);
-				const normalizedLines =
-					replaceLines.length === 1 && replaceLines[0] === ""
-						? []
-						: replaceLines;
-				result.push({
-					op: "replace",
-					start: parseHashRef(edit.start!),
-					end: parseHashRef(edit.end!),
-					lines: normalizedLines,
-				});
-				break;
-			}
-			case "append": {
-				result.push({
-					op: "append",
-					...(edit.pos ? { pos: parseHashRef(edit.pos) } : {}),
-					lines: hashlineParseText(edit.lines ?? null),
-				});
-				break;
-			}
-			case "prepend": {
-				result.push({
-					op: "prepend",
-					...(edit.pos ? { pos: parseHashRef(edit.pos) } : {}),
-					lines: hashlineParseText(edit.lines ?? null),
-				});
-				break;
-			}
-		}
+		// Normalize lines: [""] to lines: [] for deletion.
+		const replaceLines = hashlineParseText(edit.lines ?? null);
+		const normalizedLines =
+			replaceLines.length === 1 && replaceLines[0] === ""
+				? []
+				: replaceLines;
+		result.push({
+			start: parseHashRef(edit.start!),
+			end: parseHashRef(edit.end!),
+			lines: normalizedLines,
+		});
 	}
 	return result;
 }
 
-
 function maybeWarnSuspiciousUnicodeEscapePlaceholder(
 	edits: HashlineEdit[],
 	warnings: string[],
@@ -308,14 +244,7 @@ export function assertNoBareHashPrefixLines(
  * Human-readable label for a resolved edit (used in warnings and conflict errors).
  */
 export function describeEdit(edit: ResolvedHashlineEdit): string {
-	switch (edit.op) {
-		case "replace":
-			return `replace ${edit.start.hash}-${edit.end.hash}`;
-		case "append":
-			return edit.pos ? `append after ${edit.pos.hash}` : "append at EOF";
-		case "prepend":
-			return edit.pos ? `prepend before ${edit.pos.hash}` : "prepend at BOF";
-	}
+	return `replace ${edit.start.hash}-${edit.end.hash}`;
 }
 
 export function validateAnchorEdits(
@@ -345,102 +274,56 @@ export function validateAnchorEdits(
 
 	for (const edit of edits) {
 		throwIfAborted(signal);
-		switch (edit.op) {
-			case "replace": {
-				const startResolved = tryResolve(edit.start);
-				const endResolved = tryResolve(edit.end);
-					if (!startResolved || !endResolved) {
-					continue;
-				}
-				if (startResolved.line > endResolved.line) {
-					throw new Error(
-						`[E_BAD_OP] Range start line ${startResolved.line} must be <= end line ${endResolved.line} (anchors ${edit.start.hash} and ${edit.end.hash}).`,
-					);
-				}
-				const endLine = endResolved.line;
-				const nextLine = fileLines[endLine];
-				const replacementLastLine = edit.lines.at(-1)?.trim();
-				if (
-					nextLine !== undefined &&
-					replacementLastLine &&
-					/[\p{L}\p{N}]/u.test(replacementLastLine) &&
-					replacementLastLine === nextLine.trim()
-				) {
-					const resolvedEdit: ResolvedHashlineEdit = {
-						op: "replace",
-						start: startResolved,
-						end: endResolved,
-						lines: edit.lines,
-					};
-					warnings.push(
-						`Potential boundary duplication after ${describeEdit(resolvedEdit)}: the replacement ends with a line that matches the next surviving line after trim.`,
-					);
-				}
-				const prevLine = fileLines[startResolved.line - 2];
-				const replacementFirstLine = edit.lines[0]?.trim();
-				if (
-					prevLine !== undefined &&
-					replacementFirstLine &&
-					/[\p{L}\p{N}]/u.test(replacementFirstLine) &&
-					replacementFirstLine === prevLine.trim()
-				) {
-					const resolvedEdit: ResolvedHashlineEdit = {
-						op: "replace",
-						start: startResolved,
-						end: endResolved,
-						lines: edit.lines,
-					};
-					warnings.push(
-						`Potential boundary duplication before ${describeEdit(resolvedEdit)}: the replacement starts with a line that matches the preceding surviving line after trim.`,
-					);
-				}
-				resolved.push({
-					op: "replace",
-					start: startResolved,
-					end: endResolved,
-					lines: edit.lines,
-				});
-				break;
-			}
-			case "append": {
-				let posResolved: ResolvedAnchor | undefined;
-				if (edit.pos) {
-					const r = tryResolve(edit.pos);
-					if (!r) continue;
-					posResolved = r;
-				}
-				if (edit.lines.length === 0) {
-					throw new Error(
-						"[E_BAD_OP] Append with empty lines payload. Provide content to insert or remove the edit.",
-					);
-				}
-				resolved.push({
-					op: "append",
-					...(posResolved ? { pos: posResolved } : {}),
-					lines: edit.lines,
-				});
-				break;
-			}
-			case "prepend": {
-				let posResolved: ResolvedAnchor | undefined;
-				if (edit.pos) {
-					const r = tryResolve(edit.pos);
-					if (!r) continue;
-					posResolved = r;
-				}
-				if (edit.lines.length === 0) {
-					throw new Error(
-						"[E_BAD_OP] Prepend with empty lines payload. Provide content to insert or remove the edit.",
-					);
-				}
-				resolved.push({
-					op: "prepend",
-					...(posResolved ? { pos: posResolved } : {}),
-					lines: edit.lines,
-				});
-				break;
-			}
+		const startResolved = tryResolve(edit.start);
+		const endResolved = tryResolve(edit.end);
+		if (!startResolved || !endResolved) {
+			continue;
+		}
+		if (startResolved.line > endResolved.line) {
+			throw new Error(
+				`[E_BAD_OP] Range start line ${startResolved.line} must be <= end line ${endResolved.line} (anchors ${edit.start.hash} and ${edit.end.hash}).`,
+			);
+		}
+		const endLine = endResolved.line;
+		const nextLine = fileLines[endLine];
+		const replacementLastLine = edit.lines.at(-1)?.trim();
+		if (
+			nextLine !== undefined &&
+			replacementLastLine &&
+			/[\p{L}\p{N}]/u.test(replacementLastLine) &&
+			replacementLastLine === nextLine.trim()
+		) {
+			const resolvedEdit: ResolvedHashlineEdit = {
+				start: startResolved,
+				end: endResolved,
+				lines: edit.lines,
+			};
+			warnings.push(
+				`Potential boundary duplication after ${describeEdit(resolvedEdit)}: the replacement ends with a line that matches the next surviving line after trim.`,
+			);
+		}
+		const prevLine = fileLines[startResolved.line - 2];
+		const replacementFirstLine = edit.lines[0]?.trim();
+		if (
+			prevLine !== undefined &&
+			replacementFirstLine &&
+			/[\p{L}\p{N}]/u.test(replacementFirstLine) &&
+			replacementFirstLine === prevLine.trim()
+		) {
+			const resolvedEdit: ResolvedHashlineEdit = {
+				start: startResolved,
+				end: endResolved,
+				lines: edit.lines,
+			};
+			warnings.push(
+				`Potential boundary duplication before ${describeEdit(resolvedEdit)}: the replacement starts with a line that matches the preceding surviving line after trim.`,
+			);
 		}
+		resolved.push({
+			start: startResolved,
+			end: endResolved,
+			lines: edit.lines,
+		});
 	}
 
 	return { resolved, mismatches };

package/src/read.ts

@@ -11,7 +11,7 @@ import { Type } from "typebox";
 import { readFileSync } from "fs";
 import { access as fsAccess } from "fs/promises";
 import { constants } from "fs";
-import { normalizeToLF, stripBom } from "./edit-diff";
+import { normalizeToLF, stripBom } from "./replace-diff";
 import { loadFileKindAndText } from "./file-kind";
 import { computeLineHashes, formatHashlineRegion } from "./hashline";
 import { resolveToCwd } from "./path-utils";
@@ -68,15 +68,14 @@ export function formatHashlineReadPreview(
 	if (totalLines === 0) {
 		if (startLine === 1) {
 			return {
-				text: "File is empty. Use edit with prepend or append and omit pos to insert content.",
+				text: "File is empty. Use edit to insert content.",
 			};
 		}
-
 		return {
-			text: `Offset ${startLine} is beyond end of file (0 lines total). The file is empty. Use edit with prepend or append and omit pos to insert content.`,
+			text: `Offset ${startLine} is beyond end of file (0 lines total). The file is empty. Use edit to insert content.`,
 		};
-	}
 
+	}
 	if (startLine > totalLines) {
 		return {
 			text: `Offset ${startLine} is beyond end of file (${totalLines} lines total). Use offset=1 to read from the start, or offset=${totalLines} to read the last line.`,
@@ -197,7 +196,7 @@ export function registerReadTool(pi: ExtensionAPI): void {
 			throwIfAborted(signal);
 			const normalized = normalizeToLF(stripBom(file.text).text);
 			// Compute hashes once for the whole file so the per-line anchors the
-			// model sees here are byte-identical to what the edit tool will
+			// model sees here are byte-identical to what the replace tool will
 			// compute when it later validates against this file.
 			const fileHashes = computeLineHashes(normalized);
 			const preview = formatHashlineReadPreview(

package/src/{edit-normalize.ts → replace-normalize.ts}

@@ -14,7 +14,7 @@ function coerceEditsArray(edits: unknown): unknown {
 }
 
 
-export function normalizeEditRequest(input: unknown): unknown {
+export function normalizeReplaceRequest(input: unknown): unknown {
 	if (!isRecord(input)) {
 		return input;
 	}

package/src/{edit-render.ts → replace-render.ts}

@@ -1,13 +1,13 @@
 /**
- * TUI rendering helpers for the edit tool.
+ * TUI rendering helpers for the replace tool.
  *
- * Extracted from `src/edit.ts` to separate presentation (color themes, diff
+ * Extracted from `src/replace.ts` to separate presentation (color themes, diff
  * formatting, Markdown rendering) from tool execution logic.
  */
 
 import type { Theme } from "@earendil-works/pi-coding-agent";
-import { normalizeEditRequest } from "./edit-normalize";
-import type { EditRequestParams, HashlineEditToolDetails } from "./edit";
+import { normalizeReplaceRequest } from "./replace-normalize";
+import type { ReplaceRequestParams, HashlineReplaceToolDetails } from "./replace";
 import { isRecord } from "./utils";
 
 // ─── Theme type aliases ─────────────────────────────────────────────────
@@ -21,11 +21,11 @@ export type RenderedMarkdownTheme = Pick<
 
 // ─── Render state ───────────────────────────────────────────────────────
 
-export type EditPreview = { diff: string } | { error: string };
+export type ReplacePreview = { diff: string } | { error: string };
 
-export type EditRenderState = {
+export type ReplaceRenderState = {
 	argsKey?: string;
-	preview?: EditPreview;
+	preview?: ReplacePreview;
 	previewGeneration?: number;
 };
 
@@ -34,10 +34,10 @@ export type EditRenderState = {
 
 export function getRenderablePreviewInput(
 	args: unknown,
-): EditRequestParams | null {
+): ReplaceRequestParams | null {
 	let normalized: unknown;
 	try {
-		normalized = normalizeEditRequest(args);
+		normalized = normalizeReplaceRequest(args);
 	} catch {
 		return null;
 	}
@@ -45,7 +45,7 @@ export function getRenderablePreviewInput(
 		return null;
 	}
 
-	const request: EditRequestParams = { path: normalized.path };
+	const request: ReplaceRequestParams = { path: normalized.path };
 	if (Array.isArray(normalized.edits)) {
 		request.edits = normalized.edits as any;
 	}
@@ -91,8 +91,8 @@ export function formatResultDiff(diff: string, theme: FgTheme): string {
 // ─── Edit call formatting ───────────────────────────────────────────────
 
 export function formatEditCall(
-	args: EditRequestParams | undefined,
-	state: EditRenderState,
+	args: ReplaceRequestParams | undefined,
+	state: ReplaceRenderState,
 	expanded: boolean,
 	theme: CallTheme,
 ): string {
@@ -101,7 +101,7 @@ export function formatEditCall(
 		typeof path === "string" && path.length > 0
 			? theme.fg("accent", path)
 			: theme.fg("toolOutput", "...");
-	let text = `${theme.fg("toolTitle", theme.bold("edit"))} ${pathDisplay}`;
+	let text = `${theme.fg("toolTitle", theme.bold("replace"))} ${pathDisplay}`;
 
 	if (!state.preview) {
 		return text;
@@ -139,7 +139,7 @@ export function extractRenderedWarnings(
 // ─── Result classification ──────────────────────────────────────────────
 
 export function isAppliedChangedResult(
-	details: HashlineEditToolDetails | undefined,
+	details: HashlineReplaceToolDetails | undefined,
 ): boolean {
 	const metrics = details?.metrics;
 	return (
@@ -152,8 +152,8 @@ export function isAppliedChangedResult(
 
 export function buildAppliedChangedResultText(
 	text: string | undefined,
-	details: HashlineEditToolDetails | undefined,
-	preview: EditPreview | undefined,
+	details: HashlineReplaceToolDetails | undefined,
+	preview: ReplacePreview | undefined,
 	theme: FgTheme,
 ): string | undefined {
 	const previewDiff =

package/src/{edit-response.ts → replace-response.ts}

@@ -1,5 +1,5 @@
 
-import { generateDiffString } from "./edit-diff";
+import { generateDiffString } from "./replace-diff";
 import {
 	computeAffectedLineRange,
 	computeLineHashes,
@@ -37,7 +37,7 @@ export type FullContentPreview = {
 	nextOffset?: number;
 };
 
-export type EditMetrics = {
+export type ReplaceMetrics = {
 	edits_attempted: number;
 	edits_noop: number;
 	warnings: number;
@@ -53,7 +53,7 @@ export type ReadMetrics = {
 	next_offset?: number;
 };
 
-export type EditMeta = {
+export type ReplaceMeta = {
 	editsAttempted: number;
 	noopEditsCount: number;
 	firstChangedLine?: number;
@@ -75,7 +75,7 @@ export interface NoopResponseInput {
 	noopEdits: NoopEditEntry[] | undefined;
 	originalNormalized: string;
 	snapshotId: string;
-	editMeta: EditMeta;
+	editMeta: ReplaceMeta;
 	warnings: string[] | undefined;
 }
 
@@ -92,7 +92,7 @@ export interface SuccessResponseInput {
 	resultHashes?: string[];
 	warnings: string[] | undefined;
 	snapshotId: string;
-	editMeta: EditMeta;
+	editMeta: ReplaceMeta;
 }
 
 // ─── Helpers ────────────────────────────────────────────────────────────
@@ -122,8 +122,8 @@ function buildMetrics(args: {
 	lastChangedLine?: number;
 	addedLines?: number;
 	removedLines?: number;
-}): EditMetrics {
-	const metrics: EditMetrics = {
+}): ReplaceMetrics {
+	const metrics: ReplaceMetrics = {
 		edits_attempted: args.editsAttempted,
 		edits_noop: args.noopEditsCount,
 		warnings: args.warningsCount,
@@ -471,7 +471,7 @@ export function buildChangedResponse(input: SuccessResponseInput): ToolResult {
 					: "Anchors omitted; use read for subsequent edits.";
 			})()
 		: resultLines.length === 0
-			? "File is empty. Use edit with prepend or append and omit pos to insert content."
+			? "File is empty. Use edit to insert content."
 			: "Anchors omitted; use read for subsequent edits.";
 
 	const text = [anchorsBlock, warningsBlock.trimStart()]