@garuda-agent/garuda 0.0.1 → 0.15.0

package/dist/chunk-HRGX53VC.js

@@ -0,0 +1,173 @@
+#!/usr/bin/env node
+import {
+  cleanLine
+} from "./chunk-PZS3V6P3.js";
+import {
+  EFFORTS
+} from "./chunk-SI2QJYCR.js";
+import {
+  formatRule
+} from "./chunk-3NJNVZTK.js";
+
+// src/model/pricing.ts
+var DEFAULT_CONTEXT_WINDOW = 2e5;
+var M = 1e6;
+var ALWAYS = { mode: "always", efforts: EFFORTS };
+var OPTIONAL = { mode: "optional", efforts: EFFORTS };
+var OPTIONAL_46 = {
+  mode: "optional",
+  efforts: EFFORTS.filter((e) => e !== "xhigh")
+};
+var KNOWN = [
+  ["claude-fable-5-1", { price: p(10, 50, 0.25, 12.5), contextWindow: M, thinking: ALWAYS }],
+  ["claude-fable-5", { price: p(10, 50, 1, 12.5), contextWindow: M, thinking: ALWAYS }],
+  ["claude-opus-5-5", { price: p(4, 20, 0.2, 5), contextWindow: M, thinking: ALWAYS }],
+  ["claude-opus-5", { price: p(5, 25, 0.5, 6.25), contextWindow: M, thinking: ALWAYS }],
+  ["claude-opus-4-8", { price: p(5, 25, 0.5, 6.25), contextWindow: M, thinking: OPTIONAL }],
+  ["claude-opus-4-7", { price: p(5, 25, 0.5, 6.25), contextWindow: M, thinking: OPTIONAL }],
+  ["claude-opus-4-6", { price: p(5, 25, 0.5, 6.25), contextWindow: M, thinking: OPTIONAL_46 }],
+  ["claude-opus-4-5", { price: p(5, 25, 0.5, 6.25), contextWindow: 2e5 }],
+  ["claude-sonnet-5", { price: p(2, 10, 0.2, 2.5), contextWindow: M, thinking: ALWAYS }],
+  ["claude-sonnet-4-6", { price: p(3, 15, 0.3, 3.75), contextWindow: M, thinking: OPTIONAL_46 }],
+  ["claude-sonnet-4-5", { price: p(3, 15, 0.3, 3.75), contextWindow: 2e5 }],
+  ["claude-haiku-4-5", { price: p(1, 5, 0.1, 1.25), contextWindow: 2e5 }]
+];
+function p(input, output, cacheRead, cacheWrite) {
+  return { input, output, cacheRead, cacheWrite };
+}
+function aliasModel(alias) {
+  if (!/^(haiku|sonnet|opus|fable)$/.test(alias)) return void 0;
+  return KNOWN.find(([prefix]) => prefix.startsWith(`claude-${alias}-`))?.[0];
+}
+function knownModels() {
+  return KNOWN.map(([id, info]) => ({ id, info }));
+}
+function lookupModel(modelId) {
+  let best;
+  for (const [prefix, info] of KNOWN) {
+    if (modelId.startsWith(prefix) && prefix.length > (best?.prefix.length ?? 0)) {
+      best = { prefix, info };
+    }
+  }
+  return best?.info ?? { contextWindow: DEFAULT_CONTEXT_WINDOW };
+}
+var WEB_SEARCH_USD = 0.01;
+function costOf(usage, price, factor = 1) {
+  return (usage.inputTokens * price.input + usage.outputTokens * price.output + usage.cacheReadTokens * price.cacheRead + usage.cacheWriteTokens * price.cacheWrite) / M * factor + (usage.webSearches ?? 0) * WEB_SEARCH_USD;
+}
+function responseCost(response, price) {
+  return costOf(response.usage, price, response.priceFactor ?? 1);
+}
+function totalTokens(usage) {
+  return usage.inputTokens + usage.outputTokens + usage.cacheReadTokens + usage.cacheWriteTokens;
+}
+function contextSize(usage) {
+  return totalTokens(usage);
+}
+
+// src/permissions/projectSettings.ts
+import { createHash } from "crypto";
+function settingsRisk(settings) {
+  const risk = {
+    executorHost: settings.executor === "host",
+    allow: settings.allow.map(formatRule),
+    writePaths: [...settings.sandbox?.writePaths ?? []],
+    envAllow: [...settings.envAllow],
+    allowLocalhost: settings.web?.allowLocalhost === true
+  };
+  const formatterCommands = Object.entries(settings.formatters?.commands ?? {}).flatMap(
+    ([name, f]) => f === false ? [] : [`${name}: ${f.command.join(" ")}`]
+  );
+  if (formatterCommands.length > 0) risk.formatterCommands = formatterCommands;
+  const none = !risk.executorHost && risk.allow.length === 0 && risk.writePaths.length === 0 && risk.envAllow.length === 0 && !risk.allowLocalhost && risk.formatterCommands === void 0;
+  return none ? void 0 : risk;
+}
+function settingsRiskHash(risk) {
+  return createHash("sha256").update(JSON.stringify(risk)).digest("hex");
+}
+function settingsRiskLines(risk) {
+  const lines = [];
+  if (risk.executorHost) lines.push('executor: "host" (commands run with no OS sandbox)');
+  if (risk.allow.length > 0) {
+    lines.push(`permissions.allow (no question for these): ${risk.allow.join(", ")}`);
+  }
+  if (risk.writePaths.length > 0) {
+    lines.push(`sandbox.writePaths (commands may write there): ${risk.writePaths.join(", ")}`);
+  }
+  if (risk.envAllow.length > 0) {
+    lines.push(`env.allow (commands see these variables): ${risk.envAllow.join(", ")}`);
+  }
+  if (risk.allowLocalhost) lines.push("web.allowLocalhost (web_fetch may reach this machine)");
+  if (risk.formatterCommands !== void 0) {
+    lines.push(
+      `formatters.commands (run after each edit): ${risk.formatterCommands.map(cleanLine).join("; ")}`
+    );
+  }
+  return lines;
+}
+function withoutRisk(settings) {
+  const { sandbox, web, formatters, ...rest } = settings;
+  const { writePaths: _writePaths, ...sandboxRest } = sandbox ?? {};
+  const keptCommands = Object.fromEntries(
+    Object.entries(formatters?.commands ?? {}).filter(([, f]) => f === false)
+  );
+  return {
+    ...rest,
+    ...formatters === void 0 ? {} : { formatters: { ...formatters, commands: keptCommands } },
+    executor: settings.executor === "host" ? "auto" : settings.executor,
+    allow: [],
+    envAllow: [],
+    ...sandbox === void 0 ? {} : { sandbox: sandboxRest },
+    ...web === void 0 ? {} : { web: { ...web, allowLocalhost: false } }
+  };
+}
+async function gateProjectSettings(options) {
+  const risk = settingsRisk(options.settings);
+  if (risk === void 0) return { settings: options.settings };
+  const hash = settingsRiskHash(risk);
+  const known = options.trust?.settingsHash(options.root);
+  if (known === hash) return { settings: options.settings };
+  const lines = settingsRiskLines(risk);
+  if (options.ask !== void 0) {
+    const choice = await options.ask({
+      tool: "settings",
+      target: { kind: "input", json: "" },
+      title: "Project settings that loosen safety",
+      preview: [
+        `This project's .garuda/settings.json ${known === void 0 ? "asks for" : "changed and now asks for"}:`,
+        ...lines.map((line) => `  - ${line}`),
+        "A cloned repository can ship this file. Without your yes, Garuda uses safe defaults for these",
+        "parts; the rest of the file applies."
+      ].join("\n"),
+      isolation: options.isolation ?? "os",
+      question: "Use these project settings?",
+      choices: ["once", "session", "deny"],
+      labels: {
+        once: "Yes, for this run",
+        session: "Yes, and remember (asks again when they change)",
+        deny: "No, use safe defaults"
+      }
+    });
+    if (choice === "session") await options.trust?.setSettingsHash(options.root, hash);
+    if (choice !== "deny") return { settings: options.settings };
+  }
+  return {
+    settings: withoutRisk(options.settings),
+    notice: [
+      `Project settings not applied (not approved): ${lines.join("; ")}.`,
+      "Start the chat in a terminal and answer yes to use them."
+    ].join(" ")
+  };
+}
+
+export {
+  aliasModel,
+  knownModels,
+  lookupModel,
+  WEB_SEARCH_USD,
+  responseCost,
+  totalTokens,
+  contextSize,
+  gateProjectSettings
+};
+//# sourceMappingURL=chunk-HRGX53VC.js.map

