pi-hashline-edit-pro 6.4.7 → 6.5.0

package/src/insert.ts

@@ -12,7 +12,7 @@ import { stripAnchorRow } from "./hashline/resolve";
 import { withAnchorSession } from "./anchor-registry";
 import { loadP, loadGuidelines } from "./prompts";
 import { assertInsertReq, normReq, type InsertReq } from "./payload-contract";
-import { isRec, literalEscapeHints, splitLines } from "./utils";
+import { anchorCarryIndex, isRec, literalEscapeHints, splitLines } from "./utils";
 import { queuedEdit, editToolBase, editRenderCallWrapper, editRenderResultWrapper, resolveEditTargetWithRequirement, throwIfStrictInput, withInsertPrompts, DEFAULT_EDIT_FLAGS, type EditToolFlags } from "./edit-common";
 import type { RPreview, RRState } from "./replace-render";
 import { editResultSchema, withStructuredErrors } from "./structured";
@@ -98,6 +98,11 @@ function insertStripWarning(anchorLine: string | undefined, direction: "before"
   return { label: "text", indexOffset: anchorLine !== undefined && direction === "after" ? -1 : 0 };
 }
 
+function insertAnchorCarry(direction: "before" | "after", editParams: HTEdit, anchorLine: string | undefined): number | undefined {
+  if (anchorLine === undefined) return undefined;
+  return anchorCarryIndex(direction, editParams.text.length - 1);
+}
+
 function planInsertBatchMember(input: BatchPlannerInput): BatchMemberPlan {
   const req = normReq(input.member.args);
   assertInsertReq(req);
@@ -149,6 +154,7 @@ export async function insertPreview(request: unknown, cwd: string, signal?: Abor
       signal,
     });
     const { editParams, anchorLine, contentSeparators } = buildInsertEdit(normalized, preload, ref, targetPath);
+    const anchorCarry = insertAnchorCarry(normalized.direction, editParams, anchorLine);
     const pipe = await execPipeline(targetPath, editParams, cwd, {
       accessMode: constants.R_OK,
       noPersist: true,
@@ -156,6 +162,7 @@ export async function insertPreview(request: unknown, cwd: string, signal?: Abor
       signal,
       stripWarning: insertStripWarning(anchorLine, normalized.direction),
       endingOverrides: contentSeparators,
+      ...(anchorCarry !== undefined ? { anchorCarry } : {}),
     });
     return previewFromPipe(pipe);
   } catch (error: unknown) {
@@ -241,21 +248,21 @@ export function buildInsertToolDef(flags: EditToolFlags = DEFAULT_EDIT_FLAGS): I
             maxLines: MAX_HASH_LINES,
           });
           const { editParams, anchorLine, contentSeparators } = buildInsertEdit(req, preload, ref, targetPath);
