pi-hashline-edit-pro 4.5.2 → 5.0.0

package/src/replace-within.ts

@@ -0,0 +1,227 @@
+import type { ExtensionAPI, ToolDefinition } from "@earendil-works/pi-coding-agent";
+import { constants } from "node:fs";
+import { execPipeline, noteAnchorError, previewFromPipe, previewError, type ReplaceDetails } from "./replace";
+import { commitEdit } from "./commit";
+import { readNormFile, type NormFile } from "./file-reader";
+import { fmtRegion, MAX_HASH_LINES, parseHashRef, resolveAnchorLine, stripAnchorRow, type Anchor } from "./hashline";
+import { withAnchorSession } from "./anchor-registry";
+import { loadP, loadGuide } from "./prompts";
+import {
+  assertReplaceWithinReq,
+  buildReplaceWithinToolSchema,
+  getReplaceWithinInput,
+  normalizeReplaceWithinRequest,
+  type ReplaceWithinReq,
+} from "./payload-contract";
+import { literalEscapeHint, splitLines } from "./utils";
+import { toLF } from "./normalize";
+import { MAX_RANGE_STALE_LINES } from "./constants";
+import {
+  DEFAULT_EDIT_FLAGS,
+  editRenderResultWrapper,
+  editToolBase,
+  queuedEdit,
+  resolveEditTargetWithRequirement,
+  throwIfStrictInput,
+  tryResolveEditTarget,
+  withReplaceWithinPrompts,
+  type EditToolFlags,
+} from "./edit-common";
+import { makeRenderCall, type RPreview, type RRState } from "./replace-render";
+
+interface WithinRefs {
+  from: Anchor;
+  to: Anchor;
+}
+
+export interface WithinPlan {
+  editParams: { remove_from: string; remove_to: string; replacement_lines: string };
+}
+
+function formatWithinRange(start: number, end: number): string {
+  return start === end ? `line ${start}` : `lines ${start}-${end}`;
+}
+
+function offsetLineNumber(rangeLines: string[], offset: number): number {
+  let cursor = 0;
+  for (let index = 0; index < rangeLines.length; index++) {
+    const length = rangeLines[index]!.length;
+    if (offset <= cursor + length) return index + 1;
+    cursor += length + 1;
+  }
+  return rangeLines.length;
+}
+
+function matchOffsets(text: string, oldText: string): number[] {
+  const offsets: number[] = [];
+  let from = 0;
+  for (;;) {
+    const found = text.indexOf(oldText, from);
+    if (found < 0) return offsets;
+    offsets.push(found);
+    from = found + 1;
+  }
+}
+
+function notFoundMessage(displayPath: string, start: number, end: number, fileHashes: string[], fileLines: string[]): string {
+  const rangeLength = end - start + 1;
+  const shownCount = Math.min(rangeLength, MAX_RANGE_STALE_LINES);
+  const shown = fmtRegion(fileHashes.slice(start - 1, start - 1 + shownCount), fileLines.slice(start - 1, start - 1 + shownCount));
+  const more = rangeLength > shownCount ? `\n[The range has ${rangeLength} lines; showing the first ${shownCount}.]` : "";
+  return `[E_SUBSTRING_NOT_FOUND] "replace_old" was not found in ${formatWithinRange(start, end)} of ${displayPath}. Current rows:\n\n${shown}${more}\n\nCopy replace_old exactly from the served row (comparison uses LF breaks and excludes the last line's terminator) and retry.`;
+}
+
+function ambiguousMessage(displayPath: string, start: number, end: number, matchLines: number[]): string {
+  const shownCount = 8;
+  const shown = matchLines.slice(0, shownCount).join(", ");
+  const more = matchLines.length > shownCount ? ` (+${matchLines.length - shownCount} more)` : "";
+  return `[E_SUBSTRING_AMBIGUOUS] "replace_old" occurs ${matchLines.length} times in ${formatWithinRange(start, end)} of ${displayPath} (matching lines ${shown}${more}). Narrow replace_from/replace_to to one line, or extend replace_old so it matches exactly once.`;
+}
+
+export function parseWithinAnchors(req: ReplaceWithinReq): { refs: WithinRefs; warnings: string[] } {
+  const warnings: string[] = [];
+  const from = stripAnchorRow(req.replace_from.trim(), "replace_from entry", warnings);
+  const to = stripAnchorRow(req.replace_to.trim(), "replace_to entry", warnings);
+  return { refs: { from: parseHashRef(from), to: parseHashRef(to) }, warnings };
+}
+
+export function buildReplaceWithinEdit(req: ReplaceWithinReq, refs: WithinRefs, preload: NormFile, displayPath: string): WithinPlan {
+  const fileLines = splitLines(preload.normalized);
+  const fromLine = resolveAnchorLine(refs.from, fileLines, preload.fileHashes, displayPath);
+  const toLine = resolveAnchorLine(refs.to, fileLines, preload.fileHashes, displayPath);
+  const start = Math.min(fromLine, toLine);
+  const end = Math.max(fromLine, toLine);
+  const rangeLines = fileLines.slice(start - 1, end);
+  const rangeText = rangeLines.join("\n");
+  const oldText = toLF(req.replace_old);
+  const offsets = matchOffsets(rangeText, oldText);
+  if (offsets.length === 0) {
+    throw new Error(notFoundMessage(displayPath, start, end, preload.fileHashes, fileLines));
+  }
+  if (offsets.length > 1) {
+    throw new Error(ambiguousMessage(displayPath, start, end, offsets.map((offset) => start - 1 + offsetLineNumber(rangeLines, offset))));
+  }
+  const matchOffset = offsets[0]!;
+  const replacement = rangeText.slice(0, matchOffset) + req.replace_new + rangeText.slice(matchOffset + oldText.length);
+  const startRef = fromLine <= toLine ? refs.from : refs.to;
+  const endRef = fromLine <= toLine ? refs.to : refs.from;
+  return {
+    editParams: {
+      remove_from: startRef.hash,
+      remove_to: endRef.hash,
+      replacement_lines: replacement,
+    },
+  };
+}
+
+export async function replaceWithinPreview(request: unknown, cwd: string, signal?: AbortSignal): Promise<RPreview> {
+  try {
+    const normalized = normalizeReplaceWithinRequest(request);
+    assertReplaceWithinReq(normalized);
+    const req = normalized;
+    const { refs, warnings } = parseWithinAnchors(req);
+    await throwIfStrictInput(warnings);
+    const targetPath = await resolveEditTargetWithRequirement({
+      removeFrom: req.replace_from,
+      removeTo: req.replace_to,
+      providedPath: req.path,
+      cwd,
+    });
+    const preload = await readNormFile(targetPath, cwd, {
+      accessMode: constants.R_OK,
+      maxLines: MAX_HASH_LINES,
+      noPersist: true,
+      allocation: "shadow",
+      signal,
+    });
+    const plan = buildReplaceWithinEdit(req, refs, preload, targetPath);
+    const pipe = await execPipeline(targetPath, plan.editParams, cwd, {
+      accessMode: constants.R_OK,
+      noPersist: true,
+      preloadedNorm: preload,
+      signal,
+    });
+    return previewFromPipe(pipe);
+  } catch (error: unknown) {
+    if (signal?.aborted) throw error;
+    return previewError(error);
+  }
+}
+
+type ReplaceWithinToolDef = ToolDefinition<any, ReplaceDetails, RRState> & { renderShell?: "default" | "self" };
+
+export function buildReplaceWithinToolDef(flags: EditToolFlags = DEFAULT_EDIT_FLAGS): ReplaceWithinToolDef {
+  const prompted = withReplaceWithinPrompts({
+    description: loadP("../prompts/replace-within.md"),
+    snippet: loadP("../prompts/replace-within-snippet.md"),
+    guidelines: loadGuide("../prompts/replace-within-guidelines.md"),
+  }, flags);
+  return {
+    name: "replace_within",
+    label: "Replace Within",
+    description: prompted.description,
+    promptSnippet: prompted.snippet,
+    promptGuidelines: prompted.guidelines,
+    ...editToolBase,
+    prepareArguments: normalizeReplaceWithinRequest,
+    parameters: buildReplaceWithinToolSchema(flags.requirePath),
+    renderCall: makeRenderCall(replaceWithinPreview, {
+      getInput: getReplaceWithinInput,
+      toolName: "replace_within",
+      resolveTarget: (input) => (typeof input.replace_from === "string" ? tryResolveEditTarget(input.replace_from, input.replace_to) : undefined),
+    }),
+    renderResult: editRenderResultWrapper,
+    async execute(_toolCallId, params, signal, _onUpdate, ctx) {
+      return withAnchorSession(ctx, async () => {
+        const normalized = normalizeReplaceWithinRequest(params);
+        assertReplaceWithinReq(normalized);
+        const req = normalized;
+        const { refs, warnings } = parseWithinAnchors(req);
+        await throwIfStrictInput(warnings);
+        const hints = [
+          literalEscapeHint([req.replace_old], "replace_old"),
+          literalEscapeHint([req.replace_new], "replace_new"),
+        ].filter((hint): hint is string => hint !== undefined);
+        const targetPath = await resolveEditTargetWithRequirement({
+          removeFrom: req.replace_from,
+          removeTo: req.replace_to,
+          providedPath: req.path,
+          cwd: ctx.cwd,
+        });
+        return queuedEdit(targetPath, ctx.cwd, signal, async (absolutePath, mutationTargetPath) => {
+          const preload = await readNormFile(targetPath, ctx.cwd, {
+            signal,
+            accessMode: constants.R_OK | constants.W_OK,
+            maxLines: MAX_HASH_LINES,
+          });
+          let plan: WithinPlan;
+          try {
+            plan = buildReplaceWithinEdit(req, refs, preload, targetPath);
+          } catch (error) {
+            await noteAnchorError(preload.absolutePath, error);
+            throw error;
+          }
+          const pipe = await execPipeline(targetPath, plan.editParams, ctx.cwd, {
+            accessMode: constants.R_OK | constants.W_OK,
+            signal,
+            preloadedNorm: preload,
+          });
+          return commitEdit(pipe, {
+            path: pipe.path,
+            absolutePath,
+            mutationTargetPath,
+            editAnchors: [plan.editParams.remove_from, plan.editParams.remove_to],
+            prefixWarnings: [...warnings, ...hints],
+            signal,
+            verb: "replaced",
+            noopNoun: "Replacement",
+          });
+        });
+      });
+    },
+  };
+}
+
+export function regReplaceWithin(pi: ExtensionAPI, flags: EditToolFlags = DEFAULT_EDIT_FLAGS): void {
+  pi.registerTool(buildReplaceWithinToolDef(flags));
+}

