pi-hashline-edit-pro 0.13.3 → 0.14.0

package/src/config.ts

@@ -0,0 +1,97 @@
+import { readFileSync } from "fs";
+import { homedir } from "os";
+import { join } from "path";
+import { readFile, writeFile, mkdir } from "fs/promises";
+
+export type ReplaceMode = "bulk" | "flat";
+
+export interface Config {
+  replaceMode: ReplaceMode;
+  autoRead: boolean;
+}
+
+const DEFAULT_CONFIG: Config = {
+  replaceMode: "bulk",
+  autoRead: false,
+};
+
+/** Compute config path lazily so tests can override HOME before calling. */
+function configPath(): string {
+  return join(homedir(), ".config", "pi-hashline-edit-pro", "config.json");
+}
+
+function configDir(): string {
+  return join(homedir(), ".config", "pi-hashline-edit-pro");
+}
+
+export async function readConfig(): Promise<Config> {
+  try {
+    const content = await readFile(configPath(), "utf-8");
+    const parsed = JSON.parse(content) as Partial<Config>;
+    return {
+      replaceMode: parsed.replaceMode === "flat" ? "flat" : "bulk",
+      autoRead: parsed.autoRead === true,
+    };
+  } catch {
+    return { ...DEFAULT_CONFIG };
+  }
+}
+
+export function readConfigSync(): Config {
+  try {
+    const content = readFileSync(configPath(), "utf-8");
+    const parsed = JSON.parse(content) as Partial<Config>;
+    return {
+      replaceMode: parsed.replaceMode === "flat" ? "flat" : "bulk",
+      autoRead: parsed.autoRead === true,
+    };
+  } catch {
+    return { ...DEFAULT_CONFIG };
+  }
+}
+
+export async function writeConfig(config: Config): Promise<void> {
+  await mkdir(configDir(), { recursive: true });
+  await writeFile(configPath(), JSON.stringify(config, null, 2), "utf-8");
+}
+
+export async function readReplaceMode(): Promise<ReplaceMode> {
+  const config = await readConfig();
+  return config.replaceMode;
+}
+
+export async function writeReplaceMode(mode: ReplaceMode): Promise<void> {
+  const config = await readConfig();
+  config.replaceMode = mode;
+  await writeConfig(config);
+}
+
+export async function toggleReplaceMode(): Promise<ReplaceMode> {
+  const config = await readConfig();
+  config.replaceMode = config.replaceMode === "bulk" ? "flat" : "bulk";
+  await writeConfig(config);
+  return config.replaceMode;
+}
+
+export async function readAutoRead(): Promise<boolean> {
+  const config = await readConfig();
+  return config.autoRead;
+}
+
+export function readAutoReadSync(): boolean {
+  const config = readConfigSync();
+  return config.autoRead;
+}
+
+export async function writeAutoRead(value: boolean): Promise<void> {
+  const config = await readConfig();
+  config.autoRead = value;
+  await writeConfig(config);
+}
+
+export async function toggleAutoRead(): Promise<boolean> {
+  const config = await readConfig();
+  config.autoRead = !config.autoRead;
+  await writeConfig(config);
+  return config.autoRead;
+}

package/src/hashline/apply.ts

@@ -92,11 +92,13 @@ function resToSpan(
     return null;
   }
 