+          const anchorCarry = insertAnchorCarry(req.direction, editParams, anchorLine);
           const pipe = await execPipeline(targetPath, editParams, ctx.cwd, {
             accessMode: constants.R_OK | constants.W_OK,
             signal,
             preloadedNorm: preload,
             stripWarning: insertStripWarning(anchorLine, req.direction),
             endingOverrides: contentSeparators,
+            ...(anchorCarry !== undefined ? { anchorCarry } : {}),
           });
           return commitEdit(pipe, {
             path: pipe.path,
             absolutePath,
             mutationTargetPath,
             editAnchors: [editParams.remove_from, editParams.remove_to],
-            ...(anchorLine === undefined
-              ? {}
-              : { anchorCarry: req.direction === "after" ? 0 : editParams.text.length - 1 }),
+            ...(anchorCarry !== undefined ? { anchorCarry } : {}),
             signal,
             verb: "inserted",
             noopNoun: "Insertion",

package/src/payload-contract.ts

@@ -1,6 +1,7 @@
 import { Type } from "typebox";
 import { isRec, normalizeRequest, rejectUnknownFields, assertNoNul } from "./utils";
 import { TEXT_ENDING_NOTE, TEXT_NOT_STRING_MSG, NEW_CONTENT_NOT_STRING_MSG } from "./constants";
+import { toLF } from "./normalize";
 
 const textSchema = Type.String({
   description:
@@ -166,25 +167,44 @@ export function assertTransferReq(request: unknown): asserts request is Transfer
   }
 }
 
-const MATCH_KS = new Set(["path", "replace_from", "replace_to", "old_string", "new_string"]);
+const MATCH_KS = new Set(["path", "replace_from", "replace_to", "match", "replacement"]);
 
 export interface ReplaceMatchReq {
   path?: string;
   replace_from: string;
   replace_to: string;
-  old_string: string;
-  new_string: string;
+  match: string;
+  replacement: string;
+}
+
+export function singleLineFragment(field: "match" | "replacement", raw: string): string {
+  const text = toLF(raw);
+  const fragment = text.endsWith("\n") ? text.slice(0, -1) : text;
+  const lineBreak = fragment.indexOf("\n");
+  if (lineBreak >= 0) {
+    const column = [...fragment.slice(0, lineBreak)].length + 1;
+    throw new Error(
+      `[E_BAD_SHAPE] ${field} must stay within one line, but the value contains a line break at column ${column}. A trailing line break is accepted as the line's own terminator; text on another line belongs to replace.`,
+    );
+  }
+  if (field === "match" && fragment.length === 0) {
+    throw new Error('[E_BAD_SHAPE] Replace-match request field "match" must be a non-empty string holding the exact text to find.');
+  }
+  return fragment;
 }
 
 export function assertReplaceMatchReq(request: unknown): asserts request is ReplaceMatchReq {
   if (!isRec(request)) {
     throw new Error("[E_BAD_SHAPE] Replace-match request must be an object.");
   }
+  if ("old_string" in request || "new_string" in request) {
+    throw new Error('[E_BAD_SHAPE] Replace-match request no longer accepts "old_string"/"new_string"; use "match" for the text to find and "replacement" for the new text.');
+  }
   rejectUnknownFields(request, MATCH_KS, "Replace-match request");
   if (request.path !== undefined && typeof request.path !== "string") {
     throw new Error('[E_BAD_SHAPE] Replace-match request field "path" must be a string when provided.');
   }
-  for (const key of ["replace_from", "replace_to", "old_string", "new_string"] as const) {
+  for (const key of ["replace_from", "replace_to", "match", "replacement"] as const) {
     if (typeof (request as Record<string, unknown>)[key] !== "string") {
       throw new Error(`[E_BAD_SHAPE] Replace-match request requires a "${key}" string.`);
     }
@@ -193,13 +213,12 @@ export function assertReplaceMatchReq(request: unknown): asserts request is Repl
   if (within.replace_from.length === 0 || within.replace_to.length === 0) {
     throw new Error('[E_BAD_SHAPE] Replace-match request requires non-empty "replace_from" and "replace_to" anchors.');
   }
-  if (within.old_string.length === 0) {
-    throw new Error('[E_BAD_SHAPE] Replace-match request field "old_string" must be a non-empty string holding the exact text to find.');
-  }
-  assertNoNul([within.new_string]);
+  singleLineFragment("match", within.match);
+  singleLineFragment("replacement", within.replacement);
+  assertNoNul([within.replacement]);
 }
 
-export function getReplaceMatchInput(args: unknown): { path?: string; replace_from: string; replace_to: string; old_string: string; new_string: string } | null {
+export function getReplaceMatchInput(args: unknown): { path?: string; replace_from: string; replace_to: string; match: string; replacement: string } | null {
   let normalized: unknown;
   try {
     normalized = normalizeRequest(args, "replace");
@@ -210,8 +229,8 @@ export function getReplaceMatchInput(args: unknown): { path?: string; replace_fr
   if (
     typeof normalized.replace_from !== "string" ||
     typeof normalized.replace_to !== "string" ||
-    typeof normalized.old_string !== "string" ||
-    typeof normalized.new_string !== "string"
+    typeof normalized.match !== "string" ||
+    typeof normalized.replacement !== "string"
   ) {
     return null;
   }
@@ -219,8 +238,8 @@ export function getReplaceMatchInput(args: unknown): { path?: string; replace_fr
     ...(typeof normalized.path === "string" ? { path: normalized.path } : {}),
     replace_from: normalized.replace_from,
     replace_to: normalized.replace_to,
-    old_string: normalized.old_string,
-    new_string: normalized.new_string,
+    match: normalized.match,
+    replacement: normalized.replacement,
   };
 }
 
@@ -230,15 +249,15 @@ const replaceMatchFromSchema = Type.String({
 });
 const replaceMatchToSchema = Type.String({
   description:
-    "4-char anchor of the LAST line of the range searched; same as replace_from for a single line.",
+    "4-char anchor of the LAST line of the range searched; same as `replace_from` for a single line.",
 });
-const replaceMatchOldStringSchema = Type.String({
+const replaceMatchMatchSchema = Type.String({
   description:
-    "The exact text to find inside the selected line(s), copied from the served row: only the fragment that changes, never text that `new_string` leaves unchanged. If `old_string` is everything on the line except indentation and trailing punctuation, that is a whole-line match: use `replace` instead. Every occurrence inside the range is replaced; the text around each match is left untouched. Matching uses LF line breaks and excludes the last line's terminator.",
+    "The exact text to find inside the selected lines, copied from the served row: only the fragment that changes, never text that `replacement` leaves unchanged. It must stay within one line and hold text: a single trailing line break is accepted as the line's own terminator, a line break anywhere else is refused, and a value that is only a line break leaves nothing to find and is refused. Every occurrence inside the range is replaced; the text around each match is left untouched. If `match` is an entire single-line range except indentation and trailing punctuation, that is a whole-line match: use `replace` instead.",
 });
-const replaceMatchNewStringSchema = Type.String({
+const replaceMatchReplacementSchema = Type.String({
   description:
-    `The exact replacement for every matched occurrence. "" deletes the matches. ${TEXT_ENDING_NOTE} The rest of the range is kept byte-for-byte.`,
+    `The exact replacement for every matched occurrence within the range. "" deletes the matches. It must stay within one line: a single trailing line break is accepted and dropped (a value that is only a line break counts as ""), and a line break anywhere else is refused. The rest of each line is kept byte-for-byte.`,
 });
 const replaceMatchPathRequiredSchema = Type.String({
   description:
@@ -249,8 +268,8 @@ export const replaceMatchToolSchema = Type.Object(
   {
     replace_from: replaceMatchFromSchema,
     replace_to: replaceMatchToSchema,
-    old_string: replaceMatchOldStringSchema,
-    new_string: replaceMatchNewStringSchema,
+    match: replaceMatchMatchSchema,
+    replacement: replaceMatchReplacementSchema,
   },
   { additionalProperties: true },
 );
@@ -262,8 +281,8 @@ export function buildReplaceMatchToolSchema(requirePath: boolean): typeof replac
       path: replaceMatchPathRequiredSchema,
       replace_from: replaceMatchFromSchema,
       replace_to: replaceMatchToSchema,
-      old_string: replaceMatchOldStringSchema,
-      new_string: replaceMatchNewStringSchema,
+      match: replaceMatchMatchSchema,
+      replacement: replaceMatchReplacementSchema,
     },
     { additionalProperties: true },
   ) as typeof replaceMatchToolSchema;

package/src/read.ts

@@ -23,7 +23,7 @@ import { withAnchorSession, adoptAnchors, ownerOf, ownersDifferingOnlyByCase, fo
 import { serveRows } from "./served";
 import { snapshotCache } from "./hash-store/cache";
 import { Text } from "@earendil-works/pi-tui";
-import { anchoredLine, readResultSchema, withStructuredErrors, type AnchoredLine, type ReadResult } from "./structured";
+import { anchoredLine, readResultSchema, withStructuredErrors, type AnchoredLine, type ReadResult, type ReadTextResult } from "./structured";
 const R_DESC = loadP("../tool-prompts/read.md");
 const R_SNIPPET = loadP("../tool-prompts/read-snippet.md");
 function readGuide(): Guideline[] {
@@ -241,7 +241,6 @@ function anchorRefOf(args: unknown): { anchor: string; limit: number | undefined
 	const { offset, limit, path } = args;
 	if (typeof offset !== "string" || offset.length === 0 || /^\d+$/.test(offset)) return undefined;
 	const validLimit = typeof limit === "number" && Number.isInteger(limit) && limit >= 1 ? limit : undefined;
-	if (limit !== undefined && validLimit === undefined) return undefined;
 	return { anchor: offset, limit: validLimit, path: typeof path === "string" ? path : undefined };
 }
 
@@ -263,28 +262,79 @@ function anchorLineOf(anchor: string, path: string | undefined, cwd: unknown): n
 	return index < 0 ? undefined : index + 1;
 }
 
+const ANSI_ESC = String.fromCharCode(27);
+const CALL_ANSI_RE = new RegExp(`${ANSI_ESC}\\[[0-9;]*m`, "g");
+const CALL_ANSI_AT_RE = new RegExp(`^${ANSI_ESC}\\[[0-9;]*m`);
+
+function rawIndexForPlainIndex(text: string, plainIndex: number): number {
+	let raw = 0;
+	let plain = 0;
+	while (raw < text.length && plain < plainIndex) {
+		const escape = CALL_ANSI_AT_RE.exec(text.slice(raw));
+		if (escape !== null) {
+			raw += escape[0].length;
+			continue;
+		}
+		raw += 1;
+		plain += 1;
+	}
+	return raw;
+}
+
+export function insertBeforeExpandHint(text: string, suffix: string): string {
+	const plain = text.replace(CALL_ANSI_RE, "");
+	if (!plain.endsWith(" to expand)")) return `${text}${suffix}`;
+	const plainIndex = plain.lastIndexOf(" (");
+	const insertAt = plainIndex < 0 ? text.length : rawIndexForPlainIndex(text, plainIndex);
+	return `${text.slice(0, insertAt)}${suffix}${text.slice(insertAt)}`;
+}
+
+function anchorRangeLabel(ref: { anchor: string; limit: number | undefined }, line: number | undefined): string {
+	if (line === undefined) return ref.limit === undefined ? `:${ref.anchor}` : `:${ref.anchor} +${ref.limit}`;
+	return ref.limit === undefined ? `:${line} (${ref.anchor})` : `:${line}-${line + ref.limit - 1} (${ref.anchor})`;
+}
+
 function renderReadCall(args: unknown, theme: any, context: any): Text {
 	const normalized = normalizeReadCallArgs(args);
-	const rendered = builtinReadRenderCall(normalized, theme, context);
 	const ref = anchorRefOf(normalized);
-	if (ref === undefined) return rendered;
-	const marker = `:${ref.anchor}`;
-	const text = (rendered as unknown as { text: string }).text;
-	const index = text.lastIndexOf(marker);
-	if (index < 0) return rendered;
+	if (ref === undefined) return builtinReadRenderCall(normalized, theme, context);
+	const rendered = builtinReadRenderCall(isRec(normalized) ? { ...normalized, offset: undefined, limit: undefined } : normalized, theme, context);
 	const line = anchorLineOf(ref.anchor, ref.path, context?.cwd);
-	if (line === undefined) {
-		if (ref.limit === undefined) return rendered;
-		const suffix = theme.fg("warning", ` +${ref.limit}`);
-		rendered.setText(`${text.slice(0, index + marker.length)}${suffix}${text.slice(index + marker.length)}`);
-		return rendered;
-	}
-	const range = ref.limit === undefined ? `${line}` : `${line}-${line + ref.limit - 1}`;
-	const replacement = theme.fg("warning", `:${range} (${ref.anchor})`);
-	rendered.setText(`${text.slice(0, index)}${replacement}${text.slice(index + marker.length)}`);
+	const suffix = theme.fg("warning", anchorRangeLabel(ref, line));
+	const text = (rendered as unknown as { text: string }).text;
+	rendered.setText(insertBeforeExpandHint(text, suffix));
 	return rendered;
 }
 
+function buildReadToolSchema(codemode: boolean) {
+	return Type.Object({
+		path: Type.String({
+			description: "Path to the file to read (relative or absolute)",
+		}),
+		offset: Type.Optional(
+			Type.Union([
+				Type.Integer({ minimum: 1 }),
+				Type.String(),
+			], { description: "Line number (1-indexed) or a served anchor to start reading from" }),
+		),
+		limit: Type.Optional(
+			Type.Integer({
+				minimum: 1,
+				description: "Maximum number of lines to read from offset",
+			}),
+		),
+		...(codemode
+			? {
+					anchors: Type.Optional(
+						Type.Boolean({
+							description: "Return { text, lines, notices } with editable anchors instead of the plain file text to a codemode script",
+						}),
+					),
+				}
+			: {}),
+	});
+}
+
 export function regRead(pi: ExtensionAPI, flags: EditToolFlags = DEFAULT_EDIT_FLAGS): void {
   const prompted = withReadPrompts({ description: R_DESC, snippet: R_SNIPPET, guidelines: readGuide() }, flags);
   pi.registerTool({
@@ -294,23 +344,7 @@ export function regRead(pi: ExtensionAPI, flags: EditToolFlags = DEFAULT_EDIT_FL
     promptSnippet: prompted.snippet,
     promptGuidelines: prompted.guidelines,
 		prepareArguments: makePrepareArguments(),
-		parameters: Type.Object({
-			path: Type.String({
-				description: "Path to the file to read (relative or absolute)",
-			}),
-			offset: Type.Optional(
-				Type.Union([
-					Type.Integer({ minimum: 1 }),
-					Type.String(),
-				], { description: "Line number (1-indexed) or a served anchor to start reading from" }),
-			),
-			limit: Type.Optional(
-				Type.Integer({
-					minimum: 1,
-					description: "Maximum number of lines to read from offset",
-				}),
-			),
-		}),
+		parameters: buildReadToolSchema(flags.codemode),
 		outputSchema: readResultSchema,
 		executionMode: "sequential",
 		renderCall: renderReadCall,
@@ -370,7 +404,7 @@ export function regRead(pi: ExtensionAPI, flags: EditToolFlags = DEFAULT_EDIT_FL
 				const servedRawText = preview.anchoredLines.map((row) => fileLines[row.line - 1] ?? "").join("\n");
 				const rawTruncation = servedRawText.length > 0 ? truncateHead(servedRawText, { maxBytes: DEFAULT_MAX_BYTES, maxLines: DEFAULT_MAX_LINES }) : undefined;
 
-				const structuredContent: ReadResult = {
+				const readResult: ReadTextResult = {
 					ok: true,
 					kind: "read",
 					path: rawPath,
@@ -384,6 +418,8 @@ export function regRead(pi: ExtensionAPI, flags: EditToolFlags = DEFAULT_EDIT_FL
 					hadUtf8DecodeErrors,
 					notices,
 				};
+				const anchorsRequested = isRec(params) && params.anchors === true;
+				const structuredContent: ReadResult = flags.codemode && !anchorsRequested ? readResult.text : readResult;
 				return {
 					content: [{ type: "text", text: previewText }],
 					details: {

package/src/replace-diff.ts

@@ -159,6 +159,40 @@ function placeSpans(
   return placed;
 }
 
+function splitPlacedSpan(
+  span: PlacedSpan,
+  oldLines: string[],
+  newLines: string[],
+  oldHashes: string[],
+  newIndexByHash: ReadonlyMap<string, number>,
+): PlacedSpan[] {
+  if (span.oldStart > span.oldEnd || span.newStart > span.newEnd) return [span];
+  const pairs: Array<[number, number]> = [];
+  let lastNew = span.newStart - 1;
+  for (let oldIdx = span.oldStart; oldIdx <= span.oldEnd; oldIdx++) {
+    const newIdx = newIndexByHash.get(oldHashes[oldIdx]!);
+    if (newIdx === undefined || newIdx < span.newStart || newIdx > span.newEnd || newIdx <= lastNew) continue;
+    if (oldLines[oldIdx] !== newLines[newIdx]) continue;
+    pairs.push([oldIdx, newIdx]);
+    lastNew = newIdx;
+  }
+  if (pairs.length === 0) return [span];
+  const out: PlacedSpan[] = [];
+  let oldCursor = span.oldStart;
+  let newCursor = span.newStart;
+  for (const [oldIdx, newIdx] of pairs) {
+    if (oldCursor <= oldIdx - 1 || newCursor <= newIdx - 1) {
+      out.push({ oldStart: oldCursor, oldEnd: oldIdx - 1, newStart: newCursor, newEnd: newIdx - 1 });
+    }
+    oldCursor = oldIdx + 1;
+    newCursor = newIdx + 1;
+  }
+  if (oldCursor <= span.oldEnd || newCursor <= span.newEnd) {
+    out.push({ oldStart: oldCursor, oldEnd: span.oldEnd, newStart: newCursor, newEnd: span.newEnd });
+  }
+  return out;
+}
+
 function trimPlacedSpans(
   placed: PlacedSpan[],
   oldLines: string[],
@@ -166,22 +200,11 @@ function trimPlacedSpans(
   oldHashes: string[],
   newHashes: string[],
 ): PlacedSpan[] {
+  const newIndexByHash = new Map<string, number>();
+  for (let index = 0; index < newHashes.length; index++) newIndexByHash.set(newHashes[index]!, index);
   const out: PlacedSpan[] = [];
   for (const span of placed) {
-    let oldStart = span.oldStart;
-    let oldEnd = span.oldEnd;
-    let newStart = span.newStart;
-    let newEnd = span.newEnd;
-    while (oldStart <= oldEnd && newStart <= newEnd && oldLines[oldStart] === newLines[newStart] && oldHashes[oldStart] === newHashes[newStart]) {
-      oldStart += 1;
-      newStart += 1;
-    }
-    while (oldStart <= oldEnd && newStart <= newEnd && oldLines[oldEnd] === newLines[newEnd] && oldHashes[oldEnd] === newHashes[newEnd]) {
-      oldEnd -= 1;
-      newEnd -= 1;
-    }
-    if (oldStart > oldEnd && newStart > newEnd) continue;
-    out.push({ oldStart, oldEnd, newStart, newEnd });
+    for (const piece of splitPlacedSpan(span, oldLines, newLines, oldHashes, newIndexByHash)) out.push(piece);
   }
   return out;
 }
@@ -364,7 +387,7 @@ export function genDiff(
 ): { diff: string; firstChangedLine: number | undefined; lineNumbers: (number|undefined)[] } {
   const maxLineBytes = limits?.unlimited ? Number.POSITIVE_INFINITY : (limits?.maxLineBytes ?? DEFAULT_MAX_BYTES);
   const maxBytes = limits?.unlimited ? Number.POSITIVE_INFINITY : (limits?.maxBytes ?? DEFAULT_MAX_BYTES);
-  if (spans && newContentHashes && oldContentHashes) {
+  if (spans && spans.length > 0 && newContentHashes && oldContentHashes) {
     const anchored = genSpanDiff(oldContent, newContent, contextLines, newContentHashes, oldContentHashes, maxLineBytes, maxBytes, spans);
     if (anchored) {
       const diff = disambiguateDuplicateAnchors(anchored.diff);