pi-hashline-edit-pro 4.0.1 → 4.2.0

package/src/config-ui.ts

@@ -0,0 +1,108 @@
+import { Key, matchesKey, visibleWidth } from "@earendil-works/pi-tui";
+import type { Theme } from "@earendil-works/pi-coding-agent";
+import { readConfig, type Config } from "./config";
+
+export type ConfigToggleKey = "autoRead" | "anchorGrepEnabled" | "requirePath" | "strictInput" | "boundaryDedupMode";
+
+export interface ConfigRow {
+  key: ConfigToggleKey;
+  label: string;
+  hint: string;
+  enabled: boolean;
+  mode?: string;
+  cycle?: string[];
+}
+
+export function configRows(config: Config): ConfigRow[] {
+  return [
+    { key: "autoRead", label: "Auto-read", hint: "Anchors after write + post-edit diffs", enabled: config.autoRead !== false },
+    { key: "anchorGrepEnabled", label: "Anchor grep", hint: "anchor_grep tool (builtin grep off while on)", enabled: config.anchorGrepEnabled === true },
+    { key: "requirePath", label: "Require path", hint: "replace + insert need path (RPC visibility)", enabled: config.requirePath === true },
+    { key: "strictInput", label: "Strict input", hint: "Reject auto-fixable slips instead of warnings", enabled: config.strictInput === true },
+    { key: "boundaryDedupMode", label: "Boundary dedup", hint: "Strip edge lines: on, strict (reject), off (literal)", enabled: (config.boundaryDedupMode ?? "on") !== "off", mode: config.boundaryDedupMode ?? "on", cycle: ["on", "strict", "off"] },
+  ];
+}
+
+function padRow(theme: Theme, innerWidth: number, content: string): string {
+  const padded = content + " ".repeat(Math.max(0, innerWidth - visibleWidth(content)));
+  return theme.fg("border", "│") + padded + theme.fg("border", "│");
+}
+
+function modeBox(theme: Theme, mode: string): string {
+  if (mode === "off") return theme.fg("dim", `[${mode}]`);
+  if (mode === "strict") return theme.fg("accent", `[${mode}]`);
+  return theme.fg("success", `[${mode}]`);
+}
+
+export class HashlineConfigOverlay {
+  private rows: ConfigRow[];
+  private selected = 0;
+
+  constructor(private readonly opts: { tui: { requestRender(force?: boolean): void }; theme: Theme; done: () => void; onToggle: (key: ConfigToggleKey) => Promise<void> }) {
+    this.rows = [];
+  }
+
+  async load(): Promise<void> {
+    this.rows = configRows(await readConfig());
+  }
+
+  private toggleSelected(): void {
+    const row = this.rows[this.selected];
+    if (!row) return;
+    if (row.cycle && row.mode !== undefined) {
+      const next = row.cycle[(row.cycle.indexOf(row.mode) + 1) % row.cycle.length] ?? row.cycle[0];
+      if (next === undefined) return;
+      row.mode = next;
+      row.enabled = next !== "off";
+    } else {
+      row.enabled = !row.enabled;
+    }
+    this.opts.tui.requestRender(true);
+    void this.opts.onToggle(row.key).then(async () => {
+      this.rows = configRows(await readConfig());
+      this.opts.tui.requestRender(true);
+    }).catch((error: unknown) => {
+      console.error("Failed to toggle hashline setting:", error);
+    });
+  }
+
+  handleInput(data: string): void {
+    if (matchesKey(data, Key.up) || data === "k") {
+      this.selected = (this.selected + this.rows.length - 1) % this.rows.length;
+      return;
+    }
+    if (matchesKey(data, Key.down) || data === "j") {
+      this.selected = (this.selected + 1) % this.rows.length;
+      return;
+    }
+    if (matchesKey(data, Key.space) || matchesKey(data, Key.enter) || data === " " || data === "\r" || data === "\n") {
+      this.toggleSelected();
+      return;
+    }
+    if (matchesKey(data, Key.escape) || data === "q") {
+      this.opts.done();
+    }
+  }
+
+  invalidate(): void {
+  }
+
+  render(width: number): string[] {
+    const theme = this.opts.theme;
+    const innerWidth = width - 2;
+    const lines: string[] = [];
+    lines.push(theme.fg("border", `╭${"─".repeat(innerWidth)}╮`));
+    lines.push(padRow(theme, innerWidth, ` ${theme.fg("accent", theme.bold("Hashline Config"))}`));
+    lines.push(theme.fg("border", `├${"─".repeat(innerWidth)}┤`));
+    this.rows.forEach((row, index) => {
+      const cursor = index === this.selected ? theme.fg("accent", "> ") : "  ";
+      const box = row.mode !== undefined ? modeBox(theme, row.mode) : row.enabled ? theme.fg("success", "[x]") : theme.fg("dim", "[ ]");
+      const label = index === this.selected ? theme.fg("accent", theme.bold(row.label)) : row.label;
+      lines.push(padRow(theme, innerWidth, `${cursor}${box} ${label} ${theme.fg("dim", `— ${row.hint}`)}`));
+    });
+    lines.push(theme.fg("border", `├${"─".repeat(innerWidth)}┤`));
+    lines.push(padRow(theme, innerWidth, theme.fg("dim", " ↑↓ navigate · space toggle · q close")));
+    lines.push(theme.fg("border", `╰${"─".repeat(innerWidth)}╯`));
+    return lines;
+  }
+}

