@wrongstack/tools 0.318.0 → 0.319.1

package/dist/{chunk-MRZOVQ5D.js → chunk-IYKXK356.js}

@@ -1,3 +1,7 @@
+import {
+  getProcessRegistry,
+  redactCommand
+} from "./chunk-3PVYQFRQ.js";
 import {
   buildWin32CmdShimInvocation,
   resolveWin32Command
@@ -7,10 +11,12 @@ import {
   detectPackageManager,
   normalizeCommandOutput,
   safeResolveReal
-} from "./chunk-D33S4RQG.js";
+} from "./chunk-ZUFHAHTE.js";
 
 // src/outdated.ts
 import { spawn } from "node:child_process";
+import { StringDecoder } from "node:string_decoder";
+import { ToolValidationError } from "@wrongstack/core/types";
 import { buildChildEnv } from "@wrongstack/core/utils";
 var outdatedTool = {
   name: "outdated",
@@ -48,12 +54,19 @@ var outdatedTool = {
     }
   },
   async execute(input, ctx, opts) {
+    if (input.cwd !== void 0 && (typeof input.cwd !== "string" || !input.cwd.trim())) {
+      throw new ToolValidationError({
+        message: "outdated: cwd must be a non-empty string when provided.",
+        field: "cwd"
+      });
+    }
     const cwd = input.cwd ? await safeResolveReal(input.cwd, ctx) : ctx.cwd;
     const signal = opts?.signal ?? ctx.signal ?? new AbortController().signal;
+    signal.throwIfAborted();
     const manager = await detectPackageManager(cwd, ctx.projectRoot);
     if (manager === "npm") {
       try {
-        const { detectNonJsEcosystem } = await import("./legacy-bridge-SFNXIRAP.js");
+        const { detectNonJsEcosystem } = await import("./legacy-bridge-3T7SR4SK.js");
         const nonJs = await detectNonJsEcosystem(cwd, ctx.projectRoot);
         if (nonJs) {
           const { planLanguageOperation, executePackagePlan } = await import("./languages/index.js");
@@ -107,10 +120,23 @@ var outdatedTool = {
   }
 };
 function runOutdated(manager, args, cwd, signal) {
+  if (signal.aborted) {
+    return Promise.resolve({
+      exit_code: 124,
+      packages: [],
+      total: 0,
+      output: "Aborted",
+      truncated: false
+    });
+  }
   return new Promise((resolve) => {
     let stdout = "";
     let stderr = "";
+    let stdoutBytes = 0;
+    let stderrBytes = 0;
     const MAX = 1e5;
+    const stdoutDecoder = new StringDecoder("utf8");
+    const stderrDecoder = new StringDecoder("utf8");
     const resolved = resolveWin32Command(manager);
     const needsShell = process.platform === "win32" && (resolved.endsWith(".cmd") || resolved.endsWith(".bat"));
     const shim = needsShell ? buildWin32CmdShimInvocation(resolved, args) : null;
@@ -124,17 +150,78 @@ function runOutdated(manager, args, cwd, signal) {
       windowsHide: true,
       ...shim ? { windowsVerbatimArguments: shim.windowsVerbatimArguments } : {}
     });
+    const registry = getProcessRegistry();
+    if (typeof child.pid === "number") {
+      registry.register({
+        pid: child.pid,
+        name: manager,
+        command: redactCommand(`${spawnCmd} ${args.join(" ")}`),
+        startedAt: Date.now(),
+        child
+      });
+    }
+    const onAbort = () => {
+      if (typeof child.pid === "number") {
+        registry.kill(child.pid, { force: true });
+      } else {
+        try {
+          child.kill("SIGKILL");
+        } catch {
+        }
+      }
+    };
+    if (signal) {
+      if (signal.aborted) onAbort();
+      else signal.addEventListener("abort", onAbort, { once: true });
+    }
     child.stdout?.on("data", (c) => {
-      if (stdout.length < MAX) stdout += c.toString();
+      stdoutBytes += c.byteLength;
+      if (stdout.length < MAX) {
+        const text = stdoutDecoder.write(c);
+        stdout += text.slice(0, MAX - stdout.length);
+      }
     });
     child.stderr?.on("data", (c) => {
-      if (stderr.length < MAX) stderr += c.toString();
+      stderrBytes += c.byteLength;
+      if (stderr.length < MAX) {
+        const text = stderrDecoder.write(c);
+        stderr += text.slice(0, MAX - stderr.length);
+      }
     });
     child.on("close", (code) => {
-      const result = parseOutdatedOutput(stdout, code ?? 0);
+      if (signal) signal.removeEventListener("abort", onAbort);
+      if (typeof child.pid === "number") registry.unregister(child.pid);
+      if (signal.aborted) {
+        resolve({
+          exit_code: 124,
+          packages: [],
+          total: 0,
+          output: "Aborted",
+          truncated: false
+        });
+        return;
+      }
+      const restOut = stdoutDecoder.end();
+      if (restOut && stdout.length < MAX) {
+        stdout += restOut.slice(0, MAX - stdout.length);
+      }
+      const isTruncated = stdoutBytes > MAX || stderrBytes > MAX || Buffer.byteLength(stdout, "utf8") > COMMAND_OUTPUT_MAX_BYTES;
+      const result = parseOutdatedOutput(stdout, code ?? 0, stderr, isTruncated);
       resolve(result);
     });
     child.on("error", (e) => {
+      if (signal) signal.removeEventListener("abort", onAbort);
+      if (typeof child.pid === "number") registry.unregister(child.pid);
+      if (signal.aborted || e.name === "AbortError") {
+        resolve({
+          exit_code: 124,
+          packages: [],
+          total: 0,
+          output: "Aborted",
+          truncated: false
+        });
+        return;
+      }
       resolve({
         exit_code: 1,
         packages: [],
@@ -145,18 +232,18 @@ function runOutdated(manager, args, cwd, signal) {
     });
   });
 }
-function parseOutdatedOutput(json, exitCode) {
+function parseOutdatedOutput(json, exitCode, stderr = "", truncated = false) {
   const packages = [];
   if (!json) {
     return {
       exit_code: exitCode,
       packages: [],
       total: 0,
-      output: exitCode === 0 ? "All packages up to date" : "Could not check outdated packages",
-      truncated: false
+      output: stderr || (exitCode === 0 ? "All packages up to date" : "Could not check outdated packages"),
+      truncated
     };
   }
-  const truncated = json.length >= 1e5 || Buffer.byteLength(json, "utf8") > COMMAND_OUTPUT_MAX_BYTES;
+  const isTruncated = truncated || json.length >= 1e5 || Buffer.byteLength(json, "utf8") > COMMAND_OUTPUT_MAX_BYTES;
   let parsedOk = false;
   try {
     const data = JSON.parse(json);
@@ -188,11 +275,11 @@ Note: exit code 1 from \`outdated\` means outdated packages were found (expected
     packages,
     total: packages.length,
     output,
-    truncated
+    truncated: isTruncated
   };
 }
 
 export {
   outdatedTool
 };
-//# sourceMappingURL=chunk-MRZOVQ5D.js.map
+//# sourceMappingURL=chunk-IYKXK356.js.map

package/dist/{chunk-6GZPSWP3.js → chunk-JDPQOR7C.js}

@@ -7,7 +7,7 @@ import {
 import {
   assertRealInsideRoot,
   safeResolveReal
-} from "./chunk-D33S4RQG.js";
+} from "./chunk-ZUFHAHTE.js";
 
 // src/glob.ts
 import * as fs from "node:fs/promises";
@@ -52,9 +52,9 @@ var globTool = {
     required: ["pattern"]
   },
   async execute(input, ctx, opts) {
-    if (!input?.pattern) {
+    if (!input?.pattern || typeof input.pattern !== "string" || !input.pattern.trim()) {
       throw new ToolValidationError({
-        message: "glob: pattern is required",
+        message: "glob: pattern is required and cannot be empty",
         field: "pattern"
       });
     }
@@ -63,10 +63,12 @@ var globTool = {
       return { files: [], truncated: true };
     }
     const base = input.path ? await safeResolveReal(input.path, ctx) : ctx.cwd;
-    const limit = Math.max(1, Math.min(input.limit ?? 1e3, 5e3));
+    const rawLimit = typeof input.limit === "number" && !Number.isNaN(input.limit) ? input.limit : 1e3;
+    const limit = Math.max(1, Math.min(Math.floor(rawLimit), 5e3));
     const isGitIgnored = await loadGitignoreMatcher(base);
     const re = compileGlob(input.pattern);
     const results = [];
+    const visitedRealDirs = /* @__PURE__ */ new Set();
     let truncated = false;
     const pushResult = async (full) => {
       if (signal?.aborted || truncated || results.length >= limit) {
@@ -89,6 +91,9 @@ var globTool = {
         truncated = true;
         return;
       }
+      const realDir = await fs.realpath(dir).catch(() => dir);
+      if (visitedRealDirs.has(realDir)) return;
+      visitedRealDirs.add(realDir);
       if (results.length >= limit) {
         truncated = true;
         return;
@@ -111,7 +116,8 @@ var globTool = {
           subdirs.push({ full, rel });
         } else if (e.isFile()) {
           if (isGitIgnored(rel, false)) continue;
-          if (re.test(rel) || re.test(name)) {
+          re.lastIndex = 0;
+          if (re.test(rel) || (re.lastIndex = 0, re.test(name))) {
             matchedFiles.push(full);
           }
         } else if (e.isSymbolicLink()) {
@@ -126,7 +132,8 @@ var globTool = {
               if (isGitIgnored(rel, false)) continue;
               const real = await fs.realpath(full);
               await assertRealInsideRoot(real, ctx);
-              if (re.test(rel) || re.test(name)) matchedFiles.push(full);
+              re.lastIndex = 0;
+              if (re.test(rel) || (re.lastIndex = 0, re.test(name))) matchedFiles.push(full);
             }
           } catch {
           }
@@ -151,4 +158,4 @@ var globTool = {
 export {
   globTool
 };
-//# sourceMappingURL=chunk-6GZPSWP3.js.map
+//# sourceMappingURL=chunk-JDPQOR7C.js.map

package/dist/{chunk-BLCSYKNN.js → chunk-KY4PXYSO.js}

@@ -1,6 +1,6 @@
 import {
   parseFilesContent
-} from "./chunk-JJQB6R7Y.js";
+} from "./chunk-CMOUCKGC.js";
 import {
   INDEXABLE_EXTENSIONS,
   LANG_FAMILY_ENTRIES,
@@ -514,7 +514,9 @@ function encodeVector(vec) {
 function decodeVector(buf) {
   if (buf.byteLength === 0) return new Float32Array(0);
   if (buf.byteLength % 4 !== 0) {
-    throw new Error(`decodeVector: invalid vector byteLength ${buf.byteLength} (must be a multiple of 4)`);
+    throw new Error(
+      `decodeVector: invalid vector byteLength ${buf.byteLength} (must be a multiple of 4)`
+    );
   }
   const copy = new Float32Array(buf.byteLength / 4);
   new Uint8Array(copy.buffer).set(buf);
@@ -636,10 +638,7 @@ function bulkInsertSymbolsWithStatement(stmt, maxSqlVars, rows) {
   for (const take of ladder) {
     const chunk = rows.slice(cursor, cursor + take);
     cursor += take;
-    const placeholders2 = getRowPlaceholders(
-      "(?, ?, ?, ?, ?, ?, ?, ?, ?, ?)",
-      chunk.length
-    );
+    const placeholders2 = getRowPlaceholders("(?, ?, ?, ?, ?, ?, ?, ?, ?, ?)", chunk.length);
     const insert = stmt(
       `INSERT INTO symbols(id, lang, kind, name, file, line, col, signature, doc_comment, scope)
        VALUES ${placeholders2}`
@@ -697,10 +696,7 @@ function bulkInsertRefsWithStatement(stmt, maxSqlVars, refs) {
   for (const take of ladder) {
     const chunk = refs.slice(cursor, cursor + take);
     cursor += take;
-    const placeholders2 = getRowPlaceholders(
-      "(?, ?, ?, ?, ?, ?, ?, ?)",
-      chunk.length
-    );
+    const placeholders2 = getRowPlaceholders("(?, ?, ?, ?, ?, ?, ?, ?)", chunk.length);
     const insert = stmt(
       `INSERT INTO refs(from_id, to_name, to_id, call_type, line, lang, module, to_file)
        VALUES ${placeholders2}`
@@ -1769,9 +1765,7 @@ function commitBatchWithStatement(stmtFn, maxSqlVars, ftsAvailable, vectorsAvail
       if (vectorsAvailable) {
         vectorRows.push({
           id,
-          vector: encodeVector(
-            embedText(buildIndexableText(s.name, s.signature, s.docComment))
-          )
+          vector: encodeVector(embedText(buildIndexableText(s.name, s.signature, s.docComment)))
         });
       }
       const inserted = { ...s, id };
@@ -1923,6 +1917,7 @@ var SYMBOL_VECTORS_TABLE_SQL = `
 // src/codebase-index/writer-refs.ts
 var FAMILY_MATCH_SQL = `(
   sym.lang = refs.lang
+  OR refs.lang = ''
   OR EXISTS (
     SELECT 1 FROM lang_family lf1
       JOIN lang_family lf2 ON lf1.family = lf2.family
@@ -3824,7 +3819,7 @@ var ParserWorkerPool = class {
    */
   async reparseInline(batch, orphaned, workerId) {
     try {
-      const { parseFileContent } = await import("./parser-dispatch-X62UWXJS.js");
+      const { parseFileContent } = await import("./parser-dispatch-QGC4HSP5.js");
       for (const item of orphaned) {
         if (batch.settled) return;
         try {
@@ -4613,4 +4608,4 @@ export {
   incomingCallsService,
   outgoingCallsService
 };
-//# sourceMappingURL=chunk-BLCSYKNN.js.map
+//# sourceMappingURL=chunk-KY4PXYSO.js.map

package/dist/{chunk-WJYXMB2R.js → chunk-LOBRWKCR.js}

@@ -1,15 +1,16 @@
 import {
   tryLegacyCodeOperation
-} from "./chunk-4E42D7UF.js";
+} from "./chunk-ATSKPZUK.js";
 import {
   spawnStream
 } from "./chunk-ZHH3BEWU.js";
 import {
   normalizeCommandOutput,
   safeResolveReal
-} from "./chunk-D33S4RQG.js";
+} from "./chunk-ZUFHAHTE.js";
 
 // src/lint.ts
+import { ToolValidationError } from "@wrongstack/core/types";
 var lintTool = {
   name: "lint",
   category: "Code Quality",
@@ -49,6 +50,14 @@ var lintTool = {
   async *executeStream(input, ctx, opts) {
     const cwd = input.cwd ? await safeResolveReal(input.cwd, ctx) : ctx.cwd;
     const signal = opts?.signal ?? ctx.signal ?? new AbortController().signal;
+    signal.throwIfAborted();
+    const VALID_LINTERS = /* @__PURE__ */ new Set(["biome", "eslint", "tslint", "auto"]);
+    if (input.linter !== void 0 && !VALID_LINTERS.has(input.linter)) {
+      throw new ToolValidationError({
+        message: `lint: unsupported linter "${input.linter}". Allowed linters: biome, eslint, tslint, auto`,
+        field: "linter"
+      });
+    }
     const linter = input.linter ?? "auto";
     if (linter === "auto" && !input.files) {
       const bridge = await tryLegacyCodeOperation("lint", {
@@ -90,24 +99,49 @@ var lintTool = {
       return;
     }
     yield { type: "log", text: `Running ${detected}\u2026`, data: { linter: detected } };
-    const args = ["lint"];
-    if (input.fix) args.push("--write");
-    if (input.files) {
-      const files = Array.isArray(input.files) ? input.files : input.files.split(",");
-      args.push("--", ...files.map((f) => f.trim()));
+    const files = input.files ? (Array.isArray(input.files) ? input.files : input.files.split(",")).map((f) => f.trim().replace(/\\/g, "/")).filter(Boolean) : [];
+    const args = [];
+    if (detected === "eslint") {
+      if (input.fix) args.push("--fix");
+      if (files.length) args.push(...files);
+    } else {
+      args.push("lint");
+      if (input.fix) args.push("--write");
+      if (files.length) args.push("--", ...files);
     }
     const cmd = detected === "biome" ? "biome" : detected;
     const result = yield* spawnStream({ cmd, args, cwd, signal, maxBytes: 1e5 });
-    const errors = [...result.stdout.matchAll(/\berror\b/gi)].length;
-    const warnings = [...result.stdout.matchAll(/\bwarning\b/gi)].length;
+    const combined = `${result.stdout}
+${result.stderr}`;
+    let errors = 0;
+    let warnings = 0;
+    const biomeSummary = combined.match(/Found\s+(\d+)\s+errors?(?:\s+and\s+(\d+)\s+warnings?)?/i);
+    const eslintSummary = combined.match(
+      /(\d+)\s+problems?\s+\((\d+)\s+errors?,\s*(\d+)\s+warnings?\)/i
+    );
+    if (biomeSummary) {
+      errors = Number.parseInt(biomeSummary[1] ?? "0", 10);
+      warnings = Number.parseInt(biomeSummary[2] ?? "0", 10);
+    } else if (eslintSummary) {
+      errors = Number.parseInt(eslintSummary[2] ?? "0", 10);
+      warnings = Number.parseInt(eslintSummary[3] ?? "0", 10);
+    } else {
+      errors = [...combined.matchAll(/\berror\b/gi)].length;
+      warnings = [...combined.matchAll(/\bwarning\b/gi)].length;
+    }
+    if (errors === 0 && result.exitCode !== 0) {
+      errors = 1;
+    }
+    const rawOutput = result.stdout && result.stderr ? `${result.stdout}
+${result.stderr}` : result.stdout || result.stderr || result.error || "";
     yield {
       type: "final",
       output: {
         linter: detected,
-        files_checked: input.files ? Array.isArray(input.files) ? input.files.length : input.files.split(",").length : 0,
+        files_checked: files.length,
         errors,
         warnings,
-        output: normalizeCommandOutput(result.stdout),
+        output: normalizeCommandOutput(rawOutput),
         fix_applied: input.fix ?? false,
         truncated: result.truncated
       }
@@ -116,10 +150,25 @@ var lintTool = {
 };
 async function detectLinter(cwd) {
   const { stat } = await import("node:fs/promises");
-  const checks = ["biome.json", ".eslintrc.json", "tslint.json", ".eslintrc.js", "tsconfig.json"];
+  const checks = [
+    "biome.json",
+    "biome.jsonc",
+    "eslint.config.js",
+    "eslint.config.mjs",
+    "eslint.config.cjs",
+    "eslint.config.ts",
+    ".eslintrc.json",
+    ".eslintrc.js",
+    ".eslintrc.cjs",
+    ".eslintrc.yaml",
+    ".eslintrc.yml",
+    "tslint.json",
+    "tsconfig.json"
+  ];
   for (const f of checks) {
     try {
-      await stat(`${cwd}/${f}`);
+      const { join } = await import("node:path");
+      await stat(join(cwd, f));
       if (f.includes("biome")) return "biome";
       if (f.includes("eslint")) return "eslint";
       if (f.includes("tslint")) return "tslint";
@@ -132,4 +181,4 @@ async function detectLinter(cwd) {
 export {
   lintTool
 };
-//# sourceMappingURL=chunk-WJYXMB2R.js.map
+//# sourceMappingURL=chunk-LOBRWKCR.js.map

package/dist/{chunk-J5SKD6LN.js → chunk-MNP3GE7H.js}

@@ -1,11 +1,11 @@
 import {
   safeResolveReal
-} from "./chunk-D33S4RQG.js";
+} from "./chunk-ZUFHAHTE.js";
 
 // src/tree.ts
 import * as fs from "node:fs/promises";
 import * as path from "node:path";
-import { DEFAULT_WALK_IGNORE_DIRS, compileGlob, expectDefined } from "@wrongstack/core/utils";
+import { compileGlob, DEFAULT_WALK_IGNORE_DIRS, expectDefined } from "@wrongstack/core/utils";
 var DEFAULT_IGNORE = /* @__PURE__ */ new Set([
   ...DEFAULT_WALK_IGNORE_DIRS,
   ".wrongstack",
@@ -80,14 +80,20 @@ var treeTool = {
   },
   async *executeStream(input, ctx, opts) {
     const basePath = input.path ? await safeResolveReal(input.path, ctx) : ctx.cwd;
-    const maxDepth = input.depth ?? 3;
+    const maxDepth = typeof input.depth === "number" && Number.isFinite(input.depth) && input.depth >= 0 ? Math.floor(input.depth) : 3;
     const showFiles = input.show_files ?? true;
     const showDirs = input.show_dirs ?? true;
     const showHidden = input.show_hidden ?? false;
-    const exclude = /* @__PURE__ */ new Set([...DEFAULT_IGNORE, ...input.exclude ?? []]);
+    const exclude = /* @__PURE__ */ new Set([
+      ...DEFAULT_IGNORE,
+      ...(input.exclude ?? []).map(
+        (s) => s.trim().replace(/[\\/]+$/, "").replace(/^\.\//, "")
+      ).filter(Boolean)
+    ]);
     const globRe = input.glob ? compileGlob(input.glob) : void 0;
-    const maxEntries = input.max_entries ?? DEFAULT_MAX_ENTRIES;
+    const maxEntries = typeof input.max_entries === "number" && Number.isFinite(input.max_entries) && input.max_entries > 0 ? Math.floor(input.max_entries) : DEFAULT_MAX_ENTRIES;
     const signal = opts?.signal ?? ctx.signal ?? new AbortController().signal;
+    signal.throwIfAborted();
     const lines = [basePath];
     const totals = { totalFiles: { value: 0 }, totalDirs: { value: 0 } };
     const retention = {
@@ -100,6 +106,7 @@ var treeTool = {
     const queue = [];
     const FLUSH_EVERY = 200;
     let lastEmittedTotal = 0;
+    let wakeWaiter;
     const tickProgress = () => {
       const seen = totals.totalFiles.value + totals.totalDirs.value;
       if (seen - lastEmittedTotal >= FLUSH_EVERY) {
@@ -109,6 +116,7 @@ var treeTool = {
           data: { files: totals.totalFiles.value, dirs: totals.totalDirs.value }
         });
         lastEmittedTotal = seen;
+        wakeWaiter?.();
       }
     };
     const walkPromise = walkDir(basePath, 0, {
@@ -129,27 +137,20 @@ var treeTool = {
       signal
     });
     let walkDone = false;
-    void walkPromise.then(
-      () => {
-        walkDone = true;
-      },
-      () => {
-        walkDone = true;
-      }
-    );
+    void walkPromise.catch(() => {
+    }).finally(() => {
+      walkDone = true;
+      wakeWaiter?.();
+    });
     while (!walkDone || queue.length > 0) {
       if (queue.length > 0) {
         yield expectDefined(queue.shift());
       } else {
-        let pollTimer;
-        const poll = new Promise((r) => {
-          pollTimer = setTimeout(r, 50);
+        await new Promise((resolve) => {
+          wakeWaiter = resolve;
+          if (walkDone || queue.length > 0) resolve();
         });
-        try {
-          await Promise.race([walkPromise, poll]).catch(() => void 0);
-        } finally {
-          if (pollTimer) clearTimeout(pollTimer);
-        }
+        wakeWaiter = void 0;
       }
     }
     await walkPromise;
@@ -166,10 +167,17 @@ var treeTool = {
   }
 };
 function matchesTreeGlob(globRe, fileName, absPath, basePath) {
-  if (globRe.test(fileName)) return true;
+  globRe.lastIndex = 0;
+  if (globRe.test(fileName)) {
+    globRe.lastIndex = 0;
+    return true;
+  }
+  globRe.lastIndex = 0;
   const rel = path.relative(basePath, absPath);
   const posixRel = !rel || rel.startsWith("..") || path.isAbsolute(rel) ? absPath.split(path.sep).join("/") : rel.split(path.sep).join("/");
-  return globRe.test(posixRel);
+  const matches = globRe.test(posixRel);
+  globRe.lastIndex = 0;
+  return matches;
 }
 async function walkDir(dir, depth, opts) {
   opts.signal.throwIfAborted();
@@ -178,6 +186,8 @@ async function walkDir(dir, depth, opts) {
   const filtered = entries.filter((e) => {
     if (!opts.showHidden && e.name.startsWith(".")) return false;
     if (opts.exclude.has(e.name)) return false;
+    const rel = path.relative(opts.basePath, path.join(dir, e.name)).split(path.sep).join("/");
+    if (opts.exclude.has(rel)) return false;
     if (e.isFile() && opts.globRe) {
       const abs = path.join(dir, e.name);
       if (!matchesTreeGlob(opts.globRe, e.name, abs, opts.basePath)) return false;
@@ -204,11 +214,12 @@ async function walkDir(dir, depth, opts) {
     const entry = items[i];
     if (!entry) continue;
     const isLast = i === items.length - 1;
-    const connector = opts.isLast ? "    " : "\u2502   ";
+    const connector = isLast ? "    " : "\u2502   ";
     const branch = isLast ? "\u2514\u2500\u2500 " : "\u251C\u2500\u2500 ";
     const displayName = entry.name + (entry.isDirectory() ? "/" : "");
-    if (!opts.showDirs && entry.isDirectory()) continue;
-    if (!opts.showFiles && entry.isFile()) continue;
+    const isDir = entry.isDirectory();
+    if (!opts.showDirs && isDir) continue;
+    if (!opts.showFiles && !isDir) continue;
     const line = opts.prefix + branch + displayName;
     const lineBytes = Buffer.byteLength(line, "utf8") + 1;
     if (opts.retention.entries >= opts.retention.maxEntries || opts.retention.outputBytes + lineBytes > opts.retention.maxOutputBytes) {
@@ -232,4 +243,4 @@ async function walkDir(dir, depth, opts) {
 export {
   treeTool
 };
-//# sourceMappingURL=chunk-J5SKD6LN.js.map
+//# sourceMappingURL=chunk-MNP3GE7H.js.map

package/dist/{chunk-S2GBLQ5S.js → chunk-O44IMQCN.js}

@@ -3,16 +3,16 @@ import {
 } from "./chunk-FQZOHLG3.js";
 import {
   enqueueReindex
-} from "./chunk-VZLX2JZG.js";
+} from "./chunk-DP6CXMJZ.js";
 import {
   safeResolveReal,
   sha256hex,
   truncateDiffPayload
-} from "./chunk-D33S4RQG.js";
+} from "./chunk-ZUFHAHTE.js";
 
 // src/write.ts
 import * as fs from "node:fs/promises";
-import { ToolValidationError } from "@wrongstack/core/types";
+import { FsError, ToolValidationError } from "@wrongstack/core/types";
 import {
   atomicWrite,
   detectNewlineStyle,
@@ -72,6 +72,15 @@ var writeTool = {
     yield { type: "final", output: await finishWrite(input, ctx, prepared, signal) };
   }
 };
+function countLines(text) {
+  if (!text) return 0;
+  const trimmed = text.endsWith("\n") ? text.slice(0, -1) : text;
+  let count = 1;
+  for (let i = 0; i < trimmed.length; i++) {
+    if (trimmed.charCodeAt(i) === 10) count++;
+  }
+  return count;
+}
 async function writeFile(input, ctx, signal) {
   signal?.throwIfAborted();
   return finishWrite(input, ctx, await prepareWrite(input, ctx), signal);
@@ -94,6 +103,14 @@ async function prepareWrite(input, ctx) {
   let prev = "";
   try {
     const stat2 = await fs.stat(absPath);
+    if (stat2.isDirectory()) {
+      throw new FsError({
+        message: `write: "${input.path}" is an existing directory and cannot be overwritten`,
+        code: "FS_WRITE_FAILED",
+        path: absPath,
+        context: { reason: "is-directory" }
+      });
+    }
     existed = stat2.isFile();
     if (existed) {
       prev = await fs.readFile(absPath, "utf8");
@@ -116,11 +133,13 @@ async function finishWrite(input, ctx, prepared, signal) {
     enqueueReindex({ projectRoot: ctx.projectRoot, files: [prepared.absPath] });
   } catch {
   }
-  const rawDiff = prepared.existed ? unifiedDiff(prepared.prev, content, { fromFile: input.path, toFile: input.path }) : `+++ ${input.path}
-+ (new file, ${content.split("\n").length} lines)`;
+  const isIdentical = prepared.existed && prepared.prev === content;
+  const rawDiff = prepared.existed ? isIdentical ? "(no-op: file content is identical to existing content)" : unifiedDiff(prepared.prev, content, { fromFile: input.path, toFile: input.path }) : `+++ ${input.path}
++ (new file, ${countLines(content)} lines)`;
   const { text: diff, truncated: diffTruncated } = truncateDiffPayload(rawDiff, MAX_DIFF_BYTES);
+  const contentHash = sha256hex(content);
   const stat2 = await fs.stat(prepared.absPath);
-  ctx.recordRead(prepared.absPath, stat2.mtimeMs, "write", sha256hex(content));
+  ctx.recordRead(prepared.absPath, stat2.mtimeMs, "write", contentHash);
   ctx.session?.recordFileChange?.({
     path: prepared.absPath,
     action: prepared.existed ? "modified" : "created",
@@ -134,6 +153,11 @@ async function finishWrite(input, ctx, prepared, signal) {
   ).catch(() => void 0);
   const hasSyntaxErrors = syntax !== void 0 && syntax.errors.length > 0;
   const notes = [];
+  if (isIdentical) {
+    notes.push(
+      "Write completed with no content changes (new content is identical to existing content)."
+    );
+  }
   if (diffTruncated) {
     notes.push("Diff truncated to the 256 KiB output budget \u2014 the full write is on disk.");
   }
@@ -155,4 +179,4 @@ async function finishWrite(input, ctx, prepared, signal) {
 export {
   writeTool
 };
-//# sourceMappingURL=chunk-S2GBLQ5S.js.map
+//# sourceMappingURL=chunk-O44IMQCN.js.map