ashlr-plugin 1.36.4

package/servers/diff-server-handlers.ts

@@ -0,0 +1,317 @@
+/**
+ * diff-server-handlers — side-effect module.
+ *
+ * Importing this file registers the ashlr__diff tool into the shared registry
+ * (_tool-base.ts). Used by both the standalone entry point (diff-server.ts)
+ * and the router (_router.ts via _router-handlers.ts).
+ */
+
+import { registerTool, type ToolCallContext, type ToolResult } from "./_tool-base";
+import { spawnSync } from "child_process";
+import { existsSync } from "fs";
+import { summarizeIfLarge, PROMPTS, confidenceBadge, confidenceTier } from "./_summarize";
+import { recordSaving as recordSavingCore } from "./_stats";
+import { logEvent } from "./_events";
+import { clampToCwd } from "./_cwd-clamp";
+
+// ---------------------------------------------------------------------------
+// snipCompact for full-mode oversized diffs
+// ---------------------------------------------------------------------------
+
+const FULL_SNIP_THRESHOLD = 4096;
+const HEAD_BYTES = 1600;
+const TAIL_BYTES = 1600;
+
+function snipCompact(s: string): string {
+  if (s.length <= FULL_SNIP_THRESHOLD) return s;
+  const elided = s.length - HEAD_BYTES - TAIL_BYTES;
+  return (
+    s.slice(0, HEAD_BYTES) +
+    `\n[... ${elided.toLocaleString()} bytes of diff elided ...]\n` +
+    s.slice(-TAIL_BYTES)
+  );
+}
+
+// ---------------------------------------------------------------------------
+// git invocation
+// ---------------------------------------------------------------------------
+
+interface DiffArgs {
+  ref?: string;
+  path?: string;
+  cwd?: string;
+  mode?: "stat" | "summary" | "full";
+  bypassSummary?: boolean;
+}
+
+function resolveRefArgs(ref: string): { args: string[]; label: string } {
+  const r = ref.trim();
+  if (r === "staged" || r === "--cached" || r === "cached") {
+    return { args: ["--cached"], label: "staged" };
+  }
+  if (r === "unstaged" || r === "working") {
+    return { args: [], label: r };
+  }
+  return { args: [r], label: r };
+}
+
+function runGit(cwd: string, args: string[]): { ok: boolean; stdout: string; stderr: string } {
+  const res = spawnSync("git", ["-C", cwd, ...args], {
+    encoding: "utf-8",
+    maxBuffer: 100 * 1024 * 1024,
+    timeout: 15_000,
+  });
+  return {
+    ok: res.status === 0,
+    stdout: res.stdout || "",
+    stderr: res.stderr || "",
+  };
+}
+
+function isGitRepo(cwd: string): boolean {
+  const r = runGit(cwd, ["rev-parse", "--is-inside-work-tree"]);
+  return r.ok && r.stdout.trim() === "true";
+}
+
+// ---------------------------------------------------------------------------
+// numstat + hunk parsing
+// ---------------------------------------------------------------------------
+
+interface FileStat {
+  added: number;
+  deleted: number;
+  path: string;
+}
+
+function parseNumstat(raw: string): FileStat[] {
+  const out: FileStat[] = [];
+  for (const line of raw.split("\n")) {
+    if (!line) continue;
+    const parts = line.split("\t");
+    if (parts.length < 3) continue;
+    const [a, d, ...rest] = parts;
+    const path = rest.join("\t");
+    const added = a === "-" ? 0 : Number(a) || 0;
+    const deleted = d === "-" ? 0 : Number(d) || 0;
+    out.push({ added, deleted, path });
+  }
+  return out;
+}
+
+function padCol(s: string, w: number): string {
+  if (s.length >= w) return s;
+  return s + " ".repeat(w - s.length);
+}
+
+function renderStat(files: FileStat[], header: string): string {
+  const totalAdd = files.reduce((s, f) => s + f.added, 0);
+  const totalDel = files.reduce((s, f) => s + f.deleted, 0);
+  const lines: string[] = [
+    `diff ${header} \u00b7 ${files.length} file${files.length === 1 ? "" : "s"} \u00b7 +${totalAdd} -${totalDel} lines`,
+  ];
+  if (files.length === 0) return lines[0]! + "\n  (no changes)";
+  const pathW = Math.min(60, Math.max(...files.map((f) => f.path.length)));
+  for (const f of files) {
+    lines.push(`  ${padCol(f.path, pathW)}  +${f.added} -${f.deleted}`);
+  }
+  return lines.join("\n");
+}
+
+interface Hunk {
+  header: string;
+  added: string[];
+  deletedCount: number;
+  addedCountTotal: number;
+}
+
+function parseHunksForFile(fileBlock: string): Hunk[] {
+  const hunks: Hunk[] = [];
+  const lines = fileBlock.split("\n");
+  let cur: Hunk | null = null;
+  for (const ln of lines) {
+    if (ln.startsWith("@@")) {
+      if (cur) hunks.push(cur);
+      cur = { header: ln, added: [], deletedCount: 0, addedCountTotal: 0 };
+    } else if (cur) {
+      if (ln.startsWith("+") && !ln.startsWith("+++")) {
+        cur.addedCountTotal++;
+        cur.added.push(ln);
+      } else if (ln.startsWith("-") && !ln.startsWith("---")) {
+        cur.deletedCount++;
+      }
+    }
+  }
+  if (cur) hunks.push(cur);
+  return hunks;
+}
+
+function splitDiffByFile(raw: string): Map<string, string> {
+  const map = new Map<string, string>();
+  if (!raw) return map;
+  const parts = raw.split(/^diff --git /m);
+  for (const part of parts) {
+    if (!part.trim()) continue;
+    const firstLine = part.split("\n", 1)[0] || "";
+    const m = firstLine.match(/ b\/(.+)$/);
+    const path = m ? m[1]! : firstLine.trim();
+    map.set(path, "diff --git " + part);
+  }
+  return map;
+}
+
+function renderSummary(files: FileStat[], header: string, rawDiff: string): string {
+  const stat = renderStat(files, header);
+  const blocks = splitDiffByFile(rawDiff);
+  const out: string[] = [stat, ""];
+  const KEY_ADDED_SHOWN = 10;
+  for (const f of files) {
+    const block = blocks.get(f.path);
+    out.push(`${f.path}  +${f.added} -${f.deleted}`);
+    if (!block) {
+      out.push("  (no hunks)");
+      out.push("");
+      continue;
+    }
+    const hunks = parseHunksForFile(block);
+    const hottest = [...hunks].sort((a, b) => b.addedCountTotal - a.addedCountTotal).slice(0, 2);
+    if (hottest.length === 0) {
+      out.push("  (no hunks)");
+    }
+    for (const h of hottest) {
+      out.push(`  ${h.header}`);
+      const shown = h.added.slice(0, KEY_ADDED_SHOWN);
+      for (const s of shown) {
+        out.push(`    ${s}`);
+      }
+      const moreAdded = Math.max(0, h.addedCountTotal - shown.length);
+      if (moreAdded > 0 || h.deletedCount > 0) {
+        out.push(`    [... ${moreAdded} more added \u00b7 ${h.deletedCount} deleted ...]`);
+      }
+    }
+    out.push("");
+  }
+  return out.join("\n").replace(/\n+$/, "");
+}
+
+// ---------------------------------------------------------------------------
+// Core logic (exported for tests)
+// ---------------------------------------------------------------------------
+
+export async function ashlrDiff(args: DiffArgs): Promise<string> {
+  const clamp = clampToCwd(args.cwd, "ashlr__diff");
+  if (!clamp.ok) return clamp.message;
+  const cwd = clamp.abs;
+  if (!existsSync(cwd)) {
+    throw new Error(`cwd does not exist: ${cwd}`);
+  }
+  if (!isGitRepo(cwd)) {
+    throw new Error(`not a git repository: ${cwd}`);
+  }
+
+  const refIn = args.ref ?? "HEAD~1";
+  const { args: refArgs, label } = resolveRefArgs(refIn);
+  const pathArgs = args.path ? ["--", args.path] : [];
+
+  const numstat = runGit(cwd, ["diff", "--numstat", ...refArgs, ...pathArgs]);
+  if (!numstat.ok) {
+    const msg = numstat.stderr.trim() || "git diff failed";
+    throw new Error(`git diff failed: ${msg}`);
+  }
+  const files = parseNumstat(numstat.stdout);
+  const totalChangedLines = files.reduce((s, f) => s + f.added + f.deleted, 0);
+
+  const raw = runGit(cwd, ["diff", ...refArgs, ...pathArgs]);
+  const rawDiff = raw.ok ? raw.stdout : "";
+  const rawBytes = rawDiff.length;
+
+  let mode: "stat" | "summary" | "full";
+  if (args.mode === "stat" || args.mode === "summary" || args.mode === "full") {
+    mode = args.mode;
+  } else if (totalChangedLines > 500) {
+    mode = "stat";
+  } else if (totalChangedLines >= 100) {
+    mode = "summary";
+  } else {
+    mode = "full";
+  }
+
+  let body: string;
+  if (mode === "stat") {
+    body = renderStat(files, label);
+  } else if (mode === "summary") {
+    body = renderSummary(files, label, rawDiff);
+  } else {
+    if (!rawDiff) {
+      body = renderStat(files, label);
+    } else {
+      const header = renderStat(files, label);
+      body = `${header}\n\n${snipCompact(rawDiff)}`;
+    }
+  }
+
+  const rawDiffBytes = Buffer.byteLength(rawDiff, "utf-8");
+  if ((mode === "full" || mode === "summary") && rawDiffBytes > 16_384 && !args.bypassSummary) {
+    const s = await summarizeIfLarge(body, {
+      toolName: "ashlr__diff",
+      systemPrompt: PROMPTS.diff,
+      bypass: false,
+      thresholdBytes: 1,
+    });
+    body = s.text;
+  }
+
+  const footer = `\n\n[ashlr__diff \u00b7 mode=${mode}]`;
+  const text = body + footer;
+
+  const diffRawBytes = Math.max(rawBytes, body.length);
+  await recordSavingCore(diffRawBytes, text.length, "ashlr__diff");
+
+  const diffBadgeOpts = {
+    toolName: "ashlr__diff",
+    rawBytes: diffRawBytes,
+    outputBytes: text.length,
+  };
+  if (confidenceTier(diffBadgeOpts) === "low") {
+    await logEvent("tool_low_confidence_shipped", { tool: "ashlr__diff", reason: "low-confidence" });
+  }
+  return text + confidenceBadge(diffBadgeOpts);
+}
+
+// ---------------------------------------------------------------------------
+// Registration (side-effect on import)
+// ---------------------------------------------------------------------------
+
+registerTool({
+  name: "ashlr__diff",
+  description:
+    "Fast adaptive git diff. Use instead of native Bash 'git diff | cat' when reviewing " +
+    "changes — avoids dumping thousands of lines into context. Compresses by auto-selecting " +
+    "stat-only (>500 changed lines), stat+hottest-hunks (100–500), or full patch (<100); " +
+    "typical savings 60–95% on large diffs. Accepts any git ref plus pseudo-refs 'staged', " +
+    "'unstaged', 'working'. For refactor/rename reviews use ashlr__diff_semantic instead.",
+  inputSchema: {
+    type: "object",
+    properties: {
+      ref: {
+        type: "string",
+        description:
+          "Git ref to diff against (default: HEAD~1). Also accepts 'staged' / 'unstaged' / 'working'.",
+      },
+      path: { type: "string", description: "Limit to path(s) \u2014 file or dir" },
+      cwd: { type: "string" },
+      mode: {
+        type: "string",
+        description:
+          "'stat' (files + lines only) \u00b7 'summary' (stat + hottest hunks) \u00b7 'full' (default: adaptive \u2014 stat if huge, summary if moderate, full if small)",
+      },
+      bypassSummary: {
+        type: "boolean",
+        description: "If true, skip LLM summarization and return the full compacted diff.",
+      },
+    },
+  },
+  handler: async (args: Record<string, unknown>, _ctx: ToolCallContext): Promise<ToolResult> => {
+    const text = await ashlrDiff(args as unknown as DiffArgs);
+    return { content: [{ type: "text", text }] };
+  },
+});

