@garuda-agent/garuda 0.0.1 → 0.14.1

package/dist/chunk-V7WPGQLB.js

@@ -0,0 +1,207 @@
+#!/usr/bin/env node
+import {
+  keepSecretForRedaction
+} from "./chunk-ITITLNAR.js";
+import {
+  lookupModel
+} from "./chunk-W7BPYQMW.js";
+import {
+  isLoopbackHost
+} from "./chunk-ATW7BNIG.js";
+
+// src/model/providers.ts
+import { readFile } from "fs/promises";
+import { homedir } from "os";
+import { join } from "path";
+import { z } from "zod";
+var MODELS_FILE = join(".garuda", "models.json");
+var priceSchema = z.strictObject({
+  input: z.number().min(0),
+  output: z.number().min(0),
+  cacheRead: z.number().min(0),
+  cacheWrite: z.number().min(0)
+});
+var providerSchema = z.strictObject({
+  type: z.enum(["anthropic", "openai-compatible"]),
+  /** For openai-compatible: the URL that ends before /chat/completions. */
+  baseUrl: z.url().optional(),
+  /** The environment variable that holds the API key. */
+  apiKeyEnv: z.string().regex(/^[A-Za-z_][A-Za-z0-9_]*$/).optional(),
+  /** A server on this machine: price 0 unless a model entry says otherwise. */
+  local: z.boolean().optional(),
+  /** Allow plain http to a host that is not this machine. Off: an API key could travel in clear text. */
+  allowInsecureHttp: z.boolean().optional()
+});
+var modelSchema = z.strictObject({
+  contextWindow: z.number().int().min(4096).optional(),
+  price: priceSchema.optional(),
+  maxTokens: z.number().int().min(256).optional(),
+  /**
+   * Tool calls that the model writes as JSON text (openai-compatible only): "whole" (default) when
+   * the whole reply is calls, "lines" when calls stand on their own lines between prose, "off".
+   */
+  textToolCalls: z.enum(["off", "whole", "lines"]).optional()
+});
+var fileSchema = z.strictObject({
+  providers: z.record(z.string().regex(/^[a-z][a-z0-9-]{0,31}$/), providerSchema).default({}),
+  /** Keyed by the full spec, for example "ollama/qwen3-coder:30b". */
+  models: z.record(z.string(), modelSchema).default({})
+});
+var BUILTIN_PROVIDERS = {
+  anthropic: { type: "anthropic" },
+  ollama: { type: "openai-compatible", baseUrl: "http://localhost:11434/v1", local: true },
+  lmstudio: { type: "openai-compatible", baseUrl: "http://localhost:1234/v1", local: true },
+  llamacpp: { type: "openai-compatible", baseUrl: "http://localhost:8080/v1", local: true },
+  vllm: { type: "openai-compatible", baseUrl: "http://localhost:8000/v1", local: true },
+  openrouter: {
+    type: "openai-compatible",
+    baseUrl: "https://openrouter.ai/api/v1",
+    apiKeyEnv: "OPENROUTER_API_KEY"
+  }
+};
+var OPEN_MODEL_DEFAULT_WINDOW = 32768;
+var ZERO_PRICE = { input: 0, output: 0, cacheRead: 0, cacheWrite: 0 };
+async function loadModelsConfig(home = homedir()) {
+  const file = join(home, MODELS_FILE);
+  let text;
+  try {
+    text = await readFile(file, "utf8");
+  } catch (error) {
+    if (error.code === "ENOENT")
+      return { config: { providers: {}, models: {} } };
+    return {
+      config: { providers: {}, models: {} },
+      problem: `${file}: ${error.message}`
+    };
+  }
+  try {
+    const parsed = fileSchema.safeParse(JSON.parse(text));
+    if (!parsed.success) {
+      return {
+        config: { providers: {}, models: {} },
+        problem: `${file}: ${z.prettifyError(parsed.error)}`
+      };
+    }
+    return { config: parsed.data };
+  } catch (error) {
+    return {
+      config: { providers: {}, models: {} },
+      problem: `${file}: invalid JSON: ${error.message}`
+    };
+  }
+}
+var keptKeys = /* @__PURE__ */ new Map();
+function keepProviderKey(name) {
+  const value = process.env[name];
+  if (value !== void 0 && value !== "") {
+    keptKeys.set(name, value);
+    keepSecretForRedaction(name, value);
+    delete process.env[name];
+  }
+}
+function hasProviderKey(name) {
+  return keptKeys.has(name) || (process.env[name] ?? "") !== "";
+}
+function providerKey(env, name) {
+  if (name === void 0) return void 0;
+  return keptKeys.get(name) ?? env[name];
+}
+function resolveModel(spec, config = { providers: {}, models: {} }) {
+  const providers = { ...BUILTIN_PROVIDERS, ...config.providers };
+  const slash = spec.indexOf("/");
+  const [provider, model] = slash === -1 ? ["anthropic", spec] : [spec.slice(0, slash), spec.slice(slash + 1)];
+  const def = providers[provider];
+  if (def === void 0) {
+    throw new Error(
+      `Unknown model provider "${provider}" in "${spec}". Known providers: ${Object.keys(providers).join(", ")}. Add others in ~/${MODELS_FILE}.`
+    );
+  }
+  if (model === "") throw new Error(`"${spec}" names no model. Use <provider>/<model>.`);
+  if (def.type === "openai-compatible") checkBaseUrl(provider, def);
+  const entry = config.models[spec] ?? (provider === "anthropic" ? config.models[model] : void 0);
+  const base = def.type === "anthropic" ? lookupModel(model) : { contextWindow: OPEN_MODEL_DEFAULT_WINDOW, ...def.local ? { price: ZERO_PRICE } : {} };
+  const info = {
+    contextWindow: entry?.contextWindow ?? base.contextWindow,
+    ...entry?.price !== void 0 ? { price: entry.price } : base.price !== void 0 ? { price: base.price } : {},
+    // Thinking by model (0.9): only Claude models on the Anthropic provider have it.
+    ...base.thinking === void 0 ? {} : { thinking: base.thinking }
+  };
+  const notes = [];
+  if (def.type === "openai-compatible" && entry?.contextWindow === void 0) {
+    notes.push(
+      `Garuda assumes a ${OPEN_MODEL_DEFAULT_WINDOW}-token context window for ${spec}. Set the real value ("contextWindow") for "${spec}" in ~/${MODELS_FILE}; the server must allow it too (for Ollama: OLLAMA_CONTEXT_LENGTH).`
+    );
+  }
+  return {
+    spec,
+    provider,
+    model,
+    def,
+    info,
+    notes,
+    ...entry?.maxTokens === void 0 ? {} : { maxTokens: entry.maxTokens },
+    ...def.type === "anthropic" ? {
+      async createBatch(env = process.env, options = {}) {
+        const apiKey = providerKey(env, def.apiKeyEnv ?? "ANTHROPIC_API_KEY");
+        const { AnthropicBatchClient } = await import("./anthropic-NQDBCHJU.js");
+        return new AnthropicBatchClient({ model, ...apiKey ? { apiKey } : {}, ...options });
+      }
+    } : {},
+    async create(env = process.env) {
+      const apiKey = providerKey(env, def.apiKeyEnv);
+      if (def.apiKeyEnv !== void 0 && (apiKey === void 0 || apiKey === "")) {
+        throw new Error(`Set ${def.apiKeyEnv} to use the ${provider} provider.`);
+      }
+      if (def.type === "anthropic") {
+        const key = providerKey(env, def.apiKeyEnv ?? "ANTHROPIC_API_KEY");
+        const { AnthropicClient } = await import("./anthropic-NQDBCHJU.js");
+        return new AnthropicClient({ model, ...key ? { apiKey: key } : {} });
+      }
+      const { OpenAICompatibleClient } = await import("./openaiCompatible-CJWVJP5M.js");
+      return new OpenAICompatibleClient({
+        provider,
+        baseUrl: def.baseUrl,
+        model,
+        ...apiKey === void 0 ? {} : { apiKey },
+        ...entry?.textToolCalls === void 0 ? {} : { textToolCalls: entry.textToolCalls }
+      });
+    }
+  };
+}
+function checkBaseUrl(provider, def) {
+  if (def.baseUrl === void 0) throw new Error(`Provider "${provider}" needs a baseUrl.`);
+  const url = new URL(def.baseUrl);
+  if (url.protocol !== "https:" && url.protocol !== "http:") {
+    throw new Error(`Provider "${provider}": the baseUrl must use http or https.`);
+  }
+  if (url.username !== "" || url.password !== "") {
+    throw new Error(`Provider "${provider}": put credentials in apiKeyEnv, not in the baseUrl.`);
+  }
+  if (url.protocol === "http:" && !isLoopbackHost(url.hostname) && def.allowInsecureHttp !== true) {
+    throw new Error(
+      `Provider "${provider}" uses plain http to ${url.hostname}. Use https, or set "allowInsecureHttp": true for a trusted network.`
+    );
+  }
+}
+
+// src/permissions/autoApprover.ts
+var AutoApprover = class {
+  requests = [];
+  answer;
+  constructor(answer = "once") {
+    this.answer = typeof answer === "function" ? answer : () => answer;
+  }
+  async ask(request) {
+    this.requests.push(request);
+    return this.answer(request);
+  }
+};
+
+export {
+  loadModelsConfig,
+  keepProviderKey,
+  hasProviderKey,
+  resolveModel,
+  AutoApprover
+};
+//# sourceMappingURL=chunk-V7WPGQLB.js.map

