@wrongstack/tools 0.313.0 → 0.316.1

package/dist/chunk-WHIIIREL.js

@@ -0,0 +1,223 @@
+// src/memory.ts
+import { ToolValidationError } from "@wrongstack/core/types";
+function rememberTool(memory) {
+  return {
+    name: "remember",
+    category: "Session",
+    description: "Persist facts, conventions, decisions, and preferences into long-term memory. Memories survive restarts and are scored for relevance in future sessions.",
+    usageHint: "Persist facts, conventions, decisions, and preferences into long-term memory.\n\nWHEN TO USE:\n- Project conventions discovered during a task (build tool, lint rules, code style)\n- Architecture decisions made (chose X over Y, decided to use pattern Z)\n- User preferences expressed (prefers short names, always uses pnpm)\n- Anti-patterns identified (never do X, avoid pattern Y)\n- File/location references useful across sessions\n\nWHEN NOT TO USE:\n- Temporary task state or progress \u2192 use `todo`\n- One-off debugging notes\n- Information already obvious from the codebase\n\nAlways include `type` and `priority`. Use 1-3 `tags` for grouping.\nBetter to remember a fact now than rediscover it next session.",
+    permission: "confirm",
+    mutating: true,
+    timeoutMs: 2e3,
+    capabilities: ["memory.write"],
+    icon: "settings",
+    inputSchema: {
+      type: "object",
+      properties: {
+        text: {
+          type: "string",
+          description: "The fact or note to remember. Keep it concise and factual."
+        },
+        scope: {
+          type: "string",
+          enum: ["project-agents", "project-memory", "user-memory"],
+          description: "Where to store it: project-memory (shared), user-memory (personal), or project-agents."
+        },
+        type: {
+          type: "string",
+          enum: ["fact", "decision", "convention", "preference", "reference", "anti_pattern"],
+          description: "Category for filtering and relevance scoring."
+        },
+        tags: {
+          type: "array",
+          items: { type: "string" },
+          description: "Hashtag-style tags for grouping and search."
+        },
+        priority: {
+          type: "string",
+          enum: ["critical", "high", "medium", "low"],
+          description: "Priority level. Critical = always injected into context."
+        }
+      },
+      required: ["text"]
+    },
+    async execute(input) {
+      if (!input?.text) {
+        throw new ToolValidationError({
+          message: "remember: text is required",
+          field: "text"
+        });
+      }
+      const scope = input.scope ?? "project-memory";
+      await memory.remember(input.text, scope, {
+        type: input.type,
+        tags: input.tags,
+        priority: input.priority
+      });
+      return { ok: true, scope };
+    }
+  };
+}
+function forgetTool(memory) {
+  return {
+    name: "forget",
+    category: "Session",
+    description: "Remove memory entries that contain the given substring (case-insensitive). Use with caution. Pass `dry_run: true` to preview the matching entries (capped at 20) without deleting anything.",
+    usageHint: "This permanently deletes matching memories in the chosen scope.\n- Provide a reasonably specific `query` to avoid deleting unrelated memories.\n- Always double-check before calling with broad queries \u2014 `dry_run: true` previews the matches without deleting.\n- Use `remember` + `forget` together to maintain clean long-term memory.",
+    permission: "confirm",
+    // WS-046: gives permission decisions something to key on — the substring
+    // being forgotten.
+    subjectKey: "query",
+    mutating: true,
+    timeoutMs: 2e3,
+    capabilities: ["memory.delete"],
+    icon: "settings",
+    inputSchema: {
+      type: "object",
+      properties: {
+        query: { type: "string" },
+        scope: { type: "string", enum: ["project-agents", "project-memory", "user-memory"] },
+        dry_run: {
+          type: "boolean",
+          description: "When true, return the matched entries (capped at 20) WITHOUT deleting them. Default false."
+        }
+      },
+      required: ["query"]
+    },
+    async execute(input) {
+      if (!input?.query) {
+        throw new ToolValidationError({
+          message: "forget: query is required",
+          field: "query"
+        });
+      }
+      const scope = input.scope ?? "project-memory";
+      if (input.dry_run) {
+        const entries = await memory.list(scope);
+        const needle = input.query.toLowerCase();
+        const matching = entries.filter((entry) => entry.text.toLowerCase().includes(needle));
+        return {
+          removed: 0,
+          scope,
+          dryRun: true,
+          matched: matching.length,
+          matches: matching.slice(0, 20).map((entry) => entry.text)
+        };
+      }
+      const removed = await memory.forget(input.query, scope);
+      return { removed, scope };
+    }
+  };
+}
+function searchMemoryTool(memory) {
+  return {
+    name: "search_memory",
+    category: "Session",
+    description: "Search memory entries by content. With the default backend this does substring matching; semantic/graph backends use embedding similarity or graph traversal.",
+    usageHint: "Search long-term memory for relevant facts, conventions, or decisions.\n- Returns results ordered by relevance (newest-first for default, similarity for semantic).\n- Use before starting a task to recall project conventions and past decisions.\n- `limit` caps results (default 5, max 20).",
+    permission: "auto",
+    mutating: false,
+    timeoutMs: 2e3,
+    capabilities: ["memory.read"],
+    inputSchema: {
+      type: "object",
+      properties: {
+        query: {
+          type: "string",
+          description: "Search query \u2014 words or phrase to find in memory."
+        },
+        scope: {
+          type: "string",
+          enum: ["project-agents", "project-memory", "user-memory"],
+          description: "Which scope to search. Defaults to project-memory."
+        },
+        limit: {
+          type: "number",
+          description: "Maximum results to return (default 5, max 20)."
+        }
+      },
+      required: ["query"]
+    },
+    async execute(input) {
+      if (!input?.query) {
+        throw new ToolValidationError({
+          message: "search_memory: query is required",
+          field: "query"
+        });
+      }
+      const scope = input.scope ?? "project-memory";
+      const limit = Math.min(input.limit ?? 5, 20);
+      const entries = await memory.search(input.query, scope, limit);
+      return {
+        results: entries.map((e) => ({
+          text: e.text,
+          ts: e.ts,
+          scope: e.scope,
+          type: e.type,
+          tags: e.tags,
+          priority: e.priority
+        }))
+      };
+    }
+  };
+}
+function relatedMemoryTool(memory) {
+  return {
+    name: "find_related_memories",
+    category: "Session",
+    description: "Find memories related to the given text via graph traversal. Only available with graph backends; falls back to content search with file backends.",
+    usageHint: "Discover memories connected to a topic through co-occurrence or similarity edges.\n- Useful for exploring what else the project knows about a given concept.\n- Falls back to content search when no graph backend is configured.\n- `limit` caps results (default 5, max 20).",
+    permission: "auto",
+    mutating: false,
+    timeoutMs: 2e3,
+    capabilities: ["memory.read"],
+    inputSchema: {
+      type: "object",
+      properties: {
+        text: {
+          type: "string",
+          description: "Text to find related memories for."
+        },
+        scope: {
+          type: "string",
+          enum: ["project-agents", "project-memory", "user-memory"],
+          description: "Which scope to search. Defaults to project-memory."
+        },
+        limit: {
+          type: "number",
+          description: "Maximum results to return (default 5, max 20)."
+        }
+      },
+      required: ["text"]
+    },
+    async execute(input) {
+      if (!input?.text) {
+        throw new ToolValidationError({
+          message: "find_related_memories: text is required",
+          field: "text"
+        });
+      }
+      const scope = input.scope ?? "project-memory";
+      const limit = Math.min(input.limit ?? 5, 20);
+      const entries = memory.findRelated ? await memory.findRelated(input.text, scope, limit) : await memory.search(input.text, scope, limit);
+      return {
+        results: entries.map((e) => ({
+          text: e.text,
+          ts: e.ts,
+          scope: e.scope,
+          type: e.type,
+          tags: e.tags,
+          priority: e.priority
+        }))
+      };
+    }
+  };
+}
+
+export {
+  rememberTool,
+  forgetTool,
+  searchMemoryTool,
+  relatedMemoryTool
+};
+//# sourceMappingURL=chunk-WHIIIREL.js.map