package/dist/chunk-HUIK3WXO.js

@@ -0,0 +1,234 @@
+#!/usr/bin/env node
+import {
+  commandMatches,
+  commandParts,
+  hostMatches,
+  pathMatches
+} from "./chunk-3NJNVZTK.js";
+
+// src/permissions/policy.ts
+import { existsSync } from "fs";
+import { readFile } from "fs/promises";
+import { homedir } from "os";
+import { join } from "path";
+import { z } from "zod";
+var POLICY_FILE = join(".garuda", "policy.json");
+function managedPolicyPath(platform = process.platform) {
+  if (platform === "darwin") return "/Library/Application Support/Garuda/policy.json";
+  if (platform === "linux") return "/etc/garuda/policy.json";
+  return void 0;
+}
+function ignoredProjectPolicy(root) {
+  const file = join(root, POLICY_FILE);
+  return existsSync(file) ? file : void 0;
+}
+var policySchema = z.strictObject({
+  disallowedCommands: z.array(z.string()).optional(),
+  requireSandbox: z.boolean().optional(),
+  denyPaths: z.array(z.string()).optional(),
+  allowedModels: z.array(z.string()).optional(),
+  network: z.strictObject({
+    blockedHosts: z.array(z.string()).optional(),
+    strictAllowlist: z.boolean().optional()
+  }).optional(),
+  limits: z.strictObject({
+    maxSteps: z.number().int().positive().optional(),
+    tokenBudget: z.number().int().positive().optional()
+  }).optional(),
+  audit: z.strictObject({
+    enabled: z.boolean().optional(),
+    level: z.enum(["all", "mutations", "denials"]).optional()
+  }).optional()
+});
+function parsePolicy(json) {
+  const result = policySchema.safeParse(json);
+  if (!result.success) {
+    throw new Error(`Invalid policy schema: ${z.prettifyError(result.error)}`);
+  }
+  const data = result.data;
+  return {
+    ...data.disallowedCommands === void 0 ? {} : { disallowedCommands: data.disallowedCommands },
+    ...data.requireSandbox === void 0 ? {} : { requireSandbox: data.requireSandbox },
+    ...data.denyPaths === void 0 ? {} : { denyPaths: data.denyPaths },
+    ...data.allowedModels === void 0 ? {} : { allowedModels: data.allowedModels },
+    ...data.network === void 0 ? {} : {
+      network: {
+        ...data.network.blockedHosts === void 0 ? {} : { blockedHosts: data.network.blockedHosts },
+        ...data.network.strictAllowlist === void 0 ? {} : { strictAllowlist: data.network.strictAllowlist }
+      }
+    },
+    ...data.limits === void 0 ? {} : {
+      limits: {
+        ...data.limits.maxSteps === void 0 ? {} : { maxSteps: data.limits.maxSteps },
+        ...data.limits.tokenBudget === void 0 ? {} : { tokenBudget: data.limits.tokenBudget }
+      }
+    },
+    ...data.audit === void 0 ? {} : {
+      audit: {
+        ...data.audit.enabled === void 0 ? {} : { enabled: data.audit.enabled },
+        ...data.audit.level === void 0 ? {} : { level: data.audit.level }
+      }
+    }
+  };
+}
+async function readPolicyFile(file) {
+  let text;
+  try {
+    text = await readFile(file, "utf8");
+  } catch (error) {
+    if (error.code === "ENOENT") return void 0;
+    throw new Error(`${file}: ${error.message}`);
+  }
+  let json;
+  try {
+    json = JSON.parse(text);
+  } catch (error) {
+    throw new Error(`${file}: invalid JSON: ${error.message}`);
+  }
+  try {
+    return parsePolicy(json);
+  } catch (error) {
+    throw new Error(`${file}: ${error.message}`);
+  }
+}
+function mergePolicies(user, managed) {
+  if (user === void 0) return managed;
+  if (managed === void 0) return user;
+  const union = (a, b) => a === void 0 && b === void 0 ? void 0 : [.../* @__PURE__ */ new Set([...a ?? [], ...b ?? []])];
+  const either = (a, b) => a === void 0 && b === void 0 ? void 0 : a === true || b === true;
+  const lower = (a, b) => a === void 0 ? b : b === void 0 ? a : Math.min(a, b);
+  const disallowedCommands = union(user.disallowedCommands, managed.disallowedCommands);
+  const denyPaths = union(user.denyPaths, managed.denyPaths);
+  const requireSandbox = either(user.requireSandbox, managed.requireSandbox);
+  const allowedModels = managed.allowedModels ?? user.allowedModels;
+  const blockedHosts = union(user.network?.blockedHosts, managed.network?.blockedHosts);
+  const strictAllowlist = either(user.network?.strictAllowlist, managed.network?.strictAllowlist);
+  const maxSteps = lower(user.limits?.maxSteps, managed.limits?.maxSteps);
+  const tokenBudget = lower(user.limits?.tokenBudget, managed.limits?.tokenBudget);
+  const audit = managed.audit ?? user.audit;
+  return {
+    ...disallowedCommands === void 0 ? {} : { disallowedCommands },
+    ...requireSandbox === void 0 ? {} : { requireSandbox },
+    ...denyPaths === void 0 ? {} : { denyPaths },
+    ...allowedModels === void 0 ? {} : { allowedModels },
+    ...blockedHosts === void 0 && strictAllowlist === void 0 ? {} : {
+      network: {
+        ...blockedHosts === void 0 ? {} : { blockedHosts },
+        ...strictAllowlist === void 0 ? {} : { strictAllowlist }
+      }
+    },
+    ...maxSteps === void 0 && tokenBudget === void 0 ? {} : {
+      limits: {
+        ...maxSteps === void 0 ? {} : { maxSteps },
+        ...tokenBudget === void 0 ? {} : { tokenBudget }
+      }
+    },
+    ...audit === void 0 ? {} : { audit }
+  };
+}
+async function loadTeamPolicy(options = {}) {
+  const userFile = join(options.home ?? homedir(), POLICY_FILE);
+  const managedFile = "managed" in options ? options.managed : managedPolicyPath();
+  const user = await readPolicyFile(userFile);
+  const managed = managedFile === void 0 ? void 0 : await readPolicyFile(managedFile);
+  const policy = mergePolicies(user, managed);
+  if (policy === void 0) return void 0;
+  const sources = [
+    ...managed === void 0 || managedFile === void 0 ? [] : [managedFile],
+    ...user === void 0 ? [] : [userFile]
+  ];
+  return { policy, sources };
+}
+function isCommandDisallowedByPolicy(policy, command) {
+  if (!policy.disallowedCommands || policy.disallowedCommands.length === 0) {
+    return { disallowed: false };
+  }
+  const parts = commandParts(command);
+  for (const pattern of policy.disallowedCommands) {
+    const hit = (part) => commandMatches(pattern, part);
+    if (parts.some(hit) || hit(command)) {
+      return {
+        disallowed: true,
+        pattern,
+        reason: `Command is disallowed by team policy: pattern "${pattern}".`
+      };
+    }
+  }
+  return { disallowed: false };
+}
+function isSandboxRequiredByPolicy(policy, outsideSandbox) {
+  if (policy.requireSandbox === true && outsideSandbox) {
+    return {
+      disallowed: true,
+      reason: "The team policy requires the OS sandbox: this command would run outside it (outside_sandbox, or no sandbox on this machine)."
+    };
+  }
+  return { disallowed: false };
+}
+function isPathDeniedByPolicy(policy, path) {
+  if (!policy.denyPaths || policy.denyPaths.length === 0) {
+    return { denied: false };
+  }
+  for (const pattern of policy.denyPaths) {
+    if (pathMatches(pattern, path)) {
+      return {
+        denied: true,
+        pattern,
+        reason: `Access to path "${path}" is disallowed by team policy: pattern "${pattern}".`
+      };
+    }
+  }
+  return { denied: false };
+}
+function isModelAllowedByPolicy(policy, modelId) {
+  if (!policy.allowedModels || policy.allowedModels.length === 0) {
+    return { allowed: true };
+  }
+  const allowed = policy.allowedModels.some((pattern) => commandMatches(pattern, modelId));
+  if (!allowed) {
+    return {
+      allowed: false,
+      reason: `Model "${modelId}" is not permitted by team policy. Allowed: ${policy.allowedModels.join(", ")}.`
+    };
+  }
+  return { allowed: true };
+}
+function assertModelAllowedByPolicy(policy, modelId) {
+  if (policy === void 0) return;
+  const decision = isModelAllowedByPolicy(policy, modelId);
+  if (!decision.allowed) {
+    throw new Error(decision.reason ?? `Model "${modelId}" is not permitted by team policy.`);
+  }
+}
+function isHostBlockedByPolicy(policy, host) {
+  if (!policy.network?.blockedHosts || policy.network.blockedHosts.length === 0) {
+    return { blocked: false };
+  }
+  const name = host.replace(/^\[|\]$/g, "").replace(/\.$/, "");
+  for (const pattern of policy.network.blockedHosts) {
+    if (hostMatches(pattern, name)) {
+      return {
+        blocked: true,
+        pattern,
+        reason: `Network access to host "${host}" is blocked by team policy: pattern "${pattern}".`
+      };
+    }
+  }
+  return { blocked: false };
+}
+
+export {
+  POLICY_FILE,
+  managedPolicyPath,
+  ignoredProjectPolicy,
+  parsePolicy,
+  mergePolicies,
+  loadTeamPolicy,
+  isCommandDisallowedByPolicy,
+  isSandboxRequiredByPolicy,
+  isPathDeniedByPolicy,
+  isModelAllowedByPolicy,
+  assertModelAllowedByPolicy,
+  isHostBlockedByPolicy
+};
+//# sourceMappingURL=chunk-HUIK3WXO.js.map