package/src/config.ts

@@ -3,16 +3,33 @@ import { configPath } from "./paths";
 import { errCode, isRec } from "./utils";
 import { writeAtomic } from "./fs-write";
 
+export type BoundaryDedupMode = "on" | "off" | "strict";
+
 export interface Config {
   autoRead: boolean;
   anchorGrepEnabled: boolean;
+  requirePath?: boolean;
+  strictInput?: boolean;
+  boundaryDedupMode?: BoundaryDedupMode;
 }
 
 const DEFAULT_CONFIG: Config = {
   autoRead: true,
-  anchorGrepEnabled: false
+  anchorGrepEnabled: true,
+  requirePath: false,
+  strictInput: false,
+  boundaryDedupMode: "on"
 };
 
+const BOUNDARY_DEDUP_MODES: BoundaryDedupMode[] = ["on", "strict", "off"];
+
+function parseBoundaryDedupMode(mode: unknown, legacy: unknown): BoundaryDedupMode {
+  if (mode === "on" || mode === "strict" || mode === "off") return mode;
+  if (legacy === true) return "on";
+  if (legacy === false) return "off";
+  return DEFAULT_CONFIG.boundaryDedupMode ?? "on";
+}
+
 function parseConfig(content: string): Config {
   const parsed = JSON.parse(content) as unknown;
   const autoRead = isRec(parsed) ? parsed.autoRead : undefined;
@@ -20,9 +37,16 @@ function parseConfig(content: string): Config {
     throw new Error("config.json must be an object with a boolean autoRead field");
   }
   const anchorGrepEnabled = isRec(parsed) ? parsed.anchorGrepEnabled : undefined;
+  const requirePath = isRec(parsed) ? parsed.requirePath : undefined;
+  const strictInput = isRec(parsed) ? parsed.strictInput : undefined;
+  const boundaryDedupMode = isRec(parsed) ? parsed.boundaryDedupMode : undefined;
+  const legacyBoundaryDedup = isRec(parsed) ? parsed.boundaryDedupEnabled : undefined;
   return {
     autoRead,
     anchorGrepEnabled: typeof anchorGrepEnabled === "boolean" ? anchorGrepEnabled : DEFAULT_CONFIG.anchorGrepEnabled,
+    requirePath: typeof requirePath === "boolean" ? requirePath : DEFAULT_CONFIG.requirePath,
+    strictInput: typeof strictInput === "boolean" ? strictInput : DEFAULT_CONFIG.strictInput,
+    boundaryDedupMode: parseBoundaryDedupMode(boundaryDedupMode, legacyBoundaryDedup),
   };
 }
 
@@ -56,3 +80,26 @@ export async function toggleAnchorGrep(): Promise<boolean> {
   await writeConfig(config);
   return config.anchorGrepEnabled;
 }
