@wrongstack/tools 0.319.0 → 0.320.1

package/dist/{chunk-Z4VBTVUM.js → chunk-DFQDJT22.js}

@@ -1,16 +1,22 @@
+import {
+  getProcessRegistry,
+  redactCommand
+} from "./chunk-ESLPBT5A.js";
 import {
   buildWin32CmdShimInvocation,
   resolveWin32Command
-} from "./chunk-V43EQ6VR.js";
+} from "./chunk-KE7A76VC.js";
 import {
   COMMAND_OUTPUT_MAX_BYTES,
   detectPackageManager,
   normalizeCommandOutput,
   safeResolveReal
-} from "./chunk-QLF74MSV.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-EC7GM2IW.js");
+        const { detectNonJsEcosystem } = await import("./legacy-bridge-FOV5ODDI.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-Z4VBTVUM.js.map
+//# sourceMappingURL=chunk-DFQDJT22.js.map

package/dist/{chunk-6RNIFLG4.js → chunk-ELRRTWNP.js}

@@ -14,6 +14,8 @@ import {
   setActiveKit,
   setDesignOverrides
 } from "@wrongstack/core/design";
+import { ToolValidationError } from "@wrongstack/core/types";
+import { atomicWrite } from "@wrongstack/core/utils";
 async function resolveReal(p) {
   const resolved = path.resolve(p);
   let probe = resolved;
@@ -102,10 +104,33 @@ var designTool = {
     },
     required: []
   },
-  async execute(input, ctx) {
+  async execute(input, ctx, _opts) {
+    const signal = _opts?.signal ?? ctx?.signal;
+    signal?.throwIfAborted();
+    const VALID_ACTIONS = /* @__PURE__ */ new Set([
+      "list",
+      "use",
+      "foundations",
+      "set",
+      "tune",
+      "materialize",
+      "verify"
+    ]);
+    if (input.action !== void 0 && !VALID_ACTIONS.has(input.action)) {
+      throw new ToolValidationError({
+        message: `design: unknown action "${input.action}". Allowed actions: ${[...VALID_ACTIONS].join(", ")}`,
+        field: "action"
+      });
+    }
+    if (input.stack !== void 0 && !isDesignStack(input.stack)) {
+      throw new ToolValidationError({
+        message: `design: invalid stack "${input.stack}". Allowed stacks: web, react-native, flutter, swiftui, compose`,
+        field: "stack"
+      });
+    }
     const loader = getDesignKitLoader(ctx.projectRoot);
     const action = input.action ?? "list";
-    const stack = input.stack && isDesignStack(input.stack) ? input.stack : void 0;
+    const stack = input.stack;
     if (action === "foundations") {
       const text = await loader.foundationsText(stack);
       return { action, stack, output: text || "No foundations document is installed." };
@@ -231,7 +256,10 @@ Run \`design {action:"materialize"}\` to write the tuned tokens to your theme fi
       const abs = path.join(absParent, path.basename(absResolved));
       const rel = path.relative(root, abs);
       if (rel.startsWith("..") || path.isAbsolute(rel)) {
-        throw new Error(`design: materialize path "${result.path}" would escape the project root`);
+        throw new ToolValidationError({
+          message: `design: materialize path "${result.path}" would escape the project root`,
+          field: "out"
+        });
       }
       let exists = false;
       try {
@@ -253,7 +281,7 @@ ${result.content}
         };
       }
       await fs.mkdir(path.dirname(abs), { recursive: true });
-      await fs.writeFile(abs, result.content);
+      await atomicWrite(abs, result.content);
       return {
         action,
         kit: active.kit,
@@ -263,6 +291,7 @@ ${result.content}
       };
     }
     if (action === "verify") {
+      signal?.throwIfAborted();
       const active = await loadActiveKit(ctx.projectRoot);
       if (!active) {
         return {
@@ -270,12 +299,15 @@ ${result.content}
           output: 'No active kit to verify against. Pick one: `design {action:"use", kit:"<id>"}`.'
         };
       }
+      signal?.throwIfAborted();
       const rawTokens = await loader.readTokens(active.kit);
       if (!rawTokens) {
         return { action, kit: active.kit, output: `Kit "${active.kit}" has no tokens.json.` };
       }
+      signal?.throwIfAborted();
       const tokens = applyTokenOverrides(rawTokens, active.overrides);
-      const report = await runDesignVerify(ctx.projectRoot, tokens, input.files);
+      const normalizedFiles = input.files ? (Array.isArray(input.files) ? input.files : String(input.files).split(",")).map((f) => f.trim().replace(/\\/g, "/")).filter(Boolean) : void 0;
+      const report = await runDesignVerify(ctx.projectRoot, tokens, normalizedFiles);
       const pct = Math.round(report.score * 100);
       const top = report.violations.slice(0, 25).map((v) => `  ${v.file}:${v.line} \u2014 ${v.reason}: ${v.snippet}`).join("\n");
       const summary = `Adherence: ${pct}% on-palette across ${report.filesScanned} file(s). ${report.violations.length} violation(s).` + (report.violations.length ? `
@@ -302,4 +334,4 @@ Replace off-palette colors with kit tokens (or the materialized CSS vars / token
 export {
   designTool
 };
-//# sourceMappingURL=chunk-6RNIFLG4.js.map
+//# sourceMappingURL=chunk-ELRRTWNP.js.map

package/dist/{chunk-3PVYQFRQ.js → chunk-ESLPBT5A.js}

@@ -30,6 +30,7 @@ var SENSITIVE_FLAG_PATTERNS = [
   /--\w*(?:token|key|secret|password|passwd|auth|credential)\w*[=\s,][A-Za-z0-9+/=]{32,}/g
 ];
 function redactCommand(cmd) {
+  if (typeof cmd !== "string") return "";
   let result = cmd;
   for (const pattern of SENSITIVE_FLAG_PATTERNS) {
     result = result.replace(pattern, (match) => {
@@ -469,4 +470,4 @@ export {
   getProcessRegistry,
   _resetProcessRegistry
 };
-//# sourceMappingURL=chunk-3PVYQFRQ.js.map
+//# sourceMappingURL=chunk-ESLPBT5A.js.map

package/dist/{chunk-YZHK4TLF.js → chunk-FQNXYA6W.js}

@@ -3,11 +3,13 @@ import {
 } from "./chunk-Q5JPPCZC.js";
 import {
   safeResolveReal
-} from "./chunk-QLF74MSV.js";
+} from "./chunk-ZUFHAHTE.js";
 
 // src/logs.ts
 import { spawn } from "node:child_process";
+import { StringDecoder } from "node:string_decoder";
 import { buildChildEnv } from "@wrongstack/core/utils";
+import { ToolValidationError } from "@wrongstack/core/types";
 var logsTool = {
   name: "logs",
   category: "Logs",
@@ -51,12 +53,32 @@ var logsTool = {
   async execute(input, ctx, opts) {
     const cwd = input.cwd ? await safeResolveReal(input.cwd, ctx) : ctx.cwd;
     const signal = opts?.signal ?? ctx.signal ?? new AbortController().signal;
-    const lines = input.lines ?? 100;
+    if (signal.aborted) {
+      return {
+        source: "none",
+        entries: [],
+        total: 0,
+        truncated: false,
+        stream_mode: false
+      };
+    }
+    const VALID_SINCE = /* @__PURE__ */ new Set(["1h", "6h", "24h", "all"]);
+    if (input.since !== void 0 && !VALID_SINCE.has(input.since)) {
+      throw new ToolValidationError({
+        message: `logs: invalid since option "${input.since}". Allowed: 1h, 6h, 24h, all`,
+        field: "since"
+      });
+    }
+    const rawLines = typeof input.lines === "number" && !Number.isNaN(input.lines) ? input.lines : 100;
+    const lines = Math.max(0, Math.floor(rawLines));
     let filterRe = null;
     if (input.filter) {
       const compiled = compileUserRegex(input.filter, "i");
       if (!compiled.ok) {
-        throw new Error(`logs: ${compiled.reason}`);
+        throw new ToolValidationError({
+          message: `logs: ${compiled.reason}`,
+          field: "filter"
+        });
       }
       filterRe = compiled.regex;
     }
@@ -92,10 +114,21 @@ async function dockerLogs(service, lines, filterRe, cwd, signal, since) {
     };
   }
   args.push("--timestamps", service);
+  if (signal.aborted) {
+    return Promise.resolve({
+      source: `docker:${service}`,
+      entries: [],
+      total: 0,
+      truncated: false,
+      stream_mode: false
+    });
+  }
   return new Promise((resolve) => {
     let stdout = "";
     let stderr = "";
     const MAX = 2e5;
+    const stdoutDecoder = new StringDecoder("utf8");
+    const stderrDecoder = new StringDecoder("utf8");
     let settled = false;
     const empty = () => ({
       source: `docker:${service}`,
@@ -122,10 +155,16 @@ async function dockerLogs(service, lines, filterRe, cwd, signal, since) {
       finish(empty());
     }, DOCKER_LOGS_TIMEOUT_MS);
     child.stdout?.on("data", (c) => {
-      if (stdout.length < MAX) stdout += c.toString();
+      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();
+      if (stderr.length < MAX) {
+        const text = stderrDecoder.write(c);
+        stderr += text.slice(0, MAX - stderr.length);
+      }
     });
     child.stdout?.on("error", (e) => {
       console.log(
@@ -229,4 +268,4 @@ function parseLine(line) {
 export {
   logsTool
 };
-//# sourceMappingURL=chunk-YZHK4TLF.js.map
+//# sourceMappingURL=chunk-FQNXYA6W.js.map

package/dist/{chunk-OYVPBPCL.js → chunk-HR67OWEP.js}

@@ -1,15 +1,18 @@
 import {
   compileUserRegex
 } from "./chunk-Q5JPPCZC.js";
+import {
+  mapWithConcurrency
+} from "./chunk-ZBMANLYH.js";
 import {
   enqueueReindex
-} from "./chunk-MRKWZCHZ.js";
+} from "./chunk-Z5Q3TXRY.js";
 import {
   isBinaryBuffer,
   safeResolveReal,
   sha256hex,
   truncateDiffPayload
-} from "./chunk-QLF74MSV.js";
+} from "./chunk-ZUFHAHTE.js";
 
 // src/replace.ts
 import { spawn } from "node:child_process";
@@ -27,7 +30,7 @@ import {
   unifiedDiff
 } from "@wrongstack/core/utils";
 var MAX_DIFF_BYTES = 262144;
-var DEFAULT_IGNORE = ["node_modules", ".git", "dist", "build", ".next", "coverage"];
+var DEFAULT_IGNORE = /* @__PURE__ */ new Set(["node_modules", ".git", "dist", "build", ".next", "coverage"]);
 var replaceTool = {
   name: "replace",
   category: "Transform",
@@ -96,54 +99,51 @@ var replaceTool = {
     const re = compiled.regex;
     const globRe = input.glob ? compileGlob(input.glob) : null;
     const dryRun = input.dry_run ?? true;
-    const filesInput = Array.isArray(input.files) ? input.files.join(",") : input.files;
-    const fileList = await resolveFiles(filesInput, ctx, globRe);
+    const fileList = await resolveFiles(input.files, ctx, globRe);
     const realRoot = await fs.realpath(ctx.projectRoot).catch(() => ctx.projectRoot);
-    const results = [];
-    let totalReplacements = 0;
-    let diffBytesUsed = 0;
-    let diffsOmitted = 0;
-    let diffsTruncated = 0;
-    for (const absPath of fileList) {
+    const fileResults = await mapWithConcurrency(fileList, 16, async (absPath) => {
       signal?.throwIfAborted();
       const lstat2 = await fs.lstat(absPath).catch((err) => {
         if (err.code === "ENOENT") return null;
         throw err;
       });
-      if (!lstat2?.isFile()) continue;
-      if (lstat2.isSymbolicLink()) continue;
+      if (!lstat2?.isFile()) return null;
+      if (lstat2.isSymbolicLink()) return null;
       let realPath;
       try {
         realPath = await fs.realpath(absPath);
       } catch {
-        continue;
+        return null;
       }
       const rel = path.relative(realRoot, realPath);
-      if (rel.startsWith("..") || path.isAbsolute(rel)) continue;
+      if (rel.startsWith("..") || path.isAbsolute(rel)) return null;
       const stat2 = await fs.stat(realPath).catch(() => null);
-      if (!stat2?.isFile()) continue;
+      if (!stat2?.isFile()) return null;
       let content;
       try {
         const buf = await fs.readFile(realPath);
-        if (isBinaryBuffer(buf)) continue;
+        if (isBinaryBuffer(buf)) return null;
         content = buf.toString("utf8");
       } catch {
-        continue;
+        return null;
       }
       const style = detectNewlineStyle(content);
       const contentLf = normalizeToLf(content);
       re.lastIndex = 0;
       const allMatches = [...contentLf.matchAll(re)];
-      if (allMatches.length === 0) continue;
+      if (allMatches.length === 0) return null;
       const matches = replaceAll ? allMatches : allMatches.slice(0, 1);
       const count = matches.length;
-      let newContentLf = contentLf;
-      for (let i = matches.length - 1; i >= 0; i--) {
+      let newContentLf = "";
+      let lastIdx = 0;
+      for (let i = 0; i < matches.length; i++) {
         const m = expectDefined(matches[i]);
-        newContentLf = newContentLf.slice(0, m.index) + expandReplacement(input.replacement, m) + newContentLf.slice(expectDefined(m.index) + m[0].length);
+        const matchIdx = expectDefined(m.index);
+        newContentLf += contentLf.slice(lastIdx, matchIdx) + expandReplacement(input.replacement, m);
+        lastIdx = matchIdx + m[0].length;
       }
+      newContentLf += contentLf.slice(lastIdx);
       re.lastIndex = 0;
-      totalReplacements += count;
       if (!dryRun) {
         const newContent = toStyle(newContentLf, style);
         await atomicWrite(realPath, newContent, { mode: stat2.mode & 511 });
@@ -158,10 +158,27 @@ var replaceTool = {
           after: newContent
         });
       }
-      let diff = dryRun || matches.length > 0 ? unifiedDiff(content, toStyle(newContentLf, style), {
+      const isIdentical = newContentLf === contentLf;
+      const rawDiff = dryRun || matches.length > 0 ? isIdentical ? "(no-op: replacement produced identical content)" : unifiedDiff(content, toStyle(newContentLf, style), {
         fromFile: absPath,
         toFile: absPath
       }) : void 0;
+      return {
+        path: absPath,
+        replacements: count,
+        rawDiff,
+        isIdentical
+      };
+    });
+    const results = [];
+    let totalReplacements = 0;
+    let diffBytesUsed = 0;
+    let diffsOmitted = 0;
+    let diffsTruncated = 0;
+    for (const item of fileResults) {
+      if (!item) continue;
+      totalReplacements += item.replacements;
+      let diff = item.rawDiff;
       if (diff !== void 0) {
         const remaining = MAX_DIFF_BYTES - diffBytesUsed;
         if (remaining <= 0) {
@@ -175,8 +192,8 @@ var replaceTool = {
         }
       }
       results.push({
-        path: absPath,
-        replacements: matches.length,
+        path: item.path,
+        replacements: item.replacements,
         diff
       });
     }
@@ -189,13 +206,25 @@ var replaceTool = {
       } catch {
       }
     }
+    const hasIdentical = fileResults.some((r) => r?.isIdentical);
     const overBudget = diffsOmitted > 0 || diffsTruncated > 0;
+    const notes = [];
+    if (overBudget) {
+      notes.push(
+        `Diff payload exceeded the 256 KiB output budget: ${diffsTruncated} diff(s) truncated, ${diffsOmitted} diff(s) omitted. Replacement counts are complete; use the read tool to inspect individual files.`
+      );
+    }
+    if (hasIdentical && !overBudget) {
+      notes.push(
+        "Some replacements produced content identical to existing files (see no-op diff)."
+      );
+    }
     return {
       files_modified: results.length,
       total_replacements: totalReplacements,
       results,
       dry_run: dryRun,
-      note: overBudget ? `Diff payload exceeded the 256 KiB output budget: ${diffsTruncated} diff(s) truncated, ${diffsOmitted} diff(s) omitted. Replacement counts are complete; use the read tool to inspect individual files.` : void 0
+      note: notes.length > 0 ? notes.join("\n") : void 0
     };
   }
 };
@@ -246,7 +275,7 @@ function passesExtraGlob(extraGlob, name, full, base) {
 }
 async function resolveFiles(filesInput, ctx, extraGlob) {
   const base = ctx.cwd;
-  const parts = filesInput.trim().split(",").map((s) => s.trim()).filter(Boolean);
+  const parts = Array.isArray(filesInput) ? filesInput.map((s) => s.trim()).filter(Boolean) : filesInput.trim().split(",").map((s) => s.trim()).filter(Boolean);
   const resolved = [];
   for (const p of parts) {
     if (p.includes("*") || p.includes("?")) {
@@ -326,8 +355,14 @@ function spawnRgFind(pattern, base) {
   return {
     promise: new Promise((resolve, reject) => {
       child.on("error", reject);
-      child.on("close", () => {
-        resolve(buf.split("\n").filter(Boolean));
+      child.on("close", (code) => {
+        if (code !== 0 && code !== null) {
+          reject(new Error(`rg exited with code ${code}`));
+          return;
+        }
+        resolve(
+          buf.split(/\r?\n/).map((s) => s.trim()).filter(Boolean)
+        );
       });
     })
   };
@@ -342,8 +377,9 @@ async function globNative(pattern, base, extraGlob) {
     } catch {
       return;
     }
+    const subdirs = [];
     for (const e of entries) {
-      if (DEFAULT_IGNORE.includes(e.name)) continue;
+      if (DEFAULT_IGNORE.has(e.name)) continue;
       const full = path.join(dir, e.name);
       try {
         const stat2 = await fs.lstat(full);
@@ -352,7 +388,7 @@ async function globNative(pattern, base, extraGlob) {
         continue;
       }
       if (e.isDirectory()) {
-        await walk(full);
+        subdirs.push(full);
       } else if (e.isFile()) {
         const name = e.name;
         const rel = path.relative(base, full).split(path.sep).join("/");
@@ -365,6 +401,9 @@ async function globNative(pattern, base, extraGlob) {
         globRe.lastIndex = 0;
       }
     }
+    if (subdirs.length > 0) {
+      await mapWithConcurrency(subdirs, 16, (subdir) => walk(subdir));
+    }
   };
   await walk(base);
   return results;
@@ -374,4 +413,4 @@ export {
   replaceTool,
   __resetRgDetectionForTests
 };
-//# sourceMappingURL=chunk-OYVPBPCL.js.map
+//# sourceMappingURL=chunk-HR67OWEP.js.map

package/dist/{chunk-ZDUGI5BC.js → chunk-I7FBZOEP.js}

@@ -2,7 +2,7 @@ import {
   executeLanguagePlan,
   executePackagePlan,
   planLanguageOperation
-} from "./chunk-UC3RKRIV.js";
+} from "./chunk-NDIT3SBZ.js";
 
 // src/languages/legacy-bridge.ts
 import * as fs from "node:fs/promises";
@@ -98,4 +98,4 @@ export {
   tryLegacyCodeOperation,
   tryLegacyPackageOperation
 };
-//# sourceMappingURL=chunk-ZDUGI5BC.js.map
+//# sourceMappingURL=chunk-I7FBZOEP.js.map