package/dist/chunk-Z6DAKQ3U.js

@@ -0,0 +1 @@
+//# sourceMappingURL=chunk-Z6DAKQ3U.js.map

package/dist/chunk-ZJQ4IGXK.js

@@ -0,0 +1,474 @@
+import {
+  checkSyntax
+} from "./chunk-FQZOHLG3.js";
+import {
+  enqueueReindex
+} from "./chunk-HYX2TZ7O.js";
+import {
+  safeResolveReal,
+  sha256hex,
+  truncateDiffPayload
+} from "./chunk-D33S4RQG.js";
+
+// src/edit.ts
+import * as fs from "node:fs/promises";
+import {
+  atomicWrite,
+  detectNewlineStyle,
+  normalizeToLf,
+  toStyle,
+  unifiedDiff
+} from "@wrongstack/core/utils";
+import { ToolValidationError } from "@wrongstack/core/types";
+
+// src/_edit-match.ts
+var TIER_LABEL = {
+  exact: "exact match",
+  "trailing-whitespace": "whitespace-normalized match (trailing whitespace ignored)",
+  "whitespace-normalized": "whitespace-normalized match (indentation ignored, replacement re-indented)",
+  fuzzy: "fuzzy match (block anchors exact, interior \u226590% similar)"
+};
+var TIER_CONFIDENCE = {
+  exact: "exact",
+  "trailing-whitespace": "high",
+  "whitespace-normalized": "medium",
+  fuzzy: "low"
+};
+var MIN_NORMALIZED_NEEDLE_CHARS = 16;
+var FUZZY_MIN_SIMILARITY = 0.9;
+var FUZZY_AMBIGUITY_MARGIN = 0.05;
+var FUZZY_MAX_INTERIOR_CHARS = 2e3;
+function findLadderMatches(fileLf, oldLf) {
+  const exact = [];
+  let idx = fileLf.indexOf(oldLf);
+  while (idx !== -1) {
+    exact.push({ start: idx, end: idx + oldLf.length, startLine: lineAt(fileLf, idx) });
+    idx = fileLf.indexOf(oldLf, idx + 1);
+  }
+  if (exact.length > 0) return { tier: "exact", matches: exact };
+  const fileLines = fileLf.split("\n");
+  const needleLines = oldLf.split("\n");
+  if (needleLines.length > fileLines.length) return void 0;
+  const offsets = lineOffsets(fileLines);
+  const fileTrimEnd = fileLines.map((l) => l.trimEnd());
+  const needleTrimEnd = needleLines.map((l) => l.trimEnd());
+  const trailing = windowScan(fileTrimEnd, needleTrimEnd, offsets, fileLines, (a, b) => a === b);
+  if (trailing.length > 0) return { tier: "trailing-whitespace", matches: trailing };
+  const normalizedLen = needleTrimEnd.reduce((n, l) => n + l.trimStart().length, 0);
+  if (normalizedLen < MIN_NORMALIZED_NEEDLE_CHARS) return void 0;
+  const fileTrimmed = fileTrimEnd.map((l) => l.trimStart());
+  const needleTrimmed = needleTrimEnd.map((l) => l.trimStart());
+  const normalized = windowScan(fileTrimmed, needleTrimmed, offsets, fileLines, (a, b) => a === b);
+  if (normalized.length > 0) return { tier: "whitespace-normalized", matches: normalized };
+  return fuzzyScan(fileLines, needleLines, offsets);
+}
+function lineAt(text, pos) {
+  if (pos < 512) {
+    let line2 = 1;
+    for (let i = 0; i < pos; i++) {
+      if (text.charCodeAt(i) === 10) line2++;
+    }
+    return line2;
+  }
+  let line = 1;
+  let search = 0;
+  while (true) {
+    const idx = text.indexOf("\n", search);
+    if (idx === -1 || idx >= pos) return line;
+    search = idx + 1;
+    line++;
+  }
+}
+function lineOffsets(lines) {
+  const out = new Array(lines.length);
+  let pos = 0;
+  for (let i = 0; i < lines.length; i++) {
+    out[i] = pos;
+    pos += lines[i].length + 1;
+  }
+  return out;
+}
+function windowToMatch(fileLines, offsets, start, windowLen) {
+  const lastLine = start + windowLen - 1;
+  return {
+    start: offsets[start],
+    end: offsets[lastLine] + fileLines[lastLine].length,
+    startLine: start + 1
+  };
+}
+function windowScan(comparisonLines, needleLines, offsets, originalLines, eq) {
+  const n = needleLines.length;
+  const out = [];
+  for (let i = 0; i + n <= comparisonLines.length; i++) {
+    let all = true;
+    for (let j = 0; j < n; j++) {
+      if (!eq(comparisonLines[i + j], needleLines[j])) {
+        all = false;
+        break;
+      }
+    }
+    if (all) {
+      out.push(windowToMatch(originalLines, offsets, i, n));
+      i += n - 1;
+    }
+  }
+  return out;
+}
+function fuzzyScan(fileLines, needleLines, offsets) {
+  const n = needleLines.length;
+  if (n < 3) return void 0;
+  const firstNeedle = needleLines[0].trim();
+  const lastNeedle = needleLines[n - 1].trim();
+  const needleInterior = needleLines.slice(1, -1).map((l) => l.trim()).join("\n");
+  if (needleInterior.length > FUZZY_MAX_INTERIOR_CHARS) return void 0;
+  const candidates = [];
+  for (let i = 0; i + n <= fileLines.length; i++) {
+    if (fileLines[i].trim() !== firstNeedle) continue;
+    if (fileLines[i + n - 1].trim() !== lastNeedle) continue;
+    const windowInterior = fileLines.slice(i + 1, i + n - 1).map((l) => l.trim()).join("\n");
+    if (windowInterior.length > FUZZY_MAX_INTERIOR_CHARS) continue;
+    const score = similarity(needleInterior, windowInterior);
+    if (score >= FUZZY_MIN_SIMILARITY) {
+      candidates.push({ match: windowToMatch(fileLines, offsets, i, n), score });
+    }
+  }
+  if (candidates.length === 0) return void 0;
+  candidates.sort((a, b) => b.score - a.score);
+  const best = candidates[0];
+  const runnerUp = candidates[1];
+  if (runnerUp && best.score - runnerUp.score < FUZZY_AMBIGUITY_MARGIN) {
+    return {
+      tier: "fuzzy",
+      matches: candidates.map((c) => c.match),
+      score: best.score,
+      ambiguous: true
+    };
+  }
+  return { tier: "fuzzy", matches: [best.match], score: best.score };
+}
+function similarity(a, b) {
+  if (a === b) return 1;
+  const max = Math.max(a.length, b.length);
+  if (max === 0) return 1;
+  if (Math.abs(a.length - b.length) / max > 1 - FUZZY_MIN_SIMILARITY + 0.05) {
+    return 1 - Math.abs(a.length - b.length) / max;
+  }
+  return 1 - levenshtein(a, b) / max;
+}
+function levenshtein(a, b) {
+  if (a.length === 0) return b.length;
+  if (b.length === 0) return a.length;
+  let prev = new Array(b.length + 1);
+  let cur = new Array(b.length + 1);
+  for (let j = 0; j <= b.length; j++) prev[j] = j;
+  for (let i = 1; i <= a.length; i++) {
+    cur[0] = i;
+    const ca = a.charCodeAt(i - 1);
+    for (let j = 1; j <= b.length; j++) {
+      const cost = ca === b.charCodeAt(j - 1) ? 0 : 1;
+      cur[j] = Math.min(
+        prev[j] + 1,
+        cur[j - 1] + 1,
+        prev[j - 1] + cost
+      );
+    }
+    [prev, cur] = [cur, prev];
+  }
+  return prev[b.length];
+}
+function firstLineIndent(text) {
+  for (const line of text.split("\n")) {
+    if (line.trim() === "") continue;
+    return /^[ \t]*/.exec(line)[0];
+  }
+  return "";
+}
+function adjustIndent(newLf, fromIndent, toIndent) {
+  if (fromIndent === toIndent) return { text: newLf, adjusted: false };
+  const lines = newLf.split("\n");
+  if (toIndent.startsWith(fromIndent)) {
+    const extra = toIndent.slice(fromIndent.length);
+    return {
+      text: lines.map((l) => l.trim() === "" ? l : extra + l).join("\n"),
+      adjusted: true
+    };
+  }
+  if (fromIndent.startsWith(toIndent)) {
+    const remove = fromIndent.slice(toIndent.length);
+    return {
+      text: lines.map((l) => l.startsWith(remove) ? l.slice(remove.length) : l).join("\n"),
+      adjusted: true
+    };
+  }
+  return { text: newLf, adjusted: false };
+}
+function nearestMatchHint(fileLf, oldLf) {
+  const fileLines = fileLf.split("\n");
+  const needleLines = oldLf.split("\n");
+  if (needleLines.length > fileLines.length) return void 0;
+  const needleTrimmed = needleLines.map((l) => l.trim());
+  let bestScore = 0;
+  let bestStart = -1;
+  for (let i = 0; i + needleLines.length <= fileLines.length; i++) {
+    let sum = 0;
+    for (let j = 0; j < needleLines.length; j++) {
+      sum += prefixSimilarity(needleTrimmed[j], fileLines[i + j].trim());
+    }
+    const score = sum / needleLines.length;
+    if (score > bestScore) {
+      bestScore = score;
+      bestStart = i;
+    }
+  }
+  if (bestStart === -1 || bestScore < 0.5) return void 0;
+  const snippet = fileLines.slice(bestStart, bestStart + Math.min(3, needleLines.length)).map((l) => l.length > 120 ? `${l.slice(0, 120)}\u2026` : l).join("\n");
+  return { line: bestStart + 1, snippet };
+}
+function prefixSimilarity(a, b) {
+  if (a === b) return 1;
+  const max = Math.max(a.length, b.length);
+  if (max === 0) return 1;
+  let p = 0;
+  const lim = Math.min(a.length, b.length);
+  while (p < lim && a.charCodeAt(p) === b.charCodeAt(p)) p++;
+  return p / max;
+}
+
+// src/edit.ts
+var MAX_DIFF_BYTES = 262144;
+var editTool = {
+  name: "edit",
+  category: "Filesystem",
+  description: "Perform a precise, surgical text replacement in a file. This is the preferred tool for modifying existing code. It works best after a prior `read`, but can auto-read the current file when the replacement is still unambiguous. Fails safely if the `old_string` appears more than once unless `replace_all` is set.",
+  usageHint: "RECOMMENDED WORKFLOW:\n1. Prefer calling `read` on the target file first when planning an edit.\n2. Use a sufficiently unique `old_string` (include surrounding lines/context if needed).\n3. If the string appears multiple times and you want to change all of them, set `replace_all: true`.\n4. `new_string` must be the exact replacement text.\n\nIf no prior read is recorded, the tool auto-reads the current file and only applies the edit after the same ambiguity checks pass.\nIf `old_string` differs from the file only in whitespace (trailing spaces, indentation), a lower-confidence fallback match is applied and reported in `matched_by`/`note` \u2014 always verify the diff when this happens.\nAfter the edit, TS/JS/JSON files are syntax-checked; if `syntax_errors` is present in the output, fix those errors immediately with a follow-up edit.",
+  selection: {
+    doNotUseWhen: "creating a new file, replacing the whole file, or applying an existing unified diff.",
+    useInstead: ["write", "patch"]
+  },
+  permission: "confirm",
+  // WS-046: gives permission decisions something to key on — the file being
+  // edited, so trust rules can scope by path.
+  subjectKey: "path",
+  mutating: true,
+  capabilities: ["fs.write"],
+  icon: "edit",
+  timeoutMs: 5e3,
+  maxOutputBytes: 262144,
+  inputSchema: {
+    type: "object",
+    properties: {
+      path: {
+        type: "string",
+        description: "Path to the file to edit \u2014 relative to the project root, or absolute inside it."
+      },
+      old_string: {
+        type: "string",
+        description: "The exact text to replace, including whitespace and indentation. Must be unique in the file unless `replace_all` is set \u2014 add surrounding lines to disambiguate."
+      },
+      new_string: {
+        type: "string",
+        description: "The exact replacement text (may be empty to delete `old_string`)."
+      },
+      replace_all: {
+        type: "boolean",
+        description: "Replace every occurrence instead of requiring a unique match. Only allowed when `old_string` matches exactly (or up to trailing whitespace) \u2014 fuzzy matches stay single-target."
+      }
+    },
+    required: ["path", "old_string", "new_string"]
+  },
+  async execute(input, ctx, opts) {
+    if (!input?.path) {
+      throw new ToolValidationError({ message: "edit: path is required", field: "path" });
+    }
+    if (input.old_string === void 0) {
+      throw new ToolValidationError({
+        message: "edit: old_string is required",
+        field: "old_string"
+      });
+    }
+    if (input.new_string === void 0) {
+      throw new ToolValidationError({
+        message: "edit: new_string is required",
+        field: "new_string"
+      });
+    }
+    if (input.old_string === "") {
+      throw new ToolValidationError({
+        message: "edit: old_string cannot be empty",
+        field: "old_string"
+      });
+    }
+    const absPath = await safeResolveReal(input.path, ctx);
+    const stat2 = await fs.stat(absPath).catch((err) => {
+      if (err.code === "ENOENT") {
+        throw new ToolValidationError({
+          message: `edit: file "${input.path}" does not exist. Use \`write\` instead.`,
+          field: "path",
+          context: { exists: false }
+        });
+      }
+      throw err;
+    });
+    if (!stat2.isFile()) {
+      throw new ToolValidationError({
+        message: `edit: "${input.path}" is not a regular file`,
+        field: "path"
+      });
+    }
+    const autoRead = !ctx.hasRead(absPath);
+    const original = await fs.readFile(absPath, "utf8");
+    const updated = await fs.stat(absPath);
+    const mtimeTolerance = process.platform === "win32" ? 2e3 : 1;
+    const originalHash = sha256hex(original);
+    const lastReadHash = ctx.lastReadHash?.(absPath);
+    if (lastReadHash !== void 0) {
+      if (lastReadHash !== originalHash) {
+        throw new ToolValidationError({
+          message: `edit: file "${input.path}" was modified externally. Re-read it first.`,
+          field: "path",
+          context: { reason: "external_modification" }
+        });
+      }
+    } else {
+      const lastReadMtime = ctx.lastReadMtime(absPath);
+      if (lastReadMtime !== void 0 && updated.mtimeMs > lastReadMtime + mtimeTolerance) {
+        throw new ToolValidationError({
+          message: `edit: file "${input.path}" was modified externally. Re-read it first.`,
+          field: "path",
+          context: { reason: "external_modification" }
+        });
+      }
+    }
+    if (autoRead && updated.mtimeMs > stat2.mtimeMs + mtimeTolerance) {
+      throw new ToolValidationError({
+        message: `edit: file "${input.path}" changed while being auto-read. Retry the edit.`,
+        field: "path",
+        context: { reason: "auto_read_race" }
+      });
+    }
+    const autoReadNote = autoRead ? `No prior read was recorded for "${input.path}"; edit auto-read the current file and applied the replacement only after the ambiguity checks passed.` : void 0;
+    const style = detectNewlineStyle(original);
+    const fileLf = normalizeToLf(original);
+    const oldLf = normalizeToLf(input.old_string);
+    const newLf = normalizeToLf(input.new_string);
+    if (oldLf === newLf) {
+      if (!fileLf.includes(oldLf)) {
+        throw noMatchError(input.path, fileLf, oldLf);
+      }
+      if (autoRead) ctx.recordRead(absPath, updated.mtimeMs, "user", originalHash);
+      return {
+        path: absPath,
+        replacements: 0,
+        diff: "(no-op: old and new are identical)",
+        matched_by: "exact",
+        note: autoReadNote
+      };
+    }
+    opts?.signal?.throwIfAborted();
+    const ladder = findLadderMatches(fileLf, oldLf);
+    if (!ladder) {
+      opts?.signal?.throwIfAborted();
+      throw noMatchError(input.path, fileLf, oldLf);
+    }
+    const { tier, matches } = ladder;
+    const count = matches.length;
+    if (ladder.ambiguous) {
+      const lines = matches.map((m) => m.startLine);
+      throw new ToolValidationError({
+        message: `edit: old_string only matched fuzzily and ${count} candidate blocks scored too close to distinguish (lines: ${lines.join(", ")}) in "${input.path}". Re-read the file and use the exact text of the intended block.`,
+        field: "old_string",
+        context: { occurrences: count, matchTier: tier }
+      });
+    }
+    if (input.replace_all && tier !== "exact" && tier !== "trailing-whitespace") {
+      throw new ToolValidationError({
+        message: `edit: old_string only matched via ${TIER_LABEL[tier]} in "${input.path}", but replace_all requires an exact (or trailing-whitespace) match. Re-read the file and use its exact text.`,
+        field: "old_string",
+        context: { matchTier: tier }
+      });
+    }
+    if (count > 1 && !input.replace_all) {
+      const lines = matches.map((m) => m.startLine);
+      throw new ToolValidationError({
+        message: `edit: old_string matched ${count} times in "${input.path}" (lines: ${lines.join(", ")})${tier === "exact" ? "" : ` via ${TIER_LABEL[tier]}`}. Add more context to make it unique, or set replace_all: true.`,
+        field: "old_string",
+        context: { occurrences: count, matchTier: tier }
+      });
+    }
+    let newFileLf;
+    let tierNote;
+    if (tier === "exact") {
+      newFileLf = input.replace_all ? fileLf.split(oldLf).join(newLf) : fileLf.replace(oldLf, newLf);
+    } else {
+      let replacement = newLf;
+      let indentSuffix = "";
+      if (tier === "whitespace-normalized" || tier === "fuzzy") {
+        const first = matches[0];
+        const matchedText = fileLf.slice(first.start, first.end);
+        const adjusted = adjustIndent(newLf, firstLineIndent(oldLf), firstLineIndent(matchedText));
+        replacement = adjusted.text;
+        if (adjusted.adjusted) indentSuffix = "; replacement re-indented to match the file";
+      }
+      newFileLf = fileLf;
+      const applied = input.replace_all ? matches : matches.slice(0, 1);
+      for (let i = applied.length - 1; i >= 0; i--) {
+        const m = applied[i];
+        newFileLf = newFileLf.slice(0, m.start) + replacement + newFileLf.slice(m.end);
+      }
+      const scoreSuffix = ladder.score !== void 0 ? `, similarity ${(ladder.score * 100).toFixed(1)}%` : "";
+      tierNote = `old_string did not match exactly; applied via ${TIER_LABEL[tier]} at line ${matches[0].startLine} (confidence: ${TIER_CONFIDENCE[tier]}${scoreSuffix}${indentSuffix}). Review the diff to confirm the intended target was edited.`;
+    }
+    const newFile = toStyle(newFileLf, style);
+    opts?.signal?.throwIfAborted();
+    await atomicWrite(absPath, newFile, { mode: updated.mode & 511 });
+    try {
+      enqueueReindex({ projectRoot: ctx.projectRoot, files: [absPath] });
+    } catch {
+    }
+    const written = await fs.stat(absPath);
+    ctx.recordRead(absPath, written.mtimeMs, "write", sha256hex(newFile));
+    ctx.session?.recordFileChange?.({
+      path: absPath,
+      action: "modified",
+      before: original,
+      after: newFile
+    });
+    opts?.signal?.throwIfAborted();
+    const { text: diff, truncated: diffTruncated } = truncateDiffPayload(
+      unifiedDiff(original, newFile, {
+        fromFile: input.path,
+        toFile: input.path
+      }),
+      MAX_DIFF_BYTES
+    );
+    const diffNote = diffTruncated ? "Diff truncated to the 256 KiB output budget \u2014 the full edit is on disk." : void 0;
+    const syntax = await checkSyntax(absPath, newFile, original).catch(() => void 0);
+    let syntaxNote;
+    if (syntax && syntax.errors.length > 0) {
+      syntaxNote = syntax.preExisting ? `Syntax check: the file still has parse errors (they pre-date this edit) \u2014 see syntax_errors.` : `Syntax check: this edit introduced ${syntax.errors.length} parse error(s) \u2014 fix them now, see syntax_errors.`;
+    }
+    const notes = [autoReadNote, tierNote, diffNote, syntaxNote].filter(Boolean);
+    return {
+      path: absPath,
+      replacements: input.replace_all ? count : 1,
+      diff,
+      matched_by: tier,
+      syntax_errors: syntax && syntax.errors.length > 0 ? syntax.errors : void 0,
+      note: notes.length > 0 ? notes.join("\n") : void 0
+    };
+  }
+};
+function noMatchError(inputPath, fileLf, oldLf) {
+  const hint = nearestMatchHint(fileLf, oldLf);
+  return new ToolValidationError({
+    message: `edit: no match for old_string in "${inputPath}".${hint ? ` Nearest match near line ${hint.line}:
+${hint.snippet}
+Compare this against your old_string and retry with the file's actual text.` : ""}`,
+    field: "old_string"
+  });
+}
+
+export {
+  editTool
+};
+//# sourceMappingURL=chunk-ZJQ4IGXK.js.map