+
+export async function toggleRequirePath(): Promise<boolean> {
+  const config = await readConfig();
+  config.requirePath = !config.requirePath;
+  await writeConfig(config);
+  return config.requirePath;
+}
+
+export async function toggleStrictInput(): Promise<boolean> {
+  const config = await readConfig();
+  config.strictInput = !(config.strictInput === true);
+  await writeConfig(config);
+  return config.strictInput === true;
+}
+
+export async function cycleBoundaryDedupMode(): Promise<BoundaryDedupMode> {
+  const config = await readConfig();
+  const current = config.boundaryDedupMode ?? "on";
+  const next = BOUNDARY_DEDUP_MODES[(BOUNDARY_DEDUP_MODES.indexOf(current) + 1) % BOUNDARY_DEDUP_MODES.length] ?? "on";
+  config.boundaryDedupMode = next;
+  await writeConfig(config);
+  return next;
+}

package/src/edit-common.ts

@@ -3,11 +3,84 @@ import { resolveInCwd } from "./fs-write";
 import { abortIf, makePrepareArguments } from "./utils";
 import { ownerOf } from "./anchor-registry";
 import { parseHashRef, stripAnchorRow } from "./hashline";
+import { readConfig, type BoundaryDedupMode } from "./config";
 import { makeRenderCall, renderEditResult, type RPreview, type FgT } from "./replace-render";
 import type { ReplaceDetails } from "./replace";
-
 export const editPrepare = makePrepareArguments();
 
+export interface EditToolFlags {
+  requirePath: boolean;
+  strictInput: boolean;
+  boundaryDedupMode: BoundaryDedupMode;
+  autoRead: boolean;
+}
+
+export const DEFAULT_EDIT_FLAGS: EditToolFlags = {
+  requirePath: false,
+  strictInput: false,
+  boundaryDedupMode: "on",
+  autoRead: true
+};
+
+export async function currentEditFlags(): Promise<EditToolFlags> {
+  const config = await readConfig();
+  return {
+    requirePath: config.requirePath === true,
+    strictInput: config.strictInput === true,
+    boundaryDedupMode: config.boundaryDedupMode ?? "on",
+    autoRead: config.autoRead !== false
+  };
+}
+
+export function withReplacePrompts(base: { description: string; snippet: string; guidelines: string[] }, flags: EditToolFlags): { description: string; snippet: string; guidelines: string[] } {
+  let description = base.description;
+  const snippetParts = [base.snippet];
+  let guidelines = [...base.guidelines];
+  if (!flags.autoRead) {
+    description = description.replace(" Anchor follow-up edits on the `+anchor│` and ` anchor│` rows of the post-edit diff instead of re-reading.", "");
+    guidelines = guidelines.map((guideline) => guideline.includes("post-edit diff") ? "`replace`: one batch per file per turn; verify each result before the next edit on that file." : guideline);
+  }
+  const descriptionParts = [description];
+  if (flags.requirePath) {
+    descriptionParts.push("Also give `path` matching the file the anchors were served for; it is required and must match anchor ownership.");
+    snippetParts.push("; include `path` (required)");
+    guidelines.push("`replace`: include `path` matching the file the anchors were served for; it is required.");
+  }
+  if (flags.strictInput) {
+    descriptionParts.push("Strict-input mode is on: auto-fixable slips are rejected instead of fixed with warnings.");
+    guidelines.push("`replace`: strict-input is on: auto-fixable slips are rejected instead of fixed.");
+  }
+  if (flags.boundaryDedupMode === "off") {
+    descriptionParts.push("Boundary dedup is off: edits apply literally.");
+    guidelines.push("`replace`: boundary dedup is off: edits apply literally.");
+  } else if (flags.boundaryDedupMode === "strict") {
+    descriptionParts.push("Boundary dedup is strict: edits that re-include edge lines are rejected instead of stripped.");
+    guidelines.push("`replace`: boundary dedup is strict: edits that re-include edge lines are rejected instead of stripped.");
+  }
+  return { description: descriptionParts.join(" "), snippet: snippetParts.join(""), guidelines };
+}
+
+export function withReadPrompts(base: { description: string; snippet: string; guidelines: string[] }, flags: EditToolFlags): { description: string; snippet: string; guidelines: string[] } {
+  if (flags.autoRead) return { description: base.description, snippet: base.snippet, guidelines: [...base.guidelines] };
+  const guidelines = base.guidelines.map((guideline) => guideline.startsWith("`read`: call again after an edit") ? "`read`: call again after an edit when you need anchors you lack." : guideline);
+  return { description: base.description, snippet: base.snippet, guidelines };
+}
+
+export function withInsertPrompts(base: { description: string; snippet: string; guidelines: string[] }, flags: EditToolFlags): { description: string; snippet: string; guidelines: string[] } {
+  const descriptionParts = [base.description];
+  const snippetParts = [base.snippet];
+  const guidelines = [...base.guidelines];
+  if (flags.requirePath) {
+    descriptionParts.push("Also give `path` matching the file the anchor was served for; it is required and must match anchor ownership.");
+    snippetParts.push("; include `path` (required)");
+    guidelines.push("`insert`: include `path` matching the file the anchor was served for; it is required.");
+  }
+  if (flags.strictInput) {
+    descriptionParts.push("Strict-input mode is on: auto-fixable slips are rejected instead of fixed with warnings.");
+    guidelines.push("`insert`: strict-input is on: auto-fixable slips are rejected instead of fixed.");
+  }
+  return { description: descriptionParts.join(" "), snippet: snippetParts.join(""), guidelines };
+}
 export function resolveEditTarget(removeFrom: string, removeTo?: string): string {
   const refs = [removeFrom, removeTo].filter((value): value is string => typeof value === "string");
   const owners = refs.map((ref) => ownerOf(parseHashRef(stripAnchorRow(ref.trim(), "anchor entry")).hash));
@@ -35,6 +108,47 @@ export function tryResolveEditTarget(removeFrom: string | undefined, removeTo?:
   }
 }
 