package/src/replace.ts

@@ -9,7 +9,7 @@ import {
   type LineEnding,
 } from "./replace-diff";
 import { readNormFile, type NormFile } from "./file-reader";
-import { editToolSchema, buildEditToolSchema, type ReqParams, assertReq, normReq } from "./payload-contract";
+import { editToolSchema, buildEditToolSchema, type ReqParams, type RawReqParams, assertReq, normReq } from "./payload-contract";
 import { literalEscapeHint, splitLines } from "./utils";
 import { loadP, loadGuide } from "./prompts";
 import { type FileIdentity } from "./fs-write";
@@ -83,6 +83,7 @@ export interface ExecPipelineOptions {
   served?: ReadonlyMap<string, string>;
   allowEmpty?: boolean;
   stripWarning?: StripWarningLocation;
+  endingOverrides?: (LineEnding | undefined)[];
 }
 
 export function hashSpan(hashes: string[], from: string, to: string): [number, number] | undefined {
@@ -120,28 +121,35 @@ function countLineChanges(
     totalRemovedLines,
   };
 }
-
-export function buildReplaceHEdit(params: ReqParams): { edit: HEdit; warnings: string[] } {
+export function buildReplaceHEdit(params: RawReqParams): { edit: HEdit; warnings: string[] } {
   const editWarnings: string[] = [];
-  const edit = resEdit(
-    {
-      remove_from: params.remove_from,
-      remove_to: params.remove_to,
-      replacement_lines: params.replacement_lines,
-    },
-    editWarnings,
-  );
+  const anchors = { remove_from: params.remove_from, remove_to: params.remove_to };
+  const edit = typeof params.replacement_lines === "string"
+    ? resEdit({ ...anchors, replacement_lines: params.replacement_lines }, editWarnings)
+    : resEdit({ ...anchors, replacement_lines: params.replacement_lines }, editWarnings);
   return { edit, warnings: editWarnings };
 }
 
+function withEndingOverrides(edit: HEdit, overrides: (LineEnding | undefined)[] | undefined): HEdit {
+  if (overrides === undefined) return edit;
+  const length = Math.max(edit.content_separators?.length ?? 0, overrides.length);
+  const separators: (LineEnding | undefined)[] = new Array(length);
+  for (let index = 0; index < length; index++) {
+    separators[index] = overrides[index] ?? edit.content_separators?.[index];
+  }
+  if (separators.every((ending) => ending === undefined)) return edit;
+  return { ...edit, content_separators: separators };
+}
+
 export async function execPipeline(
   targetPath: string,
-  params: ReqParams,
+  params: RawReqParams,
   cwd: string,
   options?: ExecPipelineOptions,
 ): Promise<PipelineResult> {
 
   const { edit, warnings: editWarnings } = buildReplaceHEdit(params);
+  const anchoredEdit = withEndingOverrides(edit, options?.endingOverrides);
   const hashStore = options?.store ?? await loadHashStore();
   const preResolvedPath = await resolveTarget(toCwd(targetPath, cwd));
   const served = options?.served ?? servedForPath(preResolvedPath);
@@ -154,7 +162,7 @@ export async function execPipeline(
   try {
     anchorResult = applyEdit(
       originalNormalized,
-      edit,
+      anchoredEdit,
       options?.signal,
       originalHashes,
       displayPath,
@@ -202,12 +210,15 @@ export async function execPipeline(
     totalRemovedLines,
     identity,
     ...(pipeSpans ? { spans: pipeSpans } : {}),
-    ...(edit.content_separators !== undefined ? { contentSeparators: edit.content_separators } : {}),
+    ...(anchoredEdit.content_separators !== undefined ? { contentSeparators: anchoredEdit.content_separators } : {}),
   };
 }
 
 export function previewFromPipe(pipe: PipelineResult): RPreview {
   if (pipe.originalNormalized === pipe.result) {
+    if (pipe.contentSeparators !== undefined) {
+      return { diff: "", path: pipe.path };
+    }
     return {
       error: `No changes made to ${pipe.path}. The edit produced identical content.`,
       path: pipe.path,
@@ -274,7 +285,7 @@ export function buildToolDef(flags: EditToolFlags = DEFAULT_EDIT_FLAGS): ToolDef
         const canonical = normReq(params);
         assertReq(canonical);
         const normalizedParams = canonical;
-        const literalEscape = literalEscapeHint(normalizedParams.replacement_lines, "replacement_lines");
+        const literalEscape = literalEscapeHint([normalizedParams.replacement_lines], "replacement_lines");
         const targetPath = await resolveEditTargetWithRequirement({
           removeFrom: normalizedParams.remove_from,
           removeTo: normalizedParams.remove_to,

package/src/utils.ts

@@ -1,5 +1,7 @@
 import { NUL_CONTENT_MSG, MAX_BYTES } from "./constants";
 import { HASH_CLASS } from "./hashline/alphabet";
+import { splitWithEndings } from "./line-endings";
+import type { LineEnding } from "./normalize";
 
 export function isRec(value: unknown): value is Record<string, unknown> {
 	return typeof value === "object" && value !== null && !Array.isArray(value);
@@ -342,24 +344,36 @@ export function decodeStringArray(value: unknown, warnings?: string[], label = "
 	return undefined;
 }
 
-function normalizeLineFieldValue(value: unknown): string[] | undefined {
-	const candidate = typeof value === "string"
-		? value
-		: Array.isArray(value) && value.length === 1 && typeof value[0] === "string"
-			? value[0]
-			: undefined;
-	if (candidate === undefined) return undefined;
-	const decoded = decodeStringArray(candidate);
-	if (decoded !== undefined) return decoded;
-	if (/^\[\s*\]$/.test(stripTrailingMemberCall(stripCodeFence(candidate)))) return [];
-	return [candidate];
+function legacyLinesToText(lines: string[]): string {
+	const decoded = decodeStringArray(lines) ?? lines;
+	const parsedLines: string[] = [];
+	const parsedSeparators: (LineEnding | undefined)[] = [];
+	for (const element of decoded) {
+		const parsed = splitWithEndings(element);
+		const lineCount = element.endsWith("\n") || element.endsWith("\r") ? parsed.lines.length - 1 : parsed.lines.length;
+		for (let index = 0; index < lineCount; index++) {
+			parsedLines.push(parsed.lines[index]!);
+			parsedSeparators.push(parsed.endings[index]);
+		}
+	}
+	let text = "";
+	for (let index = 0; index < parsedLines.length; index++) {
+		const line = parsedLines[index]!;
+		const separator = parsedSeparators[index];
+		text += line;
+		if (separator !== undefined) text += separator;
+		else if (index < parsedLines.length - 1) text += "\n";
+		else if (line === "") text += "\n";
+	}
+	return text;
 }
 
 function normalizeEditLines(record: Record<string, unknown>): void {
 	for (const key of ["replacement_lines", "lines"]) {
-		if (!(key in record)) continue;
-		const lines = normalizeLineFieldValue(record[key]);
-		if (lines !== undefined) record[key] = lines;
+		const value = record[key];
+		if (Array.isArray(value) && value.every((entry): entry is string => typeof entry === "string")) {
+			record[key] = legacyLinesToText(value);
+		}
 	}
 }
 

package/prompts/grep-guidelines.md

@@ -1,2 +0,0 @@
-- `anchor_grep`: hits and `context` rows come back as `lineNumber │ anchor│content` — target them with `replace`/`insert` directly; `lineNumber` enables jump-to-line.
-- `anchor_grep`: binary/image files are skipped silently.