package/dist/chunk-W7BPYQMW.js

@@ -0,0 +1,173 @@
+#!/usr/bin/env node
+import {
+  cleanLine
+} from "./chunk-PZS3V6P3.js";
+import {
+  EFFORTS
+} from "./chunk-D5O5CIWK.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-W7BPYQMW.js.map

package/dist/chunk-WMOLXTBU.js

@@ -0,0 +1,61 @@
+#!/usr/bin/env node
+
+// src/permissions/pathGuard.ts
+import { realpath } from "fs/promises";
+import { dirname, isAbsolute, relative, resolve, sep } from "path";
+var PathOutsideRootError = class extends Error {
+  constructor(input) {
+    super(`Path "${input}" is outside the working root.`);
+    this.name = "PathOutsideRootError";
+  }
+};
+function isInside(parent, child) {
+  const rel = relative(parent, child);
+  return rel === "" || !rel.startsWith(`..${sep}`) && rel !== ".." && !isAbsolute(rel);
+}
+async function resolveInRoot(root, input) {
+  const absolute = resolve(root, input === "" ? "." : input);
+  if (!isInside(root, absolute)) throw new PathOutsideRootError(input);
+  const realRoot = await realpath(root);
+  const realTarget = await realpathOfNearestExisting(absolute);
+  if (!isInside(realRoot, realTarget)) throw new PathOutsideRootError(input);
+  return absolute;
+}
+async function realRelative(root, path) {
+  try {
+    const realRoot = await realpath(root);
+    const real = await realpathOfNearestExisting(resolve(root, path));
+    if (!isInside(realRoot, real)) return void 0;
+    const shown = displayPath(realRoot, real);
+    return shown === path ? void 0 : shown;
+  } catch {
+    return void 0;
+  }
+}
+async function realpathOfNearestExisting(path) {
+  let current = path;
+  for (; ; ) {
+    try {
+      const real = await realpath(current);
+      return resolve(real, relative(current, path));
+    } catch (error) {
+      if (error.code !== "ENOENT") throw error;
+      const parent = dirname(current);
+      if (parent === current) return path;
+      current = parent;
+    }
+  }
+}
+function displayPath(root, absolute) {
+  const rel = relative(root, absolute);
+  return rel === "" ? "." : rel.split(sep).join("/");
+}
+
+export {
+  PathOutsideRootError,
+  isInside,
+  resolveInRoot,
+  realRelative,
+  displayPath
+};
+//# sourceMappingURL=chunk-WMOLXTBU.js.map

package/dist/chunk-YIZWYUBG.js

@@ -0,0 +1,138 @@
+#!/usr/bin/env node
+import {
+  JobGitError,
+  git
+} from "./chunk-ZGZ2ZADL.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-YIZWYUBG.js.map