+export interface PathRequirementInput {
+  removeFrom?: string;
+  removeTo?: string;
+  anchor?: string;
+  providedPath?: unknown;
+  cwd: string;
+}
+
+export async function resolveEditTargetWithRequirement(input: PathRequirementInput): Promise<string> {
+  const { requirePath } = await readConfig();
+  if (!requirePath && input.providedPath !== undefined) {
+    throw new Error("[E_BAD_SHAPE] Edit request contains unknown or unsupported fields: path. Path resolution is anchor-only; retry without `path`.");
+  }
+  if (requirePath && (typeof input.providedPath !== "string" || input.providedPath.length === 0)) {
+    throw new Error('[E_BAD_SHAPE] Edit request requires a non-empty "path" string when require-path mode is on. Provide `path` matching the file the anchors were served for.');
+  }
+  const anchorTarget = typeof input.anchor === "string"
+    ? resolveEditTarget(input.anchor)
+    : resolveEditTarget(input.removeFrom as string, input.removeTo);
+  if (requirePath) {
+    const { resolved } = await resolveInCwd(input.providedPath as string, input.cwd);
+    if (resolved !== anchorTarget) {
+      throw new Error(`[E_BAD_SHAPE] Provided "path" "${input.providedPath}" does not match anchor ownership "${anchorTarget}".`);
+    }
+  }
+  return anchorTarget;
+}
+
+export async function throwIfStrictInput(warnings: string[]): Promise<void> {
+  const fixes = warnings.filter((warning) => warning.startsWith("[W_"));
+  if (fixes.length === 0) return;
+  const { strictInput } = await readConfig();
+  if (strictInput === true) {
+    throw new Error(`[E_BAD_SHAPE] Strict-input mode rejects auto-fixable input:\n${fixes.join("\n")}`);
+  }
+}
+
+export async function getBoundaryDedupMode(): Promise<BoundaryDedupMode> {
+  return (await readConfig()).boundaryDedupMode ?? "on";
+}
+
 export function editRenderCallWrapper(
   preview: (args: unknown, cwd: string, signal?: AbortSignal) => Promise<RPreview>,
   getInput?: (args: unknown) => { path?: string } | null,

package/src/fs-write.ts

@@ -101,12 +101,18 @@ const TEMP_PREFIX = ".tmp-";
 const TEMP_UUID_RE = /^\.tmp-[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/;
 const STALE_TEMP_MS = 60 * 60 * 1000;
 const sweptDirs = new Map<string, number>();
+const SWEPT_DIRS_LIMIT = 256;
 
 async function sweepStaleTemps(dir: string): Promise<void> {
   const sweepNow = Date.now();
   const lastSweep = sweptDirs.get(dir);
   if (lastSweep !== undefined && sweepNow - lastSweep < STALE_TEMP_MS) return;
+  sweptDirs.delete(dir);
   sweptDirs.set(dir, sweepNow);
+  if (sweptDirs.size > SWEPT_DIRS_LIMIT) {
+    const oldest = sweptDirs.keys().next().value;
+    if (oldest !== undefined) sweptDirs.delete(oldest);
+  }
   try {
     const entries = await readdir(dir, { withFileTypes: true });
     for (const entry of entries) {

package/src/grep.ts

@@ -14,6 +14,8 @@ import { normReq } from "./payload-contract";
 import { abortIf, errCode, isRec, makePrepareArguments, rejectUnknownFields, truncateToBytes, visLines } from "./utils";
 import { markServed as markServedScoped } from "./anchor-registry";
 import { buildServedMap } from "./served";
+import { Text } from "@earendil-works/pi-tui";
+import { expandHint, getResultText, reuseText, type CallT, type FgT } from "./replace-render";
 const GREP_KS = new Set(["pattern", "path", "glob", "context", "ignoreCase", "literal", "limit"]);
 
 function cmp(a: string, b: string): number {
@@ -452,6 +454,79 @@ const grepToolSchema = Type.Object(
   { additionalProperties: false },
 );
 
+
+const GREP_PREVIEW_LINES = 16;
+const GREP_PREVIEW_LINES_EXPANDED = 40;
+
+export function fmtGrepCall(args: { pattern?: unknown; path?: unknown; glob?: unknown; literal?: unknown; ignoreCase?: unknown; context?: unknown; limit?: unknown } | undefined, theme: CallT): string {
+  const pattern = typeof args?.pattern === "string" && args.pattern.length > 0 ? theme.fg("accent", args.pattern) : theme.fg("toolOutput", "...");
+  const qualifiers: string[] = [];
+  if (typeof args?.path === "string" && args.path.length > 0) qualifiers.push(args.path);
+  if (typeof args?.glob === "string" && args.glob.length > 0) qualifiers.push(args.glob);
+  if (args?.literal === true) qualifiers.push("literal");
+  if (args?.ignoreCase === true) qualifiers.push("case-insensitive");
+  if (typeof args?.context === "number") qualifiers.push(`context ${args.context}`);
+  if (typeof args?.limit === "number") qualifiers.push(`limit ${args.limit}`);
+  let text = `${theme.fg("toolTitle", theme.bold("anchor_grep"))} ${pattern}`;
+  if (qualifiers.length > 0) text += ` ${theme.fg("dim", qualifiers.join(" "))}`;
+  return text;
+}
+
+function highlightRegex(args: unknown): RegExp | undefined {
+  if (!isRec(args) || typeof args.pattern !== "string" || args.pattern.length === 0) return undefined;
+  try {
+    const validated = buildRegex(args.pattern, args.literal === true, args.ignoreCase === true);
+    return new RegExp(validated.source, validated.flags.includes("i") ? "giu" : "gu");
+  } catch {
+    return undefined;
+  }
+}
+
+function highlightMatches(text: string, regex: RegExp, theme: FgT): string {
+  let out = "";
+  let last = 0;
+  regex.lastIndex = 0;
+  for (;;) {
+    const match = regex.exec(text);
+    if (!match || match[0].length === 0) break;
+    out += text.slice(last, match.index) + theme.fg("accent", match[0]);
+    last = match.index + match[0].length;
+  }
+  return out + text.slice(last);
+}
+
+const ANCHORED_ROW_RE = /^[A-Za-z0-9]{4}│/;
+
+function highlightHitRow(row: string, highlight: RegExp, theme: FgT): string {
+  const anchored = row.match(ANCHORED_ROW_RE);
+  if (!anchored) return highlightMatches(row, highlight, theme);
+  return anchored[0] + highlightMatches(row.slice(anchored[0].length), highlight, theme);
+}
+
+function styleGrepLine(line: string, highlight: RegExp | undefined, theme: FgT): string {
+  if (line.startsWith("=== ")) return theme.fg("accent", line);
+  if (line.startsWith("[grep:") || line.startsWith("... ")) return theme.fg("dim", line);
+  if (!highlight) return line;
+  const gutter = line.indexOf(" │ ");
+  if (gutter < 0) return highlightHitRow(line, highlight, theme);
+  const cut = gutter + " │ ".length;
+  return line.slice(0, cut) + highlightHitRow(line.slice(cut), highlight, theme);
+}
+
+export function renderGrepResult(result: { content?: Array<{ type: string; text?: string }> }, options: { isPartial: boolean; expanded?: boolean } | boolean, theme: FgT, context: any): Text {
+  const isPartial = typeof options === "boolean" ? options : options.isPartial;
+  const expanded = typeof options === "boolean" ? context.expanded === true : options.expanded === true || context.expanded === true;
+  if (isPartial) return reuseText(context, theme.fg("warning", "Searching..."));
+  const raw = getResultText(result);
+  if (context.isError) return raw ? reuseText(context, `\n${theme.fg("error", raw)}`) : new Text("", 0, 0);
+  if (!raw) return new Text("", 0, 0);
+  const maxLines = expanded ? GREP_PREVIEW_LINES_EXPANDED : GREP_PREVIEW_LINES;
+  const lines = raw.split("\n");
+  const highlight = highlightRegex((context as { args?: unknown }).args);
+  const shown = lines.slice(0, maxLines).map((line) => styleGrepLine(line, highlight, theme));
+  if (lines.length > maxLines) shown.push(theme.fg("muted", `... ${lines.length - maxLines} more grep lines (${expandHint()})`));
+  return reuseText(context, shown.join("\n"));
+}
 export function regGrep(pi: ExtensionAPI): void {
   pi.registerTool({
     name: "anchor_grep",
@@ -462,6 +537,14 @@ export function regGrep(pi: ExtensionAPI): void {
     prepareArguments: makePrepareArguments(),
     parameters: grepToolSchema,
     executionMode: "sequential",
+    renderCall(args: any, theme: CallT, context: any) {
+      const text = (context.lastComponent as Text | undefined) ?? new Text("", 0, 0);
+      text.setText(fmtGrepCall(args as { pattern?: unknown; path?: unknown } | undefined, theme));
+      return text;
+    },
+    renderResult(result, opts, theme, context) {
+      return renderGrepResult(result as never, opts as { isPartial: boolean; expanded?: boolean }, theme as never, context as never);
+    },
 
     async execute(_toolCallId, params, signal, _onUpdate, ctx) {
       const canonical = normReq(params);
@@ -594,7 +677,7 @@ export function regGrep(pi: ExtensionAPI): void {
       if (rowTruncated) notes.push(`[grep: output truncated at ${DEFAULT_MAX_LINES} rows or ${formatSize(DEFAULT_MAX_BYTES)}; refine the pattern to see more.]`);
       if (limitTruncated) notes.push(`[grep: showing first ${limit} matches; increase limit to see more.]`);
       if (linesReplaced > 0) notes.push(`[grep: ${linesReplaced} line(s) exceed ${formatSize(MAX_GREP_LINE_BYTES)} and are shown as truncated fragments; use read to see the full lines.]`);
-      if (poolSkipped > 0) notes.push(`[grep: ${poolSkipped} file(s) skipped because the session's anchor pool is exhausted; free anchors with /clear-anchors or narrow the search.]`);
+      if (poolSkipped > 0) notes.push(`[grep: ${poolSkipped} file(s) skipped because the session's anchor pool is exhausted; narrow the search.]`);
       const truncated = limitTruncated || rowTruncated;
       const truncation: TruncationResult | undefined = rowTruncated
         ? {

package/src/hashline/alphabet.ts

@@ -12,7 +12,7 @@ export const ALPH_RE = new RegExp(`^[${ALNUM}]+$`);
 
 export const HASH_CLASS = `[${ALNUM}]{${HASH_LEN}}`;
 
-export const HASH_RUN = `[${ALNUM}]{1,${HASH_LEN * 2}}`;
+export const HASH_RUN = `[${ALNUM}]{${HASH_LEN},${HASH_LEN + 1}}`;
 
 export const HASH_RE = new RegExp(`^${HASH_CLASS}$`);