package/servers/diff-server.ts

@@ -0,0 +1,20 @@
+#!/usr/bin/env bun
+/**
+ * ashlr-diff MCP server — standalone entry point.
+ *
+ * Imports diff-server-handlers (registers ashlr__diff into the shared
+ * registry) then runs as a standalone stdio MCP server. Existing plugin.json
+ * entries continue to work unchanged through the v1.12 migration window.
+ *
+ * For in-process router use, import diff-server-handlers directly.
+ */
+
+import "./diff-server-handlers";
+import { runStandalone } from "./_tool-base";
+
+// Re-export core logic so existing tests that import from this module keep working.
+export { ashlrDiff } from "./diff-server-handlers";
+
+if (import.meta.main) {
+  await runStandalone("ashlr-diff", "0.1.0");
+}

package/servers/edit-server-handlers.ts

@@ -0,0 +1,31 @@
+/**
+ * edit-server-handlers — registers ashlr__edit into the shared tool registry.
+ */
+
+import { registerTool, type ToolCallContext, type ToolResult } from "./_tool-base";
+import { ashlrEdit, type EditArgs } from "./edit-server";
+
+registerTool({
+  name: "ashlr__edit",
+  description:
+    "Single literal search/replace in one file, returns only a diff summary. " +
+    "Use instead of native Edit when the file is >5KB or the combined before/after " +
+    "is >=80 chars — avoids the full file round-trip. Compresses by returning only " +
+    "the changed lines; typical savings 80%. In strict mode (default) requires " +
+    "exactly one match. For many edits across files use ashlr__multi_edit instead. " +
+    "For symbol renames use ashlr__edit_structural instead.",
+  inputSchema: {
+    type: "object",
+    properties: {
+      path: { type: "string", description: "Absolute or cwd-relative file path" },
+      search: { type: "string", description: "Exact text to find" },
+      replace: { type: "string", description: "Replacement text" },
+      strict: { type: "boolean", description: "Require exactly one match (default: true)" },
+    },
+    required: ["path", "search", "replace"],
+  },
+  handler: async (args: Record<string, unknown>, _ctx: ToolCallContext): Promise<ToolResult> => {
+    const res = await ashlrEdit(args as unknown as EditArgs);
+    return { content: [{ type: "text", text: res.text }] };
+  },
+});

