@wrongstack/tools 0.313.0 → 0.316.1

package/dist/chunk-553IQUMO.js

@@ -0,0 +1,478 @@
+import {
+  capSubject,
+  compileUserRegex
+} from "./chunk-Q5JPPCZC.js";
+import {
+  mapWithConcurrency
+} from "./chunk-U4D5S3VQ.js";
+import {
+  loadGitignoreMatcher
+} from "./chunk-LIJQMYYX.js";
+import {
+  isBinaryBuffer,
+  safeResolveReal
+} from "./chunk-D33S4RQG.js";
+
+// src/grep.ts
+import { spawn } from "node:child_process";
+import * as fs from "node:fs/promises";
+import * as path from "node:path";
+import { ToolValidationError } from "@wrongstack/core/types";
+import {
+  buildChildEnv,
+  compileGlob,
+  DEFAULT_WALK_IGNORE_DIRS,
+  expectDefined
+} from "@wrongstack/core/utils";
+var DEFAULT_IGNORE = new Set(DEFAULT_WALK_IGNORE_DIRS);
+var NATIVE_SCAN_CONCURRENCY = 32;
+var NATIVE_READ_CHUNK_BYTES = 64 * 1024;
+var NATIVE_MAX_FILE_BYTES = 1e6;
+var RG_MAX_QUEUE_CHUNKS = 128;
+var RG_MAX_QUEUE_CHARS = 8 * 1024 * 1024;
+var grepTool = {
+  name: "grep",
+  category: "Search",
+  description: "Search exact file contents using a regular expression. Use index-backed `codebase-search` first for symbol or concept discovery when it is live. Prefers ripgrep for speed and features when available.",
+  usageHint: 'EXACT-TEXT AND REGEX SEARCH:\n\n- When `codebase-search` is live, use it first for symbols and concepts; use `grep` for exact text, regexes, unsupported content, and concrete usage sites.\n- `pattern` is a regular expression.\n- Use `output_mode: "content"` (default) to get matching lines with context.\n- Use `"files_with_matches"` when you only need the list of files.\n- Use `"count"` for quick statistics.\n- `glob` and `path` let you narrow the search scope significantly.\n- Always prefer this over `bash grep` when searching code.',
+  selection: {
+    doNotUseWhen: "you only need to locate files by name or path pattern.",
+    useInstead: ["glob"]
+  },
+  permission: "auto",
+  mutating: false,
+  capabilities: ["fs.read"],
+  icon: "search",
+  maxOutputBytes: 131072,
+  timeoutMs: 1e4,
+  inputSchema: {
+    type: "object",
+    properties: {
+      pattern: {
+        type: "string",
+        description: "Regular expression pattern to search for in file contents."
+      },
+      path: {
+        type: "string",
+        description: "Limit search to this directory or file (relative to project root)."
+      },
+      glob: {
+        type: "string",
+        description: 'Glob filter for which files to include (e.g. "**/*.ts", "src/**").'
+      },
+      output_mode: {
+        type: "string",
+        enum: ["content", "files_with_matches", "count"],
+        description: "Return style: detailed matches, just file list, or count only."
+      },
+      context_lines: {
+        type: "integer",
+        description: "How many lines of surrounding context to include with each match."
+      },
+      case_insensitive: {
+        type: "boolean",
+        description: "Ignore case when matching."
+      },
+      limit: {
+        type: "integer",
+        description: "Maximum number of matches to return."
+      }
+    },
+    required: ["pattern"]
+  },
+  async execute(input, ctx, opts) {
+    let final;
+    const executeStream = grepTool.executeStream;
+    if (!executeStream) throw new Error("grepTool: stream execution unavailable");
+    for await (const ev of executeStream(input, ctx, opts)) {
+      if (ev.type === "final") final = ev.output;
+    }
+    if (!final) throw new Error("grep: stream ended without final event");
+    return final;
+  },
+  async *executeStream(input, ctx, opts) {
+    if (!input?.pattern) {
+      throw new ToolValidationError({
+        message: "grep: pattern is required",
+        field: "pattern"
+      });
+    }
+    const base = input.path ? await safeResolveReal(input.path, ctx) : ctx.cwd;
+    const mode = input.output_mode ?? "content";
+    const limit = Math.max(1, Math.min(input.limit ?? 200, 2e3));
+    const validation = compileUserRegex(input.pattern, input.case_insensitive ? "i" : "");
+    if (!validation.ok) {
+      throw new ToolValidationError({
+        message: `grep: ${validation.reason}`,
+        field: "pattern"
+      });
+    }
+    const rgAvailable = await detectRg();
+    if (rgAvailable) {
+      try {
+        yield* runRgStream(input, base, mode, limit, opts.signal);
+        return;
+      } catch {
+      }
+    }
+    yield { type: "log", text: "Falling back to native grep\u2026" };
+    const out = await runNative(input, base, mode, limit, opts.signal);
+    yield { type: "final", output: out };
+  }
+};
+var rgAvailabilityCache;
+function __resetRgDetectionForTests() {
+  rgAvailabilityCache = void 0;
+}
+function detectRg() {
+  rgAvailabilityCache ??= new Promise((resolve) => {
+    try {
+      const p = spawn("rg", ["--version"], {
+        env: buildChildEnv(),
+        stdio: "ignore",
+        signal: AbortSignal.timeout(1e4),
+        windowsHide: true
+      });
+      p.on("error", () => resolve(false));
+      p.on("close", (code) => resolve(code === 0));
+    } catch {
+      resolve(false);
+    }
+  });
+  return rgAvailabilityCache;
+}
+async function* runRgStream(input, base, mode, limit, signal) {
+  const args = ["--no-heading"];
+  if (input.case_insensitive) args.push("-i");
+  if (mode === "files_with_matches") args.push("-l");
+  if (mode === "count") args.push("-c");
+  if (mode === "content") {
+    args.push("-n");
+    if (input.context_lines) args.push("-C", String(input.context_lines));
+  }
+  for (const ignored of DEFAULT_IGNORE) {
+    args.push("--glob", `!${ignored}/**`, "--glob", `!**/${ignored}/**`);
+  }
+  const gitignorePath = path.join(base, ".gitignore");
+  if (await fs.access(gitignorePath).then(
+    () => true,
+    () => false
+  )) {
+    args.push("--ignore-file", gitignorePath);
+  }
+  if (input.glob) args.push("--glob", input.glob);
+  args.push("--", input.pattern, base);
+  const matches = [];
+  let buf = "";
+  let totalLines = 0;
+  let totalCount = 0;
+  let batchSinceFlush = 0;
+  const FLUSH_AT = 16;
+  const MAX_BUF_BYTES = 1e6;
+  let bufOverflow = false;
+  const child = spawn("rg", args, {
+    signal,
+    env: buildChildEnv(),
+    // rg diagnostics are not part of the tool result. Ignoring stderr avoids
+    // an unread pipe filling up and pinning the child when rg reports many
+    // filesystem errors.
+    stdio: ["ignore", "pipe", "ignore"],
+    windowsHide: true
+  });
+  const queue = [];
+  let queuedChars = 0;
+  let waiter;
+  let paused = false;
+  const wake = () => {
+    if (waiter) {
+      const w = waiter;
+      waiter = void 0;
+      w();
+    }
+  };
+  const pauseIfFlooded = () => {
+    if (paused || queue.length < RG_MAX_QUEUE_CHUNKS && queuedChars < RG_MAX_QUEUE_CHARS) return;
+    paused = true;
+    child.stdout?.pause();
+  };
+  const resumeIfDrained = () => {
+    if (!paused || queue.length >= RG_MAX_QUEUE_CHUNKS || queuedChars >= RG_MAX_QUEUE_CHARS) return;
+    paused = false;
+    child.stdout?.resume();
+  };
+  const onStdoutData = (c) => {
+    const data = c.toString();
+    queue.push({ kind: "out", data });
+    queuedChars += data.length;
+    wake();
+    pauseIfFlooded();
+  };
+  const onError = (e) => {
+    queue.push({ kind: "error", data: e.message });
+    wake();
+  };
+  const onClose = () => {
+    queue.push({ kind: "close", data: "" });
+    wake();
+  };
+  child.stdout?.on("data", onStdoutData);
+  child.on("error", onError);
+  child.on("close", onClose);
+  let pendingBatch = [];
+  let errored = false;
+  let closed = false;
+  try {
+    for (; ; ) {
+      while (queue.length === 0) {
+        await new Promise((r) => {
+          waiter = r;
+        });
+      }
+      const c = expectDefined(queue.shift());
+      queuedChars = Math.max(0, queuedChars - c.data.length);
+      resumeIfDrained();
+      if (c.kind === "error") {
+        errored = true;
+        continue;
+      }
+      if (c.kind === "close") {
+        closed = true;
+        break;
+      }
+      buf += c.data;
+      if (buf.length > MAX_BUF_BYTES && !bufOverflow) {
+        bufOverflow = true;
+        buf = buf.slice(-MAX_BUF_BYTES);
+        try {
+          child.kill("SIGTERM");
+        } catch {
+        }
+      }
+      const idx = buf.lastIndexOf("\n");
+      if (idx === -1) continue;
+      const ready = buf.slice(0, idx);
+      buf = buf.slice(idx + 1);
+      for (const line of ready.split("\n")) {
+        if (!line) continue;
+        totalLines++;
+        if (mode === "count") totalCount += parseRgCountLine(line);
+        if (matches.length < limit) {
+          matches.push(line);
+          pendingBatch.push(line);
+          batchSinceFlush++;
+        }
+      }
+      if (batchSinceFlush >= FLUSH_AT) {
+        yield {
+          type: "partial_output",
+          text: pendingBatch.join("\n"),
+          data: { matches_so_far: matches.length }
+        };
+        pendingBatch = [];
+        batchSinceFlush = 0;
+      }
+    }
+    if (buf.trim()) {
+      for (const line of buf.split("\n")) {
+        if (!line) continue;
+        totalLines++;
+        if (mode === "count") totalCount += parseRgCountLine(line);
+        if (matches.length < limit) {
+          matches.push(line);
+          pendingBatch.push(line);
+        }
+      }
+    }
+    if (pendingBatch.length > 0) {
+      yield {
+        type: "partial_output",
+        text: pendingBatch.join("\n"),
+        data: { matches_so_far: matches.length }
+      };
+    }
+    if (errored) throw new Error("rg: spawn error");
+    yield {
+      type: "final",
+      output: {
+        matches,
+        count: mode === "count" ? totalCount : totalLines,
+        truncated: totalLines > limit || bufOverflow,
+        used: "rg"
+      }
+    };
+  } finally {
+    child.stdout?.off("data", onStdoutData);
+    child.off("error", onError);
+    child.off("close", onClose);
+    child.stdout?.destroy();
+    queue.length = 0;
+    queuedChars = 0;
+    waiter = void 0;
+    if (!closed && child.exitCode === null) {
+      try {
+        child.kill("SIGTERM");
+      } catch {
+      }
+    }
+  }
+}
+function parseRgCountLine(line) {
+  const idx = line.lastIndexOf(":");
+  if (idx === -1) return 0;
+  const n = Number.parseInt(line.slice(idx + 1), 10);
+  return Number.isFinite(n) ? n : 0;
+}
+async function runNative(input, base, mode, limit, signal) {
+  const flags = input.case_insensitive ? "i" : "";
+  const compiled = compileUserRegex(input.pattern, flags);
+  if (!compiled.ok) {
+    throw new ToolValidationError({
+      message: `grep: ${compiled.reason}`,
+      field: "pattern"
+    });
+  }
+  const re = compiled.regex;
+  const globRe = input.glob ? compileGlob(input.glob) : null;
+  const isGitIgnored = await loadGitignoreMatcher(base);
+  const matches = [];
+  const countOnlyFirstHit = mode === "count" && limit === 1;
+  const maxBytes = mode === "content" ? NATIVE_MAX_FILE_BYTES : Math.min(NATIVE_MAX_FILE_BYTES, 256 * 1024);
+  let total = 0;
+  let stopped = false;
+  const scanFile = async (full, name) => {
+    if (stopped || signal.aborted) return;
+    if (globRe && !globRe.test(name) && !globRe.test(full)) return;
+    if (globRe) globRe.lastIndex = 0;
+    try {
+      const stat2 = await fs.stat(full);
+      if (!stat2.isFile() || stat2.size > maxBytes || stopped || signal.aborted) return;
+      const file = await fs.open(full, "r");
+      try {
+        let bytesReadTotal = 0;
+        let lineNumber = 0;
+        let fileHits = 0;
+        let leftover = "";
+        let binaryChecked = false;
+        const buffer = Buffer.allocUnsafe(Math.min(NATIVE_READ_CHUNK_BYTES, maxBytes));
+        while (!stopped && !signal.aborted && bytesReadTotal < maxBytes) {
+          const remaining = maxBytes - bytesReadTotal;
+          const { bytesRead } = await file.read(
+            buffer,
+            0,
+            Math.min(buffer.length, remaining),
+            null
+          );
+          if (bytesRead === 0) break;
+          const chunk = buffer.subarray(0, bytesRead);
+          if (!binaryChecked) {
+            binaryChecked = true;
+            if (isBinaryBuffer(chunk)) return;
+          }
+          bytesReadTotal += bytesRead;
+          const text = leftover + chunk.toString("utf8");
+          const lines = text.split(/\r?\n/);
+          leftover = lines.pop() ?? "";
+          for (const rawLine of lines) {
+            if (stopped || signal.aborted) break;
+            lineNumber++;
+            const ln = capSubject(rawLine);
+            re.lastIndex = 0;
+            if (!re.test(ln)) continue;
+            fileHits++;
+            total++;
+            if (mode === "content") {
+              if (matches.length < limit) matches.push(`${full}:${lineNumber}:${ln}`);
+            } else if (mode === "files_with_matches") {
+              if (fileHits === 1 && matches.length < limit) matches.push(full);
+              break;
+            } else if (fileHits === 1 && matches.length < limit) {
+              matches.push(`${full}:${countOnlyFirstHit ? 1 : 0}`);
+            }
+            if (countOnlyFirstHit || mode !== "content" && matches.length >= limit) {
+              stopped = true;
+              break;
+            }
+          }
+          if (mode === "files_with_matches" && fileHits > 0) break;
+        }
+        if (!stopped && !signal.aborted && leftover.length > 0) {
+          lineNumber++;
+          const ln = capSubject(leftover);
+          re.lastIndex = 0;
+          if (re.test(ln)) {
+            fileHits++;
+            total++;
+            if (mode === "content") {
+              if (matches.length < limit) matches.push(`${full}:${lineNumber}:${ln}`);
+            } else if (mode === "files_with_matches") {
+              if (matches.length < limit) matches.push(full);
+            } else if (matches.length < limit) {
+              matches.push(`${full}:${countOnlyFirstHit ? 1 : fileHits}`);
+            }
+          }
+        }
+        if (fileHits > 0) {
+          if (mode === "count") {
+            const idx = matches.findIndex((entry) => entry.startsWith(`${full}:`));
+            if (idx !== -1) matches[idx] = `${full}:${fileHits}`;
+          }
+          if (mode === "files_with_matches" && matches.length >= limit) stopped = true;
+        }
+        if (mode === "content" && matches.length >= limit) stopped = true;
+        if (mode === "count" && matches.length >= limit && (countOnlyFirstHit || mode !== "count"))
+          stopped = true;
+      } finally {
+        await file.close();
+      }
+    } catch {
+    }
+  };
+  const walk = async (dir, relPrefix) => {
+    if (stopped || signal.aborted) return;
+    let entries;
+    try {
+      entries = await fs.readdir(dir, { withFileTypes: true });
+    } catch {
+      return;
+    }
+    const files = [];
+    const subdirs = [];
+    for (const e of entries) {
+      if (stopped) return;
+      if (DEFAULT_IGNORE.has(e.name)) continue;
+      if (e.isSymbolicLink()) continue;
+      const rel = relPrefix ? `${relPrefix}/${e.name}` : e.name;
+      const full = path.join(dir, e.name);
+      if (e.isDirectory()) {
+        if (isGitIgnored(rel, true)) continue;
+        subdirs.push({ full, rel });
+      } else if (e.isFile()) {
+        if (isGitIgnored(rel, false)) continue;
+        files.push({ full, name: e.name });
+      }
+    }
+    await mapWithConcurrency(
+      files,
+      NATIVE_SCAN_CONCURRENCY,
+      ({ full, name }) => scanFile(full, name)
+    );
+    await mapWithConcurrency(
+      subdirs,
+      Math.min(16, NATIVE_SCAN_CONCURRENCY),
+      ({ full, rel }) => walk(full, rel)
+    );
+  };
+  await walk(base, "");
+  return {
+    matches,
+    count: total,
+    truncated: stopped,
+    used: "native"
+  };
+}
+
+export {
+  grepTool,
+  __resetRgDetectionForTests
+};
+//# sourceMappingURL=chunk-553IQUMO.js.map