package/dist/chunk-INRZR772.js

@@ -0,0 +1,73 @@
+#!/usr/bin/env node
+import {
+  MANAGED,
+  jdtlsInstallCommand,
+  managedDir
+} from "./chunk-EU7PA45O.js";
+import {
+  DEFAULT_ENV_ALLOWLIST
+} from "./chunk-SI2QJYCR.js";
+
+// src/lsp/install.ts
+import { mkdir } from "fs/promises";
+var INSTALL_TIMEOUT_MS = 3e5;
+var NPM_ENV = [
+  "HTTP_PROXY",
+  "HTTPS_PROXY",
+  "NO_PROXY",
+  "http_proxy",
+  "https_proxy",
+  "no_proxy",
+  "NODE_EXTRA_CA_CERTS",
+  "npm_config_registry",
+  "NPM_CONFIG_REGISTRY"
+];
+function installCommand(language, dir) {
+  const managed = MANAGED[language];
+  if (managed.kind === "eclipse") return jdtlsInstallCommand(dir, quote);
+  return [
+    "npm",
+    "install",
+    "--prefix",
+    quote(dir),
+    "--ignore-scripts",
+    "--no-audit",
+    "--no-fund",
+    "--loglevel=error",
+    ...managed.packages
+  ].join(" ");
+}
+async function installServer(language, options) {
+  const dir = managedDir(language, options.home);
+  await mkdir(dir, { recursive: true });
+  const command = installCommand(language, dir);
+  const policy = {
+    root: dir,
+    sandbox: false,
+    writePaths: [],
+    denyWritePaths: [],
+    denyReadPaths: [],
+    network: true,
+    envAllowlist: [...DEFAULT_ENV_ALLOWLIST, ...NPM_ENV],
+    timeoutMs: INSTALL_TIMEOUT_MS,
+    maxOutputBytes: 2e4
+  };
+  const result = await options.executor.run(
+    command,
+    policy,
+    options.signal === void 0 ? {} : { signal: options.signal }
+  );
+  if (result.exitCode === 0) return { ok: true, dir, command };
+  const why = result.timedOut ? `npm took longer than ${INSTALL_TIMEOUT_MS / 1e3} s.` : [result.stderr.text, result.stdout.text].join("\n").trim().split("\n").slice(-8).join("\n");
+  return { ok: false, dir, command, output: why || `npm exited with ${result.exitCode}.` };
+}
+function quote(text) {
+  return /^[\w./:@-]+$/.test(text) ? text : `'${text.replaceAll("'", `'\\''`)}'`;
+}
+
+export {
+  INSTALL_TIMEOUT_MS,
+  installCommand,
+  installServer
+};
+//# sourceMappingURL=chunk-INRZR772.js.map

package/dist/chunk-K3SIUOAG.js

@@ -0,0 +1,138 @@
+#!/usr/bin/env node
+import {
+  JobGitError,
+  git
+} from "./chunk-2TAXSFWN.js";
+
+// src/jobs/worktree.ts
+import { createHash } from "crypto";
+import { existsSync, lstatSync, realpathSync } from "fs";
+import { mkdir, symlink } from "fs/promises";
+import { homedir } from "os";
+import { basename, join } from "path";
+var LINK_CANDIDATES = ["node_modules", ".venv", "venv"];
+var NEVER_COMMIT = [
+  ".garuda/sessions",
+  ".garuda/index",
+  ".garuda/evals",
+  ".garuda/jobs",
+  ".garuda/audit.jsonl"
+];
+function worktreeDir(root, id, home = homedir()) {
+  const hash = createHash("sha256").update(root).digest("hex").slice(0, 8);
+  return join(home, ".garuda", "worktrees", `${basename(root)}-${hash}`, id);
+}
+async function jobBase(executor, root) {
+  const head = await git(executor, root, ["rev-parse", "--verify", "HEAD"], { check: false });
+  if (head.exitCode !== 0) {
+    throw new JobGitError("A job needs a git repository with at least one commit.");
+  }
+  const commit = head.stdout.trim();
+  const stash = (await git(executor, root, ["stash", "create"])).stdout.trim();
+  const untracked = (await git(executor, root, ["ls-files", "--others", "--exclude-standard"])).stdout.split("\n").filter((l) => l !== "" && !l.startsWith(".garuda/")).length;
+  if (stash === "") return { commit, uncommitted: false, untracked };
+  const tree = `${stash}^{tree}`;
+  const base = await git(executor, root, [
+    "commit-tree",
+    tree,
+    "-p",
+    commit,
+    "-m",
+    "Garuda job base: uncommitted changes at scheduling time"
+  ]);
+  return { commit: base.stdout.trim(), uncommitted: true, untracked };
+}
+function cleanArgs(links = LINK_CANDIDATES) {
+  return ["clean", "-fdq", ...links.flatMap((name) => ["-e", `/${name}`])];
+}
+function linkCandidates(root) {
+  return LINK_CANDIDATES.filter((name) => {
+    try {
+      return lstatSync(join(root, name)).isDirectory();
+    } catch {
+      return false;
+    }
+  });
+}
+async function prepareWorktree(executor, job, signal) {
+  if (!existsSync(join(job.worktree, ".git"))) {
+    await mkdir(join(job.worktree, ".."), { recursive: true, mode: 448 });
+    const branch = await git(
+      executor,
+      job.root,
+      ["rev-parse", "--verify", `refs/heads/${job.branch}`],
+      { check: false, ...signal === void 0 ? {} : { signal } }
+    );
+    const args = branch.exitCode === 0 ? ["worktree", "add", job.worktree, job.branch] : ["worktree", "add", "-b", job.branch, job.worktree, job.base];
+    await git(executor, job.root, args, signal === void 0 ? {} : { signal });
+  }
+  const links = [];
+  for (const name of job.links) {
+    const target = join(job.root, name);
+    const link = join(job.worktree, name);
+    if (!existsSync(target)) continue;
+    if (!existsSync(link)) await symlink(target, link, "dir");
+    links.push(realpathSync(target));
+  }
+  return { links };
+}
+async function commitJob(executor, job, message) {
+  const exclude = [...NEVER_COMMIT, ...job.links].map((p) => `:(exclude)${p}`);
+  await git(executor, job.worktree, ["add", "-A", "--", ".", ...exclude]);
+  const staged = await git(executor, job.worktree, ["diff", "--cached", "--quiet"], {
+    check: false
+  });
+  if (staged.exitCode === 0) return void 0;
+  await git(executor, job.worktree, ["commit", "--no-verify", "-q", "-m", message]);
+  return (await git(executor, job.worktree, ["rev-parse", "HEAD"])).stdout.trim();
+}
+async function jobChanges(executor, job) {
+  const range = [job.base, job.branch];
+  const names = await git(executor, job.root, [
+    "diff",
+    "--no-renames",
+    "--name-status",
+    "-z",
+    ...range
+  ]);
+  const counts = await git(executor, job.root, [
+    "diff",
+    "--no-renames",
+    "--numstat",
+    "-z",
+    ...range
+  ]);
+  return parseChanges(names, counts);
+}
+function parseChanges(names, counts) {
+  const lines = /* @__PURE__ */ new Map();
+  for (const entry of counts.stdout.split("\0")) {
+    const m = /^(\d+|-)\t(\d+|-)\t(.*)$/s.exec(entry);
+    if (m === null) continue;
+    lines.set(m[3], m[1] === "-" ? {} : { added: Number(m[1]), removed: Number(m[2]) });
+  }
+  const parts = names.stdout.split("\0").filter((p) => p !== "");
+  const files = [];
+  for (let i = 0; i + 1 < parts.length; i += 2) {
+    const code = parts[i];
+    const path = parts[i + 1];
+    files.push({
+      status: code === "A" ? "added" : code === "D" ? "deleted" : "modified",
+      path,
+      ...lines.get(path)
+    });
+  }
+  return files;
+}
+
+export {
+  LINK_CANDIDATES,
+  worktreeDir,
+  jobBase,
+  cleanArgs,
+  linkCandidates,
+  prepareWorktree,
+  commitJob,
+  jobChanges
+};
+//# sourceMappingURL=chunk-K3SIUOAG.js.map