package/servers/edit-server.ts

@@ -0,0 +1,209 @@
+/**
+ * edit-server — ashlr__edit tool implementation.
+ *
+ * Owns the search/replace + diff-summary pipeline. Three post-edit
+ * side-effects (in order):
+ *   1. readCache invalidate  — so subsequent ashlr__read sees fresh content
+ *   2. refreshGenomeAfterEdit (fire-and-forget) — keeps genome in sync
+ *   3. editLog append        — feeds ashlr__flush summary
+ */
+
+import { readFile, writeFile } from "fs/promises";
+import { estimateTokensFromString } from "@ashlr/core-efficiency";
+import { refreshGenomeAfterEdit } from "./_genome-live";
+import { recordSaving } from "./_stats";
+import { clampToCwd } from "./_cwd-clamp";
+import { invalidateCached } from "./_read-cache";
+import { appendEdit } from "./_edit-log";
+import { levenshtein as _levenshtein, fuzzyTopLines, findFuzzyMatch } from "./_edit-match";
+import { validateEdit } from "./_edit-validate";
+
+// Re-export levenshtein so tests / other modules that may import it from here
+// continue to work (backwards-compat shim).
+export { _levenshtein as levenshtein };
+
+export interface EditArgs {
+  path: string;
+  search: string;
+  replace: string;
+  /** When true (default), require exactly one match of `search` for safety. */
+  strict?: boolean;
+}
+
+export interface EditResult {
+  text: string;
+  hunksApplied: number;
+}
+
+const FUZZY_SIZE_LIMIT = 2 * 1024 * 1024; // 2 MB
+
+function summarizeEdit(
+  relPath: string,
+  search: string,
+  replace: string,
+  matchCount: number,
+  strict: boolean,
+): string {
+  const first = (s: string) => s.split("\n")[0]?.slice(0, 72) ?? "";
+  return [
+    `[ashlr__edit] ${relPath}  ·  ${strict ? "1 of " + matchCount : matchCount + " of " + matchCount} hunks applied`,
+    `  - removed (${estimateTokensFromString(search)} tok):  ${first(search)}${search.length > 72 ? "…" : ""}`,
+    `  + added   (${estimateTokensFromString(replace)} tok):  ${first(replace)}${replace.length > 72 ? "…" : ""}`,
+  ].join("\n");
+}
+
+export async function ashlrEdit(input: EditArgs): Promise<EditResult> {
+  const { path: relPath, search, replace, strict = true } = input;
+  if (!search) throw new Error("ashlr__edit: 'search' must not be empty");
+
+  const clamp = clampToCwd(relPath, "ashlr__edit");
+  if (!clamp.ok) throw new Error(clamp.message);
+  const abs = clamp.abs;
+  const original = await readFile(abs, "utf-8");
+
+  let count = 0;
+  let idx = 0;
+  while ((idx = original.indexOf(search, idx)) !== -1) { count++; idx += search.length; }
+
+  // -------------------------------------------------------------------------
+  // Zero-match: try fuzzy fallback (Feature 2) before throwing.
+  // -------------------------------------------------------------------------
+  if (count === 0) {
+    // Fuzzy is only attempted in strict mode, for files <= 2 MB, when not disabled.
+    const fuzzyEnabled =
+      strict &&
+      original.length <= FUZZY_SIZE_LIMIT &&
+      process.env.ASHLR_EDIT_FUZZY !== "off";
+
+    if (fuzzyEnabled) {
+      const fuzzyMatch = findFuzzyMatch(original, search);
+      if (fuzzyMatch !== null) {
+        // Confident, unique match found — apply it.
+        const updated =
+          original.slice(0, fuzzyMatch.start) +
+          replace +
+          original.slice(fuzzyMatch.end);
+
+        // Validate before write (Feature 3).
+        const validation = await validateEdit(abs, original, updated).catch(() => ({
+          introducedError: false,
+          detail: "",
+        }));
+
+        if (
+          validation.introducedError &&
+          process.env.ASHLR_EDIT_VALIDATE === "block"
+        ) {
+          throw new Error(
+            `ashlr__edit: refused — edit introduces a syntax error (${validation.detail}); ` +
+              `set ASHLR_EDIT_VALIDATE=warn to override`,
+          );
+        }
+
+        await writeFile(abs, updated, "utf-8");
+        invalidateCached(abs);
+        refreshGenomeAfterEdit(abs, original, updated).catch(() => {});
+
+        const baseBytes = search.length + replace.length;
+        const compactSummary = summarizeEdit(relPath, search, replace, 1, true);
+        await recordSaving(baseBytes, compactSummary.length, "ashlr__edit");
+
+        appendEdit({ relPath, hunksApplied: 1 });
+
+        let resultText =
+          compactSummary +
+          `\n[ashlr__edit: applied via fuzzy match (sim=${fuzzyMatch.score.toFixed(2)}) — verify the diff]`;
+
+        if (validation.introducedError) {
+          resultText +=
+            `\n[ashlr__edit: ⚠ syntax — this edit introduces a parse error (${validation.detail}); review or fix in your next edit]`;
+        }
+
+        return { text: resultText, hunksApplied: 1 };
+      }
+    }
+
+    // No fuzzy match (or fuzzy disabled) — throw the existing enriched error.
+    if (strict && original.length <= FUZZY_SIZE_LIMIT) {
+      const candidates = fuzzyTopLines(search, original);
+      const hint = candidates.length
+        ? "\nClosest lines in file:\n" +
+          candidates.map(c => `  ${c.lineNo}:  ${c.text.slice(0, 120)}  (sim=${c.sim.toFixed(2)})`).join("\n")
+        : "";
+      throw new Error(`ashlr__edit: no match for search string in ${relPath} (strict mode).${hint}`);
+    }
+    throw new Error(`ashlr__edit: search string not found in ${relPath}`);
+  }
+
+  if (strict && count > 1) {
+    throw new Error(
+      `ashlr__edit: search string matched ${count} times in ${relPath}; pass strict:false to replace all, or widen the context to a unique span.`,
+    );
+  }
+
+  // -------------------------------------------------------------------------
+  // Normal exact-match path (unchanged semantics).
+  // -------------------------------------------------------------------------
+
+  // Treat replacement as literal text. String.prototype.replace(string, string)
+  // interprets `$&`, `$1`, `$'`, and `$` sequences in the replacement.
+  const matchIdx = original.indexOf(search);
+  const updated = strict
+    ? original.slice(0, matchIdx) + replace + original.slice(matchIdx + search.length)
+    : original.split(search).join(replace);
+
+  // Feature 3: validate before writing.
+  const validation = await validateEdit(abs, original, updated).catch(() => ({
+    introducedError: false,
+    detail: "",
+  }));
+
+  if (
+    validation.introducedError &&
+    process.env.ASHLR_EDIT_VALIDATE === "block"
+  ) {
+    throw new Error(
+      `ashlr__edit: refused — edit introduces a syntax error (${validation.detail}); ` +
+        `set ASHLR_EDIT_VALIDATE=warn to override`,
+    );
+  }
+
+  await writeFile(abs, updated, "utf-8");
+
+  // Post-edit side-effects (order preserved from efficiency-server.ts:847-902):
+
+  // 1. Invalidate read-cache so subsequent ashlr__read calls see new content.
+  invalidateCached(abs);
+
+  // 2. best-effort: refreshGenomeAfterEdit already swallows internally; this
+  //    outer catch guards against a pre-try sync throw.
+  refreshGenomeAfterEdit(abs, original, updated).catch(() => {});
+
+  // v1.18 Trust Pass: baseline is what Claude Code would have SENT for a
+  // native Edit — search + replace, NOT the full file twice.
+  // v1.22 refinement: multi-hunk strict=false edits replace ALL N matches in
+  // a single ashlr call. Native equivalent is one Edit with replace_all=true
+  // (still 1 call) but Claude must reason about all N occurrences when crafting
+  // the call — add a small file-context premium (+500 bytes) so multi-hunk
+  // savings reflect the cognitive overhead of the original LLM call without
+  // multiplying by `count` (which would inflate 5-10×).
+  const baseBytes = search.length + replace.length;
+  const naiveBytes = !strict && count > 1 ? baseBytes + 500 : baseBytes;
+  const compactSummary = summarizeEdit(relPath, search, replace, count, strict);
+  await recordSaving(naiveBytes, compactSummary.length, "ashlr__edit");
+
+  const hunksApplied = strict ? 1 : count;
+
+  // 3. Append to edit log (feeds ashlr__flush summary).
+  appendEdit({ relPath, hunksApplied });
+
+  let resultText = compactSummary;
+
+  // Feature 3: append warning if edit introduced a syntax error (warn mode).
+  if (validation.introducedError) {
+    resultText +=
+      `\n[ashlr__edit: ⚠ syntax — this edit introduces a parse error (${validation.detail}); review or fix in your next edit]`;
+  }
+
+  return { text: resultText, hunksApplied };
+}