package/dist/chunk-5H4GSJAI.js

@@ -0,0 +1,223 @@
+import {
+  tryLegacyPackageOperation
+} from "./chunk-PQKK5JH7.js";
+import {
+  spawnStream
+} from "./chunk-22B7GE5T.js";
+import {
+  detectPackageManager,
+  normalizeCommandOutput,
+  safeResolveReal
+} from "./chunk-D33S4RQG.js";
+
+// src/install.ts
+import { join } from "node:path";
+import {
+  detectEcosystem as detectPackageEcosystem,
+  recordPackageAction
+} from "@wrongstack/core/coordination";
+var installTool = {
+  name: "install",
+  category: "Package Management",
+  description: "Install, update or manage packages using the detected package manager (pnpm/npm/yarn). Strongly preferred over raw shell commands for dependency management because it is structured and safer.",
+  usageHint: "ALWAYS USE THIS INSTEAD OF BASH FOR PACKAGE WORK:\n\n- Empty `packages` \u2192 normal `install` (respects lockfile).\n- Provide names \u2192 adds/updates specific packages.\n- `dry_run: true` for safe preview.\n- Set `save` appropriately.\nThis tool has proper capability declaration and is heavily recommended in the security posture of the project.",
+  permission: "confirm",
+  // WS-046: gives permission decisions something to key on.
+  // What gets installed is the subject — installing a package runs its
+  // lifecycle scripts, so `express` and `evil-pkg` must not be interchangeable.
+  subjectKey: "packages",
+  mutating: true,
+  riskTier: "standard",
+  icon: "package",
+  timeoutMs: 12e4,
+  capabilities: ["package.install", "shell.restricted"],
+  inputSchema: {
+    type: "object",
+    properties: {
+      packages: {
+        type: "string",
+        description: "Package(s) to install: single name, comma-separated list, or empty for all deps"
+      },
+      save: {
+        type: "string",
+        enum: ["dependency", "dev", "optional"],
+        description: 'Where to save the package(s): "dependency", "devDependencies", or "optionalDependencies".'
+      },
+      cwd: {
+        type: "string",
+        description: "Working directory for the install command (must stay inside project)."
+      },
+      dry_run: {
+        type: "boolean",
+        description: "If true, show what would be installed without actually modifying package.json or node_modules."
+      },
+      global: {
+        type: "boolean",
+        description: "Whether to perform a global install (use with caution)."
+      },
+      lifecycleScripts: {
+        type: "boolean",
+        description: "Opt in to running package lifecycle scripts (preinstall / install / postinstall / prepare / \u2026). Default: false \u2014 installs pass --ignore-scripts so a malicious package cannot execute arbitrary code at install time. Set true to opt back in to the legacy npm/pnpm/yarn default."
+      }
+    }
+  },
+  async execute(input, ctx, opts) {
+    let final;
+    const executeStream = installTool.executeStream;
+    if (!executeStream) throw new Error("installTool: stream execution unavailable");
+    for await (const ev of executeStream(input, ctx, opts)) {
+      if (ev.type === "final") final = ev.output;
+    }
+    if (!final) throw new Error("install: stream ended without final event");
+    return final;
+  },
+  async *executeStream(input, ctx, opts) {
+    const cwd = input.cwd ? await safeResolveReal(input.cwd, ctx) : ctx.cwd;
+    if (!input.global) {
+      const pkgList2 = input.packages ? Array.isArray(input.packages) ? input.packages : input.packages.split(",").map((p) => p.trim()) : [];
+      const bridge = await tryLegacyPackageOperation(
+        "package-install",
+        {
+          cwd,
+          projectRoot: ctx.projectRoot,
+          signal: opts.signal
+        },
+        pkgList2
+      );
+      if (bridge?.outcome) {
+        const outcome = bridge.outcome;
+        const run = outcome.run;
+        yield {
+          type: "final",
+          output: {
+            exit_code: run?.exitCode ?? 0,
+            packages: [],
+            output: normalizeCommandOutput(
+              run?.output || outcome.manifestsChanged.join(", ") || "ok"
+            ),
+            truncated: run?.truncated ?? false,
+            dry_run: input.dry_run ?? false
+          }
+        };
+        return;
+      }
+    }
+    const pkgManager = await detectPackageManager(cwd, ctx.projectRoot);
+    yield { type: "log", text: `Resolving with ${pkgManager}\u2026`, data: { phase: "resolve" } };
+    const globalFlag = input.global ? ["-g"] : [];
+    const ignoreScripts = input.lifecycleScripts !== true;
+    const pkgList = input.packages ? (Array.isArray(input.packages) ? input.packages : input.packages.split(",")).map(
+      (p) => p.trim()
+    ) : [];
+    const PKG_NAME_RE = /^(?:@[a-z0-9._-]+\/)?[a-z0-9._-]+(?:@[a-z0-9^~><=*.+-]+)?$/i;
+    for (const pkg of pkgList) {
+      if (!PKG_NAME_RE.test(pkg) || pkg.startsWith("-") || pkg.length > 200) {
+        yield {
+          type: "final",
+          output: {
+            packages: pkgList,
+            exit_code: 1,
+            output: `Invalid package name "${pkg}". Names must match ${PKG_NAME_RE} and not start with "-".`,
+            dry_run: Boolean(input.dry_run),
+            truncated: false
+          }
+        };
+        return;
+      }
+    }
+    const hasPkgs = pkgList.length > 0;
+    const args = [];
+    if (input.dry_run) args.push("--dry-run");
+    if (ignoreScripts) args.push("--ignore-scripts");
+    if (pkgManager === "pnpm") {
+      if (hasPkgs) {
+        if (input.save === "dev") args.push("-D");
+        else if (input.save === "optional") args.push("-O");
+        args.push("add", ...globalFlag);
+      } else {
+        args.push("install", ...globalFlag);
+      }
+    } else if (pkgManager === "yarn") {
+      if (hasPkgs) {
+        args.push("add", ...globalFlag);
+        if (input.save === "dev") args.push("--dev");
+        else if (input.save === "optional") args.push("--optional");
+      } else {
+        args.push("install", ...globalFlag);
+      }
+    } else {
+      args.push("install", ...globalFlag);
+      if (hasPkgs) {
+        if (input.save === "dev") args.push("--save-dev");
+        else if (input.save === "optional") args.push("--save-optional");
+      }
+    }
+    if (hasPkgs) args.push(...pkgList);
+    yield {
+      type: "log",
+      text: `Fetching ${pkgList.length || "all"} packages\u2026`,
+      data: { phase: "fetch" }
+    };
+    const result = yield* spawnStream({
+      cmd: pkgManager,
+      args,
+      cwd,
+      signal: opts.signal,
+      maxBytes: 1e5
+    });
+    const output = {
+      packages: pkgList,
+      exit_code: result.exitCode,
+      output: normalizeCommandOutput(result.stdout || result.stderr || result.error || ""),
+      dry_run: args.includes("--dry-run"),
+      truncated: result.truncated
+    };
+    const isSuccess = result.exitCode === 0 && !output.dry_run && !input.global;
+    if (isSuccess && pkgList.length > 0) {
+      const trackerOpts = ctx.meta?.["packageTrackerOpts"];
+      if (trackerOpts) {
+        const manifestPath = resolveManifestPath(cwd, pkgManager);
+        for (const pkg of pkgList) {
+          try {
+            await recordPackageAction(trackerOpts, {
+              manifestPath,
+              packageName: pkg,
+              versionSpec: "latest",
+              // exact version resolved by package manager at install time
+              ecosystem: detectPackageEcosystem(manifestPath),
+              agentId: ctx.agentId,
+              agentName: ctx.agentName,
+              sessionId: ctx.session.id
+            });
+          } catch {
+          }
+        }
+      }
+    }
+    ctx.recordSideEffect?.({
+      toolUseId: `install-${Date.now()}`,
+      toolName: "install",
+      ts: (/* @__PURE__ */ new Date()).toISOString(),
+      input: { packages: pkgList, cwd, dry_run: Boolean(input.dry_run) },
+      outcome: output.dry_run ? "dry run" : result.exitCode === 0 ? `installed ${pkgList.length || "all"} packages` : `failed (exit ${result.exitCode})`,
+      risk: "package"
+    });
+    yield { type: "final", output };
+  }
+};
+function resolveManifestPath(cwd, pkgManager) {
+  switch (pkgManager) {
+    case "pnpm":
+    case "yarn":
+    case "npm":
+      return join(cwd, "package.json");
+    /* v8 ignore next 2 -- pkgManager is always pnpm/yarn/npm; the default is defensive. */
+    default:
+      return join(cwd, "package.json");
+  }
+}
+
+export {
+  installTool
+};
+//# sourceMappingURL=chunk-5H4GSJAI.js.map