+  const label = descEdit(edit);
+
   if (edit.content_lines.length > 0) {
     return {
       kind: "replace",
       index,
-      label: descEdit(edit),
+      label,
       start: lineStarts[startLine - 1]!,
       end: lineStarts[endLine - 1]! + fileLines[endLine - 1]!.length,
       replacement: edit.content_lines.join("\n"),
@@ -107,7 +109,7 @@ function resToSpan(
     return {
       kind: "replace",
       index,
-      label: descEdit(edit),
+      label,
       start: 0,
       end: content.length,
       replacement: "",
@@ -118,7 +120,7 @@ function resToSpan(
     return {
       kind: "replace",
       index,
-      label: descEdit(edit),
+      label,
       start: lineStarts[startLine - 1]!,
       end: lineStarts[endLine]!,
       replacement: "",
@@ -128,7 +130,7 @@ function resToSpan(
   return {
     kind: "replace",
     index,
-    label: descEdit(edit),
+    label,
     start: Math.max(0, lineStarts[startLine - 1]! - 1),
     end: lineStarts[endLine - 1]! + fileLines[endLine - 1]!.length,
     replacement: "",

package/src/prompts.ts

@@ -1,19 +1,25 @@
 import { readFileSync } from "fs";
 
 export function loadP(relativePath: string, replacements?: Record<string, string>): string {
-	let content = readFileSync(new URL(relativePath, import.meta.url), "utf-8").trim();
-	if (replacements) {
-		for (const [key, value] of Object.entries(replacements)) {
-			content = content.replaceAll(`{{${key}}}`, value);
-		}
-	}
-	return content;
+  let content = readFileSync(new URL(relativePath, import.meta.url), "utf-8").trim();
+  if (replacements) {
+    for (const [key, value] of Object.entries(replacements)) {
+      content = content.replaceAll(`{{${key}}}`, value);
+    }
+  }
+  return content;
 }
 
-export function loadGuide(relativePath: string): string[] {
-	return readFileSync(new URL(relativePath, import.meta.url), "utf-8")
-		.split("\n")
-		.map((line) => line.trim())
-		.filter((line) => line.startsWith("- "))
-		.map((line) => line.slice(2));
+export function loadGuide(relativePath: string, replacements?: Record<string, string>): string[] {
+  let content = readFileSync(new URL(relativePath, import.meta.url), "utf-8");
+  if (replacements) {
+    for (const [key, value] of Object.entries(replacements)) {
+      content = content.replaceAll(`{{${key}}}`, value);
+    }
+  }
+  return content
+    .split("\n")
+    .map((line) => line.trim())
+    .filter((line) => line.startsWith("- "))
+    .map((line) => line.slice(2));
 }

package/src/replace-flat.ts

@@ -0,0 +1,313 @@
+import { Markdown, Text } from "@earendil-works/pi-tui";
+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 {
+  genDiff,
+  restoreEndings,
+} from "./replace-diff";
+import { readNormFile } from "./file-reader";
+import { normReq } from "./replace-normalize";
+import { isRec } from "./utils";
+import { MAX_HASH_LINES } from "./constants";
+import { resolveTarget, writeAtomic } from "./fs-write";
+import {
+  applyEdits,
+  lineHashes,
+  resEdits,
+  type HTEdit,
+} from "./hashline";
+import { toCwd } from "./path-utils";
+import { abortIf } from "./runtime";
+import { fileSnap } from "./snapshot";
+import {
+  buildChanged,
+  buildNoop,
+  type RMeta,
+  type RMetrics,
+} from "./replace-response";
+import {
+  buildAppliedText,
+  mkMdTheme,
+  fmtCall,
+  fmtResultMd,
+  getPreviewInput,
+  getResultText,
+  isApplied,
+  type RPreview,
+  type RRState,
+} from "./replace-render";
+import { loadP, loadGuide } from "./prompts";
+import { execPipeline, compPreview, type ReplaceDetails } from "./replace";
+import { readAutoReadSync } from "./config";
+
+const contentLinesSchema = Type.Array(Type.String(), {
+  description:
+    "literal replacement file content, one string per line. Must not include the HASH│ prefix from read output.",
+});
+
+const hashRangeInclSchema = Type.Array(
+  Type.String({ description: "anchor (3-char HASH)" }),
+  {
+    description: "inclusive hash range to replace [start_hash, end_hash]. Each element must be the 3-character hash anchor only; do not include the │ separator or line content.",
+    minItems: 2,
+    maxItems: 2,
+  },
+);
+
+/**
+ * Flat-mode schema: hash_range_inclusive and content_lines are at the top
+ * level instead of inside a "changes" array. Only a single edit is supported
+ * per call (no bulk changes).
+ */
+export const flatEditToolSchema = Type.Object(
+  {
+    path: Type.String({ description: "path" }),
+    hash_range_inclusive: hashRangeInclSchema,
+    content_lines: contentLinesSchema,
+  },
+  { additionalProperties: false },
+);
+
+type ToolDef = ToolDefinition<
+  typeof flatEditToolSchema,
+  ReplaceDetails,
+  RRState
+> & { renderShell?: "default" | "self" };
+
+function reuseText(context: any, content: string): Text {
+  const t = context.lastComponent instanceof Text
+    ? context.lastComponent
+    : new Text("", 0, 0);
+  t.setText(content);
+  return t;
+}
+
+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 buildToolDef(): ToolDef {
+  const autoRead = readAutoReadSync();
+  const readGuidance = autoRead
+    ? "Anchors are provided automatically after write operations when auto-read is enabled."
+    : "Call `read` to get fresh anchors for follow-up edits.";
+
+  const E_DESC = loadP("../prompts/replace-flat.md", {
+    AUTO_READ_GUIDANCE: readGuidance,
+  });
+  const E_SNIPPET = loadP("../prompts/replace-flat-snippet.md");
+  const E_GUIDE = loadGuide("../prompts/replace-flat-guidelines.md", {
+    AUTO_READ_GUIDANCE: readGuidance,
+  });
+
+  return {
+    name: "replace",
+    label: "Replace",
+    description: E_DESC,
+    parameters: flatEditToolSchema,
+    promptSnippet: E_SNIPPET,
+    promptGuidelines: E_GUIDE,
+    prepareArguments: (args: unknown) => {
+      // Minimal normalization: file_path → path, JSON string parsing.
+      // The flat-to-canonical conversion happens in execute().
+      if (!isRec(args)) return args as any;
+      const record = { ...args };
+      if (typeof record.path !== "string" && typeof record.file_path === "string") {
+        record.path = record.file_path;
+        delete record.file_path;
+      }
+      if (typeof record.hash_range_inclusive === "string") {
+        try { record.hash_range_inclusive = JSON.parse(record.hash_range_inclusive as string); } catch { /* keep as-is */ }
+      }
+      if (typeof record.content_lines === "string") {
+        try { record.content_lines = JSON.parse(record.content_lines as string); } catch { /* keep as-is */ }
+      }
+      return record as any;
+    },
+    renderShell: "default",
+    renderCall(args, theme, context) {
+      const previewInput = getPreviewInput(args);
+      if (context.executionStarted) {
+        context.state.argsKey = undefined;
+        context.state.preview = undefined;
+        context.state.previewGeneration =
+          (context.state.previewGeneration ?? 0) + 1;
+      } else if (!context.argsComplete || !previewInput) {
+        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) {
+          context.state.argsKey = argsKey;
+          context.state.preview = undefined;
+          const previewGeneration = (context.state.previewGeneration ?? 0) + 1;
+          context.state.previewGeneration = previewGeneration;
+          compPreview(previewInput, context.cwd)
+            .then((preview) => {
+              if (
+                context.state.argsKey === argsKey &&
+                context.state.previewGeneration === previewGeneration
+              ) {
+                context.state.preview = preview;
+                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();
+              }
+            });
+        }
+      }
+      const text =
+        (context.lastComponent as Text | undefined) ?? new Text("", 0, 0);
+      text.setText(
+        fmtCall(
+          getPreviewInput(args) ?? undefined,
+          context.state as RRState,
+          context.expanded,
+          theme,
+        ),
+      );
+      return text;
+    },
+
+    renderResult(result, { isPartial }, theme, context) {
+      if (isPartial) {
+        return reuseText(context, theme.fg("warning", "Editing..."));
+      }
+
+      const typedResult = result as {
+        content?: Array<{ type: string; text?: string }>;
+        details?: ReplaceDetails;
+      };
+      const renderedText = getResultText(typedResult);
+
+      const renderState = context.state as RRState | undefined;
+      if (renderState) {
+        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(typedResult.details)) {
+        const appliedText = buildAppliedText(renderedText, typedResult.details, theme);
+        return appliedText ? reuseText(context, appliedText) : new Text("", 0, 0);
+      }
+
+      if (!renderedText) return new Text("", 0, 0);
+      return reuseMarkdown(context, fmtResultMd(renderedText), theme);
+    },
+
+    async execute(_toolCallId, params, signal, _onUpdate, ctx) {
+      // Wrap flat params into canonical shape for the pipeline
+      const canonical = normReq({
+        path: params.path,
+        changes: [{
+          hash_range_inclusive: params.hash_range_inclusive,
+          content_lines: params.content_lines,
+        }],
+      });
+      const normalizedParams = canonical as { path: string; changes: HTEdit[] };
+      const path = normalizedParams.path;
+      const absolutePath = toCwd(path, ctx.cwd);
+      const mutationTargetPath = await resolveTarget(absolutePath);
+      return withFileMutationQueue(mutationTargetPath, async () => {
+        abortIf(signal);
+
+        const {
+          originalNormalized,
+          result,
+          bom,
+          originalEnding,
+          hadUtf8DecodeErrors,
+          warnings,
+          noopEdits,
+          firstChangedLine,
+          lastChangedLine,
+          resultHashes,
+        } = await execPipeline(
+          normalizedParams,
+          ctx.cwd,
+          constants.R_OK | constants.W_OK,
+          signal,
+        );
+
+        const editsAttempted = 1; // flat mode: exactly one edit per call
+
+        if (originalNormalized === result) {
+          const noopSnapshotId = (await fileSnap(absolutePath)).snapshotId;
+          return buildNoop({
+            path,
+            noopEdits,
+            snapshotId: noopSnapshotId,
+            editMeta: {
+              editsAttempted,
+              noopEditsCount: noopEdits?.length ?? 0,
+            },
+            warnings,
+          });
+        }
+
+        if (hadUtf8DecodeErrors) {
+          warnings.push(
+            "Non-UTF-8 bytes were shown as U+FFFD; this edit rewrote the file as UTF-8.",
+          );
+        }
+
+        abortIf(signal);
+        await writeAtomic(
+          absolutePath,
+          bom + restoreEndings(result, originalEnding),
+        );
+        const updatedSnapshotId = (await fileSnap(absolutePath))
+          .snapshotId;
+
+        const editMeta: RMeta = {
+          editsAttempted,
+          noopEditsCount: noopEdits?.length ?? 0,
+          firstChangedLine,
+          lastChangedLine,
+        };
+
+        const successInput = {
+          path,
+          originalNormalized,
+          result,
+          resultHashes,
+          warnings,
+          snapshotId: updatedSnapshotId,
+          editMeta,
+        };
+
+        return buildChanged(successInput);
+      });
+    },
+  };
+}
+
+export function regReplaceFlat(pi: ExtensionAPI): void {
+  pi.registerTool(buildToolDef());
+}

package/src/replace-normalize.ts

@@ -27,6 +27,32 @@ function coerceEditArray(items: unknown[]): unknown[] {
     });
 }
 
+/**
+ * Normalizes a field from `from` to `to`: JSON-string arrays → real arrays,
+ * single objects → wrapped in array. Shared by the `changes` and `edits`
+ * normalization branches.
+ */
+function normalizeField(
+  record: Record<string, unknown>,
+  from: string,
+  to: string,
+): void {
+  if (!has(record, from)) return;
+  const raw = tryParseJSON(record[from], Array.isArray) ?? record[from];
+  if (Array.isArray(raw)) {
+    record[to] = coerceEditArray(raw);
+  } else {
+    const single =
+      typeof raw === "string"
+        ? tryParseJSON(raw, isRec)
+        : isRec(raw)
+          ? raw
+          : undefined;
+    if (single) record[to] = coerceEditArray([single]);
+  }
+  if (from !== to) delete record[from];
+}
+
 export function normReq(input: unknown): unknown {
   if (!isRec(input)) {
     return input;
@@ -39,32 +65,26 @@ export function normReq(input: unknown): unknown {
     delete record.file_path;
   }
 
-  const hasChangesField = has(record, "changes");
-  const hasEditsField = has(record, "edits");
+  normalizeField(record, "changes", "changes");
+  normalizeField(record, "edits", "changes");
 
-if (hasChangesField) {
-    const raw = tryParseJSON(record.changes, Array.isArray) ?? record.changes;
-    if (Array.isArray(raw)) {
-        record.changes = coerceEditArray(raw);
-    } else {
-        // Single object (JSON string or literal) → wrap in array
-        const single = typeof raw === "string"
-            ? tryParseJSON(raw, isRec)
-            : isRec(raw) ? raw : undefined;
-        if (single) record.changes = coerceEditArray([single]);
-    }
-} else if (hasEditsField) {
-    const raw = tryParseJSON(record.edits, Array.isArray) ?? record.edits;
-    if (Array.isArray(raw)) {
-        record.changes = coerceEditArray(raw);
-    } else {
-        const single = typeof raw === "string"
-            ? tryParseJSON(raw, isRec)
-            : isRec(raw) ? raw : undefined;
-        if (single) record.changes = coerceEditArray([single]);
+  // Handle flat format: hash_range_inclusive and content_lines at top level
+  // (no changes array). Wrap them into a single-element changes array.
+  if (!Array.isArray(record.changes) && has(record, "hash_range_inclusive") && has(record, "content_lines")) {
+    const hri = tryParseJSON(record.hash_range_inclusive, (v): v is string[] =>
+      Array.isArray(v) && v.length === 2 && v.every((i) => typeof i === "string")
+    ) ?? record.hash_range_inclusive;
+
+    const cl = tryParseJSON(record.content_lines, (v): v is string[] =>
+      Array.isArray(v) && v.every((i) => typeof i === "string")
+    ) ?? record.content_lines;
+
+    if (Array.isArray(hri) && Array.isArray(cl)) {
+      record.changes = [{ hash_range_inclusive: hri, content_lines: cl }];
+      delete record.hash_range_inclusive;
+      delete record.content_lines;
     }
-    delete record.edits;
-}
+  }
 
   return record;
 }

package/src/replace-response.ts

@@ -142,7 +142,7 @@ export function buildNoop(input: NoopInput): TResult {
 }
 
 export function buildChanged(input: SuccessInput): TResult {
-	const { result, warnings, snapshotId, originalNormalized, editMeta } = input;
+	const { path, result, warnings, snapshotId, originalNormalized, editMeta } = input;
 
 	const resultLines = visLines(result);
 	const resultHashes = input.resultHashes ?? lineHashes(result);
@@ -150,9 +150,12 @@ export function buildChanged(input: SuccessInput): TResult {
 	const addedLines = cntDiff(diffResult.diff, "+");
 	const removedLines = cntDiff(diffResult.diff, "-");
 	const warningsBlock = warnBlock(warnings);
+	const successPrefix = `Successfully replaced in ${path}.`;
 	const text = resultLines.length === 0
 		? "File is empty. Use replace to insert content."
-		: warningsBlock.trimStart();
+		: warningsBlock
+			? `${successPrefix}${warningsBlock}`
+			: successPrefix;
 
 	const metrics = buildM({
 		classification: "applied",