@dylanrussell/agent-router 1.0.0

package/dist/cli.js

@@ -0,0 +1,1259 @@
+#!/usr/bin/env node
+var __defProp = Object.defineProperty;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __esm = (fn, res) => function __init() {
+  return fn && (res = (0, fn[__getOwnPropNames(fn)[0]])(fn = 0)), res;
+};
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+
+// src/core/errors.ts
+var RouterError, StackNotFoundError, AgentFileError, ValidationError, ModelValidationError, IOError, UserError;
+var init_errors = __esm({
+  "src/core/errors.ts"() {
+    "use strict";
+    RouterError = class extends Error {
+      /** CLI exit code for this error class. Subclasses override. */
+      static exitCode = 1;
+      name = "RouterError";
+    };
+    StackNotFoundError = class extends RouterError {
+      constructor(stackName, available) {
+        super(
+          `Stack "${stackName}" not found. Available: ${available.length ? available.join(", ") : "(none)"}.`
+        );
+        this.stackName = stackName;
+        this.available = available;
+      }
+      stackName;
+      available;
+      static exitCode = 2;
+      name = "StackNotFoundError";
+    };
+    AgentFileError = class extends RouterError {
+      constructor(agentName, filePath, reason) {
+        super(`Agent "${agentName}" (${filePath}): ${reason}`);
+        this.agentName = agentName;
+        this.filePath = filePath;
+      }
+      agentName;
+      filePath;
+      static exitCode = 2;
+      name = "AgentFileError";
+    };
+    ValidationError = class extends RouterError {
+      constructor(message, path9, issues) {
+        super(message);
+        this.path = path9;
+        this.issues = issues;
+      }
+      path;
+      issues;
+      static exitCode = 4;
+      name = "ValidationError";
+    };
+    ModelValidationError = class extends RouterError {
+      constructor(stackName, missing) {
+        super(
+          `Stack "${stackName}" references ${missing.length} unreachable model ID${missing.length === 1 ? "" : "s"}.`
+        );
+        this.stackName = stackName;
+        this.missing = missing;
+      }
+      stackName;
+      missing;
+      static exitCode = 4;
+      name = "ModelValidationError";
+    };
+    IOError = class extends RouterError {
+      static exitCode = 3;
+      name = "IOError";
+      causedBy;
+      constructor(message, causedBy) {
+        super(message);
+        this.causedBy = causedBy;
+      }
+    };
+    UserError = class extends RouterError {
+      static exitCode = 1;
+      name = "UserError";
+    };
+  }
+});
+
+// src/core/schema.ts
+import { z } from "zod";
+var StateFileSchema, AgentEntrySchema, StackFileSchema, ConfigFileSchema, OpencodeJsonSchema;
+var init_schema = __esm({
+  "src/core/schema.ts"() {
+    "use strict";
+    StateFileSchema = z.object({
+      version: z.literal(1),
+      active: z.string().min(1),
+      previousActive: z.string().min(1).nullable(),
+      lastSwitchedAt: z.string().min(1)
+    }).strict();
+    AgentEntrySchema = z.object({
+      model: z.string().min(1)
+    }).passthrough();
+    StackFileSchema = z.object({
+      agents: z.record(z.string(), AgentEntrySchema)
+    }).passthrough().refine((s) => Object.keys(s.agents).length > 0, {
+      message: "Stack file must map at least one agent in `agents`."
+    });
+    ConfigFileSchema = z.object({
+      /** Where the agent .md files live. Default: `${opencodeConfigDir}/agents`. */
+      agentsDir: z.string().min(1).optional(),
+      /** Where named stacks live. Default: `${routerHome}/stacks`. */
+      stacksDir: z.string().min(1).optional()
+    }).strict();
+    OpencodeJsonSchema = z.object({
+      plugin: z.array(z.string()).optional()
+    }).passthrough();
+  }
+});
+
+// src/core/atomic-write.ts
+import { randomBytes } from "crypto";
+import { mkdir as mkdir2, realpath, rename, unlink, writeFile } from "fs/promises";
+import path5 from "path";
+async function resolveDestination(destPath) {
+  try {
+    return await realpath(destPath);
+  } catch {
+    try {
+      const dir = await realpath(path5.dirname(destPath));
+      return path5.join(dir, path5.basename(destPath));
+    } catch {
+      return destPath;
+    }
+  }
+}
+async function atomicWriteFile(destPath, contents) {
+  await mkdir2(path5.dirname(destPath), { recursive: true });
+  const dest = await resolveDestination(destPath);
+  const dir = path5.dirname(dest);
+  const tmp = path5.join(
+    dir,
+    `.${path5.basename(dest)}.artmp-${process.pid}-${randomBytes(4).toString("hex")}`
+  );
+  try {
+    await writeFile(tmp, contents, { encoding: "utf8", mode: 420 });
+    await rename(tmp, dest);
+  } catch (cause) {
+    await unlink(tmp).catch(() => {
+    });
+    throw new IOError(`Atomic write failed for ${destPath}: ${cause.message}`, cause);
+  }
+}
+async function atomicWriteJson(destPath, value) {
+  const text = `${JSON.stringify(value, null, 2)}
+`;
+  await atomicWriteFile(destPath, text);
+}
+var init_atomic_write = __esm({
+  "src/core/atomic-write.ts"() {
+    "use strict";
+    init_errors();
+  }
+});
+
+// src/core/state.ts
+var state_exports = {};
+__export(state_exports, {
+  readState: () => readState,
+  writeState: () => writeState
+});
+import { existsSync as existsSync5 } from "fs";
+import { readFile as readFile4 } from "fs/promises";
+async function readState(statePath) {
+  if (!existsSync5(statePath)) return null;
+  let raw;
+  try {
+    raw = await readFile4(statePath, "utf8");
+  } catch (cause) {
+    throw new IOError(`Failed to read ${statePath}: ${cause.message}`, cause);
+  }
+  let parsed;
+  try {
+    parsed = JSON.parse(raw);
+  } catch (cause) {
+    throw new ValidationError(
+      `state.json is not valid JSON: ${cause.message}`,
+      statePath
+    );
+  }
+  const result = StateFileSchema.safeParse(parsed);
+  if (!result.success) {
+    throw new ValidationError(
+      `state.json failed validation: ${result.error.issues.map((i) => i.message).join("; ")}`,
+      statePath,
+      result.error.issues.map((i) => `${i.path.join(".")}: ${i.message}`)
+    );
+  }
+  return result.data;
+}
+async function writeState(statePath, state) {
+  const result = StateFileSchema.safeParse(state);
+  if (!result.success) {
+    throw new ValidationError(
+      `Refusing to write invalid state.json: ${result.error.issues.map((i) => i.message).join("; ")}`,
+      statePath
+    );
+  }
+  await atomicWriteJson(statePath, result.data);
+}
+var init_state = __esm({
+  "src/core/state.ts"() {
+    "use strict";
+    init_atomic_write();
+    init_errors();
+    init_schema();
+  }
+});
+
+// src/cli.ts
+import { spawnSync } from "child_process";
+import { existsSync as existsSync7, realpathSync } from "fs";
+import { mkdir as mkdir5 } from "fs/promises";
+import path8 from "path";
+import { fileURLToPath } from "url";
+import { cac } from "cac";
+
+// src/core/backups.ts
+init_errors();
+import { existsSync } from "fs";
+import { copyFile, mkdir } from "fs/promises";
+import path from "path";
+function timestampStamp(date = /* @__PURE__ */ new Date()) {
+  return date.toISOString().replace(/[:.]/g, "-");
+}
+async function backupFiles(backupsRoot, files) {
+  const stamp = timestampStamp();
+  const dir = path.join(backupsRoot, stamp);
+  await mkdir(dir, { recursive: true });
+  for (const f of files) {
+    if (!existsSync(f)) continue;
+    try {
+      await copyFile(f, path.join(dir, path.basename(f)));
+    } catch (cause) {
+      throw new IOError(`Backup copy failed for ${f}: ${cause.message}`, cause);
+    }
+  }
+  return dir;
+}
+
+// src/core/config.ts
+init_errors();
+import { existsSync as existsSync2 } from "fs";
+import { readFile } from "fs/promises";
+import { homedir as homedir2 } from "os";
+import path3 from "path";
+
+// src/core/paths.ts
+import { homedir } from "os";
+import path2 from "path";
+function resolvePaths(options = {}) {
+  const env = options.env ?? process.env;
+  const opencodeConfigDir = options.opencodeConfigDir ?? path2.join(env.XDG_CONFIG_HOME ?? path2.join(homedir(), ".config"), "opencode");
+  const routerHome = options.routerHome ?? env.AGENT_ROUTER_HOME ?? env.OMO_ROUTER_HOME ?? path2.join(opencodeConfigDir, "agent-router");
+  const agentsDir = options.agentsDir ?? env.AGENT_ROUTER_AGENTS_DIR ?? path2.join(opencodeConfigDir, "agents");
+  const stacksDir = options.stacksDir ?? env.AGENT_ROUTER_STACKS_DIR ?? path2.join(routerHome, "stacks");
+  return {
+    opencodeConfigDir,
+    opencodeJsonPath: path2.join(opencodeConfigDir, "opencode.json"),
+    tuiJsonPath: path2.join(opencodeConfigDir, "tui.json"),
+    agentsDir,
+    opencodeBackupsDir: path2.join(opencodeConfigDir, ".backups"),
+    routerHome,
+    statePath: path2.join(routerHome, "state.json"),
+    stacksDir,
+    historyDir: path2.join(routerHome, "history")
+  };
+}
+
+// src/core/config.ts
+init_schema();
+var CONFIG_FILE_NAME = "config.json";
+function expandHome(p) {
+  if (p === "~") return homedir2();
+  if (p.startsWith("~/")) return path3.join(homedir2(), p.slice(2));
+  return p;
+}
+async function readConfigFile(routerHome) {
+  const configPath = path3.join(routerHome, CONFIG_FILE_NAME);
+  if (!existsSync2(configPath)) return null;
+  let raw;
+  try {
+    raw = await readFile(configPath, "utf8");
+  } catch (cause) {
+    throw new IOError(`Failed to read ${configPath}: ${cause.message}`, cause);
+  }
+  let parsed;
+  try {
+    parsed = JSON.parse(raw);
+  } catch (cause) {
+    throw new ValidationError(
+      `agent-router config.json is not valid JSON: ${cause.message}`,
+      configPath
+    );
+  }
+  const result = ConfigFileSchema.safeParse(parsed);
+  if (!result.success) {
+    throw new ValidationError(
+      `agent-router config.json failed validation: ${result.error.issues.map((i) => i.message).join("; ")}`,
+      configPath,
+      result.error.issues.map((i) => `${i.path.join(".")}: ${i.message}`)
+    );
+  }
+  return result.data;
+}
+function normalizeConfigPath(routerHome, p) {
+  const expanded = expandHome(p);
+  return path3.isAbsolute(expanded) ? expanded : path3.resolve(routerHome, expanded);
+}
+async function resolvePathsWithConfig(options = {}) {
+  const base = resolvePaths(options);
+  const config = await readConfigFile(base.routerHome);
+  if (!config) return base;
+  const next = { ...options };
+  if (options.agentsDir === void 0 && config.agentsDir) {
+    next.agentsDir = normalizeConfigPath(
+      base.routerHome,
+      config.agentsDir
+    );
+  }
+  if (options.stacksDir === void 0 && config.stacksDir) {
+    next.stacksDir = normalizeConfigPath(
+      base.routerHome,
+      config.stacksDir
+    );
+  }
+  return resolvePaths(next);
+}
+
+// src/cli.ts
+init_errors();
+
+// src/core/frontmatter.ts
+init_errors();
+import { existsSync as existsSync3 } from "fs";
+import { readFile as readFile2, readdir } from "fs/promises";
+import path4 from "path";
+var FRONTMATTER_RE = /^---\r?\n([\s\S]*?)\r?\n---(?:\r?\n|$)/;
+var MODEL_LINE_RE = /^model:[ \t]*(.*)$/m;
+function cleanModelValue(raw) {
+  let v = raw;
+  const hash = v.search(/[ \t]#/);
+  if (hash >= 0) v = v.slice(0, hash);
+  v = v.trim();
+  if (v.startsWith('"') && v.endsWith('"') && v.length >= 2 || v.startsWith("'") && v.endsWith("'") && v.length >= 2) {
+    v = v.slice(1, -1);
+  }
+  return v;
+}
+function getFrontmatterModel(content) {
+  const fm = FRONTMATTER_RE.exec(content);
+  if (!fm?.[1]) return null;
+  const line = MODEL_LINE_RE.exec(fm[1]);
+  if (!line) return null;
+  const value = cleanModelValue(line[1] ?? "");
+  return value.length > 0 ? value : null;
+}
+function setFrontmatterModel(content, model) {
+  const fm = FRONTMATTER_RE.exec(content);
+  if (!fm?.[1]) throw new Error("no frontmatter block");
+  const block = fm[1];
+  if (!MODEL_LINE_RE.test(block)) throw new Error("no `model:` line in frontmatter");
+  const nextBlock = block.replace(MODEL_LINE_RE, () => `model: ${model}`);
+  const blockStart = fm[0].indexOf(block);
+  const nextFm = fm[0].slice(0, blockStart) + nextBlock + fm[0].slice(blockStart + block.length);
+  return nextFm + content.slice(fm[0].length);
+}
+function agentFilePath(agentsDir, name) {
+  return path4.join(agentsDir, `${name}.md`);
+}
+async function listAgentFiles(agentsDir) {
+  if (!existsSync3(agentsDir)) return [];
+  let names;
+  try {
+    names = await readdir(agentsDir);
+  } catch (cause) {
+    throw new IOError(`Failed to read agents dir: ${cause.message}`, cause);
+  }
+  return names.filter((n) => n.endsWith(".md")).map((n) => n.slice(0, -".md".length)).sort();
+}
+async function readAgentModels(agentsDir) {
+  const out = {};
+  for (const name of await listAgentFiles(agentsDir)) {
+    const filePath = agentFilePath(agentsDir, name);
+    let content;
+    try {
+      content = await readFile2(filePath, "utf8");
+    } catch (cause) {
+      throw new IOError(`Failed to read ${filePath}: ${cause.message}`, cause);
+    }
+    const model = getFrontmatterModel(content);
+    if (model !== null) out[name] = model;
+  }
+  return out;
+}
+async function readAgentFileStrict(agentsDir, name) {
+  const filePath = agentFilePath(agentsDir, name);
+  if (!existsSync3(filePath)) {
+    throw new AgentFileError(name, filePath, "file does not exist");
+  }
+  let content;
+  try {
+    content = await readFile2(filePath, "utf8");
+  } catch (cause) {
+    throw new IOError(`Failed to read ${filePath}: ${cause.message}`, cause);
+  }
+  const model = getFrontmatterModel(content);
+  if (model === null) {
+    throw new AgentFileError(name, filePath, "no frontmatter `model:` line to rewrite");
+  }
+  return { filePath, content, model };
+}
+
+// src/core/history.ts
+init_atomic_write();
+import { mkdir as mkdir3, readdir as readdir2, unlink as unlink2 } from "fs/promises";
+import path6 from "path";
+init_errors();
+function filename(fromStack, toStack, when = /* @__PURE__ */ new Date()) {
+  const stamp = timestampStamp(when);
+  const safe = (s) => s.replace(/[^A-Za-z0-9._()-]/g, "_");
+  return `${stamp}__${safe(fromStack)}-to-${safe(toStack)}.json`;
+}
+function parseHistoryFilename(name) {
+  if (!name.endsWith(".json")) return null;
+  const stem = name.slice(0, -".json".length);
+  const sep = stem.indexOf("__");
+  if (sep < 0) return null;
+  const stamp = stem.slice(0, sep);
+  const rest = stem.slice(sep + 2);
+  const toIdx = rest.lastIndexOf("-to-");
+  if (toIdx < 0) return null;
+  return {
+    id: stem,
+    timestamp: stamp,
+    fromStack: rest.slice(0, toIdx),
+    toStack: rest.slice(toIdx + "-to-".length)
+  };
+}
+async function appendHistory(historyDir, fromStack, toStack, displacedContent) {
+  await mkdir3(historyDir, { recursive: true });
+  const name = filename(fromStack, toStack);
+  await atomicWriteFile(path6.join(historyDir, name), displacedContent);
+  return name.slice(0, -".json".length);
+}
+async function listHistory(historyDir) {
+  let names;
+  try {
+    names = await readdir2(historyDir);
+  } catch (cause) {
+    if (cause.code === "ENOENT") return [];
+    throw new IOError(`Failed to read history dir: ${cause.message}`, cause);
+  }
+  const entries = [];
+  for (const n of names) {
+    const parsed = parseHistoryFilename(n);
+    if (parsed) entries.push({ ...parsed, path: path6.join(historyDir, n) });
+  }
+  entries.sort((a, b) => a.timestamp < b.timestamp ? 1 : a.timestamp > b.timestamp ? -1 : 0);
+  return entries;
+}
+async function trimHistory(historyDir, keep = 20) {
+  const all = await listHistory(historyDir);
+  if (all.length <= keep) return [];
+  const toDelete = all.slice(keep);
+  const deleted = [];
+  for (const e of toDelete) {
+    try {
+      await unlink2(e.path);
+      deleted.push(e.id);
+    } catch (cause) {
+      void cause;
+    }
+  }
+  return deleted;
+}
+
+// src/core/opencode-config.ts
+init_atomic_write();
+init_errors();
+init_schema();
+import { existsSync as existsSync4 } from "fs";
+import { readFile as readFile3 } from "fs/promises";
+var PLUGIN_NPM_NAME = "@dylanrussell/agent-router";
+var PLUGIN_REGISTRY_ENTRY = `${PLUGIN_NPM_NAME}@latest`;
+var LEGACY_PLUGIN_NPM_NAME = "@dylanrussell/omo-router";
+async function readOpencodeJson(opencodeJsonPath) {
+  return readPluginConfigFile(opencodeJsonPath, "opencode.json");
+}
+async function readTuiJson(tuiJsonPath) {
+  return readPluginConfigFile(tuiJsonPath, "tui.json");
+}
+async function readPluginConfigFile(filePath, label) {
+  if (!existsSync4(filePath)) return null;
+  let raw;
+  try {
+    raw = await readFile3(filePath, "utf8");
+  } catch (cause) {
+    throw new IOError(`Failed to read ${filePath}: ${cause.message}`, cause);
+  }
+  let parsed;
+  try {
+    parsed = JSON.parse(raw);
+  } catch (cause) {
+    throw new ValidationError(`${label} is not valid JSON: ${cause.message}`, filePath);
+  }
+  const result = OpencodeJsonSchema.safeParse(parsed);
+  if (!result.success) {
+    throw new ValidationError(
+      `${label} failed validation: ${result.error.issues.map((i) => i.message).join("; ")}`,
+      filePath,
+      result.error.issues.map((i) => `${i.path.join(".")}: ${i.message}`)
+    );
+  }
+  return result.data;
+}
+function ensurePluginEntry(config, entry = PLUGIN_REGISTRY_ENTRY) {
+  const existing = config.plugin ?? [];
+  const already = existing.some(
+    (p) => p === entry || stripVersionTag(p) === stripVersionTag(entry)
+  );
+  if (already) {
+    return { config, result: { added: false, plugin: existing } };
+  }
+  const next = [...existing, entry];
+  return {
+    config: { ...config, plugin: next },
+    result: { added: true, plugin: next }
+  };
+}
+function removePluginEntry(config, npmName = LEGACY_PLUGIN_NPM_NAME) {
+  const existing = config.plugin ?? [];
+  const removed = existing.filter((p) => stripVersionTag(p) === npmName);
+  if (removed.length === 0) {
+    return { config, result: { removed: [], plugin: existing } };
+  }
+  const next = existing.filter((p) => stripVersionTag(p) !== npmName);
+  return {
+    config: { ...config, plugin: next },
+    result: { removed, plugin: next }
+  };
+}
+function stripVersionTag(entry) {
+  const lastAt = entry.lastIndexOf("@");
+  if (lastAt <= 0) return entry;
+  return entry.slice(0, lastAt);
+}
+async function writeOpencodeJson(opencodeJsonPath, config) {
+  await atomicWriteJson(opencodeJsonPath, config);
+}
+var TUI_JSON_SCHEMA_URL = "https://opencode.ai/config.json";
+async function ensureTuiJsonPluginEntry(tuiJsonPath, entry = PLUGIN_REGISTRY_ENTRY) {
+  const existing = await readTuiJson(tuiJsonPath) ?? { $schema: TUI_JSON_SCHEMA_URL };
+  const removed = removePluginEntry(existing);
+  const { config, result } = ensurePluginEntry(removed.config, entry);
+  if (result.added || removed.result.removed.length > 0) {
+    await atomicWriteJson(tuiJsonPath, config);
+  }
+  return result;
+}
+
+// src/cli.ts
+init_schema();
+
+// src/core/stack-manager.ts
+init_atomic_write();
+init_errors();
+import { existsSync as existsSync6 } from "fs";
+import { copyFile as copyFile2, mkdir as mkdir4, readFile as readFile5, readdir as readdir3, unlink as unlink3 } from "fs/promises";
+import path7 from "path";
+init_schema();
+init_state();
+
+// src/core/validator.ts
+init_errors();
+import { execFile } from "child_process";
+import { promisify } from "util";
+var execFileAsync = promisify(execFile);
+var DEFAULT_RUNNER = async () => {
+  const { stdout } = await execFileAsync("opencode", ["models"], {
+    encoding: "utf8",
+    timeout: 3e4,
+    maxBuffer: 4 * 1024 * 1024
+  });
+  return stdout;
+};
+function parseModelList(stdout) {
+  const out = /* @__PURE__ */ new Set();
+  for (const raw of stdout.split(/\r?\n/)) {
+    const line = raw.trim();
+    if (!line) continue;
+    if (line.startsWith("#")) continue;
+    out.add(line);
+  }
+  return out;
+}
+function collectModelRefs(stack) {
+  const refs = [];
+  for (const [k, v] of Object.entries(stack.agents)) {
+    refs.push({ path: `agents.${k}.model`, modelId: v.model });
+  }
+  return refs;
+}
+async function validateStack(stack, options = {}) {
+  const runner = options.runOpencodeModels ?? DEFAULT_RUNNER;
+  const stdout = await runner();
+  const available = parseModelList(stdout);
+  const refs = collectModelRefs(stack);
+  const missing = refs.filter((r) => !available.has(r.modelId));
+  return { ok: missing.length === 0, checked: refs.length, missing, available };
+}
+async function validateStackOrThrow(stackName, stack, options = {}) {
+  const result = await validateStack(stack, options);
+  if (!result.ok) throw new ModelValidationError(stackName, result.missing);
+  return result;
+}
+
+// src/core/stack-manager.ts
+async function listStacks(paths) {
+  if (!existsSync6(paths.stacksDir)) return [];
+  let names;
+  try {
+    names = await readdir3(paths.stacksDir);
+  } catch (cause) {
+    throw new IOError(`Failed to read stacks dir: ${cause.message}`, cause);
+  }
+  return names.filter((n) => n.endsWith(".json")).map((n) => n.slice(0, -".json".length)).sort();
+}
+function stackPath(paths, name) {
+  return path7.join(paths.stacksDir, `${name}.json`);
+}
+async function readStack(paths, name) {
+  const filePath = stackPath(paths, name);
+  if (!existsSync6(filePath)) {
+    throw new StackNotFoundError(name, await listStacks(paths));
+  }
+  const raw = await readFile5(filePath, "utf8").catch((cause) => {
+    throw new IOError(`Failed to read ${filePath}: ${cause.message}`, cause);
+  });
+  let parsed;
+  try {
+    parsed = JSON.parse(raw);
+  } catch (cause) {
+    throw new ValidationError(
+      `Stack "${name}" is not valid JSON: ${cause.message}`,
+      filePath
+    );
+  }
+  const result = StackFileSchema.safeParse(parsed);
+  if (!result.success) {
+    throw new ValidationError(
+      `Stack "${name}" failed validation: ${result.error.issues.map((i) => i.message).join("; ")}`,
+      filePath,
+      result.error.issues.map((i) => `${i.path.join(".")}: ${i.message}`)
+    );
+  }
+  return result.data;
+}
+async function readStackRaw(paths, name) {
+  const filePath = stackPath(paths, name);
+  if (!existsSync6(filePath)) {
+    throw new StackNotFoundError(name, await listStacks(paths));
+  }
+  return readFile5(filePath, "utf8");
+}
+async function getActiveStackName(paths) {
+  const state = await readState(paths.statePath);
+  return state?.active ?? null;
+}
+async function applyStack(paths, name, options = {}) {
+  const validate = options.validate ?? true;
+  const forceInvalid = options.forceInvalid ?? false;
+  const target = await readStack(paths, name);
+  if (validate && !forceInvalid) {
+    await validateStackOrThrow(name, target, options.validateOptions);
+  }
+  const pending = [];
+  for (const [agent, entry] of Object.entries(target.agents)) {
+    const { filePath, content, model } = await readAgentFileStrict(paths.agentsDir, agent);
+    pending.push({
+      agent,
+      filePath,
+      next: model === entry.model ? null : setFrontmatterModel(content, entry.model)
+    });
+  }
+  const prevState = await readState(paths.statePath);
+  const prevActive = prevState?.active ?? null;
+  const displaced = { agents: modelsToStackAgents(await readAgentModels(paths.agentsDir)) };
+  const historyId = await appendHistory(
+    paths.historyDir,
+    prevActive ?? "(none)",
+    name,
+    `${JSON.stringify(displaced, null, 2)}
+`
+  );
+  const changed = [];
+  for (const p of pending) {
+    if (p.next === null) continue;
+    await atomicWriteFile(p.filePath, p.next);
+    changed.push(p.agent);
+  }
+  await writeState(paths.statePath, {
+    version: 1,
+    active: name,
+    previousActive: prevActive,
+    lastSwitchedAt: (/* @__PURE__ */ new Date()).toISOString()
+  });
+  await trimHistory(paths.historyDir).catch(() => {
+  });
+  return {
+    previous: prevActive,
+    current: name,
+    changed,
+    historyId,
+    restartRequired: true
+  };
+}
+function modelsToStackAgents(models) {
+  const out = {};
+  for (const k of Object.keys(models).sort()) {
+    const model = models[k];
+    if (model !== void 0) out[k] = { model };
+  }
+  return out;
+}
+async function back(paths, n = 1, options = {}) {
+  if (n < 1) throw new UserError("`back -n` must be at least 1.");
+  const state = await readState(paths.statePath);
+  if (!state || !state.previousActive) {
+    throw new UserError("No previous stack to revert to.");
+  }
+  if (n === 1) return applyStack(paths, state.previousActive, options);
+  const entries = await listHistory(paths.historyDir);
+  if (entries.length < n) {
+    throw new UserError(
+      `Cannot go back ${n} steps; only ${entries.length} switch${entries.length === 1 ? "" : "es"} in history.`
+    );
+  }
+  const target = entries[n - 1]?.fromStack;
+  if (!target || target === "(none)") {
+    throw new UserError(`Cannot go back ${n} steps to a non-stack target ("${target}").`);
+  }
+  return applyStack(paths, target, options);
+}
+var STACK_NAME_RE = /^[A-Za-z0-9._-]+$/;
+function assertValidStackName(name) {
+  if (!STACK_NAME_RE.test(name)) {
+    throw new UserError(
+      `Stack name "${name}" contains invalid characters. Allowed: A-Z a-z 0-9 . _ -`
+    );
+  }
+}
+async function captureStack(paths, name, options = {}) {
+  assertValidStackName(name);
+  const dest = stackPath(paths, name);
+  if (existsSync6(dest) && !options.force) {
+    throw new UserError(`Stack "${name}" already exists. Use --force to overwrite.`);
+  }
+  const models = await readAgentModels(paths.agentsDir);
+  const agents = modelsToStackAgents(models);
+  if (Object.keys(agents).length === 0) {
+    throw new UserError(
+      `No agent .md files with a frontmatter \`model:\` line found in ${paths.agentsDir}.`
+    );
+  }
+  await mkdir4(paths.stacksDir, { recursive: true });
+  await atomicWriteJson(dest, { agents });
+  return { name, path: dest, agents: Object.keys(agents).length };
+}
+async function removeStack(paths, name, options = {}) {
+  const filePath = stackPath(paths, name);
+  if (!existsSync6(filePath)) {
+    throw new StackNotFoundError(name, await listStacks(paths));
+  }
+  const active = await getActiveStackName(paths);
+  if (active === name && !options.force) {
+    throw new UserError(`"${name}" is the active stack. Use --force to remove anyway.`);
+  }
+  await unlink3(filePath);
+}
+async function importStack(paths, name, fromFile, options = {}) {
+  assertValidStackName(name);
+  const dest = stackPath(paths, name);
+  if (existsSync6(dest) && !options.force) {
+    throw new UserError(`Stack "${name}" already exists. Use --force to overwrite.`);
+  }
+  if (!existsSync6(fromFile)) {
+    throw new UserError(`Import file does not exist: ${fromFile}`);
+  }
+  await mkdir4(paths.stacksDir, { recursive: true });
+  await copyFile2(fromFile, dest);
+}
+async function exportStack(paths, name, toFile) {
+  const filePath = stackPath(paths, name);
+  if (!existsSync6(filePath)) {
+    throw new StackNotFoundError(name, await listStacks(paths));
+  }
+  await mkdir4(path7.dirname(toFile), { recursive: true });
+  await copyFile2(filePath, toFile);
+}
+
+// src/version.ts
+var VERSION = "1.0.0";
+
+// src/cli.ts
+var log = (...args) => console.log(...args);
+var err = (...args) => console.error(...args);
+function formatStackListLine(name, isActive) {
+  return `${isActive ? "*" : " "} ${name}`;
+}
+var INIT_CAPTURE_NAME = "default";
+async function cmdInit(paths, opts) {
+  await mkdir5(paths.stacksDir, { recursive: true });
+  await mkdir5(paths.historyDir, { recursive: true });
+  const { readState: readState2, writeState: writeState2 } = await Promise.resolve().then(() => (init_state(), state_exports));
+  const existing = await readState2(paths.statePath);
+  const stacks = await listStacks(paths);
+  if ((!existing || opts.force) && stacks.length === 0) {
+    try {
+      const captured = await captureStack(paths, INIT_CAPTURE_NAME, { force: !!opts.force });
+      await writeState2(paths.statePath, {
+        version: 1,
+        active: INIT_CAPTURE_NAME,
+        previousActive: null,
+        lastSwitchedAt: (/* @__PURE__ */ new Date()).toISOString()
+      });
+      log(
+        `agent-router: captured ${captured.agents} agent${captured.agents === 1 ? "" : "s"} from ${paths.agentsDir} \u2192 stacks/${INIT_CAPTURE_NAME}.json (active)`
+      );
+    } catch (e) {
+      if (e instanceof UserError) {
+        log(`agent-router: no agents captured (${e.message})`);
+        log(
+          "  create agent .md files with a frontmatter `model:` line, then run `agent-router capture <name>`."
+        );
+      } else {
+        throw e;
+      }
+    }
+  } else if (existing) {
+    log(
+      `agent-router: state already initialized (active="${existing.active}"); use --force to reset`
+    );
+  }
+  if (opts.noEditOpencodeJson) {
+    log("agent-router: --no-edit-opencode-json passed; not editing opencode.json or tui.json");
+    log(`  add this to opencode.json plugin[]: "${PLUGIN_REGISTRY_ENTRY}"`);
+    log(`  add this to tui.json plugin[] (sidebar): "${PLUGIN_REGISTRY_ENTRY}"`);
+    return;
+  }
+  await editOpencodeJson(paths);
+  await editTuiJson(paths);
+}
+async function editTuiJson(paths) {
+  const exists = existsSync7(paths.tuiJsonPath);
+  if (exists) {
+    await backupFiles(paths.opencodeBackupsDir, [paths.tuiJsonPath]);
+  }
+  const result = await ensureTuiJsonPluginEntry(paths.tuiJsonPath);
+  if (result.added) {
+    log(`agent-router: added "${PLUGIN_REGISTRY_ENTRY}" to tui.json plugin[] (sidebar support)`);
+    return;
+  }
+  log("agent-router: tui.json already up to date");
+}
+async function editOpencodeJson(paths) {
+  const cfg = await readOpencodeJson(paths.opencodeJsonPath);
+  if (!cfg) {
+    log(`agent-router: ${paths.opencodeJsonPath} missing \u2014 skipping plugin edits.`);
+    return;
+  }
+  const removed = removePluginEntry(cfg);
+  const ensured = ensurePluginEntry(removed.config);
+  if (!ensured.result.added && removed.result.removed.length === 0) {
+    log("agent-router: opencode.json already up to date");
+    return;
+  }
+  await backupFiles(paths.opencodeBackupsDir, [paths.opencodeJsonPath]);
+  await writeOpencodeJson(paths.opencodeJsonPath, ensured.config);
+  if (removed.result.removed.length) {
+    log(
+      `agent-router: removed legacy plugin entr${removed.result.removed.length === 1 ? "y" : "ies"}: ${removed.result.removed.join(", ")}`
+    );
+  }
+  if (ensured.result.added) {
+    log(`agent-router: added "${PLUGIN_REGISTRY_ENTRY}" to opencode.json plugin[]`);
+  }
+}
+async function cmdList(paths) {
+  const stacks = await listStacks(paths);
+  if (stacks.length === 0) {
+    log("(no stacks; run `agent-router init` or `agent-router capture <name>`)");
+    return;
+  }
+  const active = await getActiveStackName(paths);
+  for (const s of stacks) log(formatStackListLine(s, s === active));
+}
+async function cmdStatus(paths) {
+  const active = await getActiveStackName(paths);
+  log(active ?? "(none)");
+}
+async function cmdShow(paths, name) {
+  const raw = await readStackRaw(paths, name);
+  try {
+    log(JSON.stringify(JSON.parse(raw), null, 2));
+  } catch {
+    process.stdout.write(raw);
+  }
+}
+async function cmdCurrent(paths) {
+  const models = await readAgentModels(paths.agentsDir);
+  const names = Object.keys(models).sort();
+  if (names.length === 0) {
+    log(`(no agent .md files with a \`model:\` line in ${paths.agentsDir})`);
+    return;
+  }
+  const width = Math.max(...names.map((n) => n.length));
+  for (const n of names) log(`${n.padEnd(width)}  ${models[n]}`);
+}
+async function cmdUse(paths, name, opts) {
+  const r = await applyStack(paths, name, {
+    validate: !opts.noValidate,
+    forceInvalid: opts.forceInvalid ?? false
+  });
+  log(
+    `Switched: ${r.previous ?? "(none)"} \u2192 ${r.current} (${r.changed.length} agent${r.changed.length === 1 ? "" : "s"} updated). Restart opencode for change to take effect.`
+  );
+}
+async function cmdBack(paths, n, opts) {
+  const r = await back(paths, n, {
+    validate: !opts.noValidate,
+    forceInvalid: opts.forceInvalid ?? false
+  });
+  log(
+    `Switched: ${r.previous ?? "(none)"} \u2192 ${r.current} (${r.changed.length} agent${r.changed.length === 1 ? "" : "s"} updated). Restart opencode for change to take effect.`
+  );
+}
+async function cmdCapture(paths, name, force) {
+  const r = await captureStack(paths, name, { force });
+  log(`Captured ${r.agents} agent${r.agents === 1 ? "" : "s"} \u2192 ${r.path}`);
+}
+async function cmdHistory(paths, limit) {
+  const entries = await listHistory(paths.historyDir);
+  if (entries.length === 0) {
+    log("(no history)");
+    return;
+  }
+  for (const e of entries.slice(0, limit)) {
+    log(`${e.id}  ${e.fromStack} \u2192 ${e.toStack}`);
+  }
+}
+async function cmdValidate(paths, name, opts) {
+  const targets = [];
+  if (opts.active) {
+    targets.push({
+      name: "(current frontmatter)",
+      load: async () => {
+        const models = await readAgentModels(paths.agentsDir);
+        const agents = Object.fromEntries(
+          Object.entries(models).map(([k, model]) => [k, { model }])
+        );
+        return { agents };
+      }
+    });
+  } else if (opts.all) {
+    for (const n of await listStacks(paths)) {
+      targets.push({ name: n, load: () => readStack(paths, n) });
+    }
+  } else {
+    if (!name) throw new UserError("Specify a stack name, or pass --all or --active.");
+    targets.push({ name, load: () => readStack(paths, name) });
+  }
+  let anyMissing = false;
+  for (const t of targets) {
+    const parsed = StackFileSchema.parse(await t.load());
+    const r = await validateStack(parsed);
+    if (r.ok) {
+      log(`${t.name}: OK (${r.checked} model id${r.checked === 1 ? "" : "s"} checked)`);
+    } else {
+      anyMissing = true;
+      err(`${t.name}: MISSING ${r.missing.length} model id${r.missing.length === 1 ? "" : "s"}:`);
+      for (const m of r.missing) err(`  ${m.path.padEnd(48)} ${m.modelId}`);
+    }
+  }
+  if (anyMissing) {
+    err("");
+    err(
+      "Run `opencode auth list` to confirm provider auth, or `opencode models` to see the full reachable list."
+    );
+    throw new ModelValidationError("(validation gate)", []);
+  }
+}
+async function cmdRm(paths, name, force) {
+  await removeStack(paths, name, { force });
+  log(`Removed stack "${name}"`);
+}
+async function cmdEdit(paths, name) {
+  const filePath = stackPath(paths, name);
+  if (!existsSync7(filePath)) {
+    throw new StackNotFoundError(name, await listStacks(paths));
+  }
+  const editor = process.env.EDITOR && process.env.EDITOR.length > 0 ? process.env.EDITOR : "vi";
+  const result = spawnSync(editor, [filePath], { stdio: "inherit" });
+  if (result.status !== 0) {
+    throw new UserError(`Editor exited with status ${result.status}.`);
+  }
+  try {
+    await readStack(paths, name);
+  } catch (e) {
+    err(`Warning: ${e.message}`);
+  }
+}
+async function cmdImport(paths, name, file, force) {
+  await importStack(paths, name, path8.resolve(file), { force });
+  log(`Imported "${file}" \u2192 stacks/${name}.json`);
+}
+async function cmdExport(paths, name, file) {
+  await exportStack(paths, name, path8.resolve(file));
+  log(`Exported stacks/${name}.json \u2192 "${file}"`);
+}
+function cmdPath(paths) {
+  for (const [k, v] of Object.entries(paths)) log(`${k.padEnd(22)} ${v}`);
+}
+async function main(argv) {
+  const cli = cac("agent-router");
+  const paths = await resolvePathsWithConfig();
+  cli.command("init", "create state dirs, capture current models, register the plugin").option("--force", "overwrite existing state").option("--no-edit-opencode-json", "do not modify opencode.json or tui.json").action(async (opts) => {
+    const passthrough = {};
+    if (opts.force !== void 0) passthrough.force = opts.force;
+    if (opts.editOpencodeJson === false) passthrough.noEditOpencodeJson = true;
+    await cmdInit(paths, passthrough);
+  });
+  cli.command("list", "list available stacks (* marks active)").action(() => cmdList(paths));
+  cli.command("status", "print active stack name").action(() => cmdStatus(paths));
+  cli.command("current", "print the agent \u2192 model mapping currently in frontmatter").action(() => cmdCurrent(paths));
+  cli.command("show <name>", "print a stack file as pretty JSON").action((n) => cmdShow(paths, n));
+  cli.command("use <name>", "apply a stack to the agent files (validates first)").alias("apply").option("--no-validate", "skip the pre-apply model validation").option("--force-invalid", "apply even if validation finds missing models").action(async (n, opts) => {
+    const passthrough = {};
+    if (opts.validate === false) passthrough.noValidate = true;
+    if (opts.forceInvalid !== void 0) passthrough.forceInvalid = opts.forceInvalid;
+    await cmdUse(paths, n, passthrough);
+  });
+  cli.command("capture <name>", "snapshot current frontmatter models into a new stack").option("--force", "overwrite an existing stack").action((n, opts) => cmdCapture(paths, n, !!opts.force));
+  cli.command("back", "undo the last N switches").option("-n <n>", "how many switches to undo", { default: 1 }).option("--no-validate", "skip the pre-apply model validation").option("--force-invalid", "apply even if validation finds missing models").action(async (opts) => {
+    const passthrough = {};
+    if (opts.validate === false) passthrough.noValidate = true;
+    if (opts.forceInvalid !== void 0) passthrough.forceInvalid = opts.forceInvalid;
+    await cmdBack(paths, opts.n ?? 1, passthrough);
+  });
+  cli.command("history", "list recent switches (newest first)").option("--limit <n>", "max entries to show", { default: 20 }).action((opts) => cmdHistory(paths, opts.limit ?? 20));
+  cli.command(
+    "validate [name]",
+    "verify model IDs in a stack are reachable via current opencode auth"
+  ).option("--all", "validate every stack").option("--active", "validate the models currently in agent frontmatter").action(
+    (name, opts) => cmdValidate(paths, name, opts)
+  );
+  cli.command("rm <name>", "delete a stack").option("--force", "delete even if active").action((n, opts) => cmdRm(paths, n, !!opts.force));
+  cli.command("edit <name>", "open a stack in $EDITOR (fallback `vi`)").action((n) => cmdEdit(paths, n));
+  cli.command("import <name> <file>", "copy <file> into stacks/<name>.json").option("--force", "overwrite an existing stack").action(
+    (n, f, opts) => cmdImport(paths, n, f, !!opts.force)
+  );
+  cli.command("export <name> <file>", "copy stacks/<name>.json to <file>").action((n, f) => cmdExport(paths, n, f));
+  cli.command("path", "print all paths used by agent-router").action(() => cmdPath(paths));
+  cli.command("completion", "print instructions for installing shell autocomplete").action(() => {
+    log("To install autocomplete for agent-router, run one of the following:\n");
+    log(
+      "ZSH:\n  agent-router completion-script zsh > ~/.agent-router-completion.zsh\n  echo 'source ~/.agent-router-completion.zsh' >> ~/.zshrc\n"
+    );
+    log(
+      "BASH:\n  agent-router completion-script bash > ~/.agent-router-completion.bash\n  echo 'source ~/.agent-router-completion.bash' >> ~/.bashrc\n"
+    );
+    log(
+      "FISH:\n  agent-router completion-script fish > ~/.config/fish/completions/agent-router.fish\n"
+    );
+  });
+  cli.command("completion-script <shell>", "Generate the completion script for your shell").action((shell) => {
+    if (shell === "zsh") {
+      log(
+        `
+#compdef agent-router
+
+_agent_router() {
+  local -a commands
+  commands=(
+    'init:create state dirs, capture current models, register the plugin'
+    'list:list available stacks'
+    'status:print active stack name'
+    'current:print the current agent \u2192 model mapping'
+    'show:print a stack file as pretty JSON'
+    'use:apply a stack to the agent files'
+    'capture:snapshot current models into a new stack'
+    'back:undo the last N switches'
+    'history:list recent switches'
+    'validate:verify model IDs'
+    'rm:delete a stack'
+    'edit:open a stack in $EDITOR'
+    'import:copy file into stacks'
+    'export:copy stack to file'
+    'path:print all paths'
+  )
+
+  if (( CURRENT == 2 )); then
+    _describe -t commands 'commands' commands
+  else
+    local cmd=\${words[2]}
+    case $cmd in
+      show|use|validate|rm|edit|export)
+        local -a stacks
+        stacks=($(agent-router completion-resolve))
+        _describe -t stacks 'stacks' stacks
+        ;;
+    esac
+  fi
+}
+
+compdef _agent_router agent-router
+        `.trim()
+      );
+    } else if (shell === "bash") {
+      log(
+        `
+_agent_router() {
+  local cur prev commands stacks
+  COMPREPLY=()
+  cur="\${COMP_WORDS[COMP_CWORD]}"
+  prev="\${COMP_WORDS[COMP_CWORD-1]}"
+  commands="init list status current show use capture back history validate rm edit import export path completion"
+
+  if [[ \${COMP_CWORD} == 1 ]]; then
+    COMPREPLY=( $(compgen -W "\${commands}" -- \${cur}) )
+    return 0
+  fi
+
+  case "\${prev}" in
+    show|use|validate|rm|edit|export)
+      stacks=$(agent-router completion-resolve 2>/dev/null)
+      COMPREPLY=( $(compgen -W "\${stacks}" -- \${cur}) )
+      ;;
+  esac
+  return 0
+}
+
+complete -F _agent_router agent-router
+        `.trim()
+      );
+    } else if (shell === "fish") {
+      log(
+        `
+function _agent_router_needs_command
+  set cmd (commandline -opc)
+  if test (count $cmd) -eq 1
+    return 0
+  end
+  return 1
+end
+
+function _agent_router_using_command
+  set cmd (commandline -opc)
+  if test (count $cmd) -gt 1
+    if test $cmd[2] = $argv[1]
+      return 0
+    end
+  end
+  return 1
+end
+
+complete -f -c agent-router -n '_agent_router_needs_command' -a init -d 'create state dirs, capture current models, register the plugin'
+complete -f -c agent-router -n '_agent_router_needs_command' -a list -d 'list available stacks'
+complete -f -c agent-router -n '_agent_router_needs_command' -a status -d 'print active stack name'
+complete -f -c agent-router -n '_agent_router_needs_command' -a current -d 'print the current agent \u2192 model mapping'
+complete -f -c agent-router -n '_agent_router_needs_command' -a show -d 'print a stack file as pretty JSON'
+complete -f -c agent-router -n '_agent_router_needs_command' -a use -d 'apply a stack to the agent files'
+complete -f -c agent-router -n '_agent_router_needs_command' -a capture -d 'snapshot current models into a new stack'
+complete -f -c agent-router -n '_agent_router_needs_command' -a back -d 'undo the last N switches'
+complete -f -c agent-router -n '_agent_router_needs_command' -a history -d 'list recent switches'
+complete -f -c agent-router -n '_agent_router_needs_command' -a validate -d 'verify model IDs'
+complete -f -c agent-router -n '_agent_router_needs_command' -a rm -d 'delete a stack'
+complete -f -c agent-router -n '_agent_router_needs_command' -a edit -d 'open a stack in $EDITOR'
+complete -f -c agent-router -n '_agent_router_needs_command' -a import -d 'copy file into stacks'
+complete -f -c agent-router -n '_agent_router_needs_command' -a export -d 'copy stack to file'
+complete -f -c agent-router -n '_agent_router_needs_command' -a path -d 'print all paths'
+
+complete -f -c agent-router -n '_agent_router_using_command show' -a '(agent-router completion-resolve)'
+complete -f -c agent-router -n '_agent_router_using_command use' -a '(agent-router completion-resolve)'
+complete -f -c agent-router -n '_agent_router_using_command validate' -a '(agent-router completion-resolve)'
+complete -f -c agent-router -n '_agent_router_using_command rm' -a '(agent-router completion-resolve)'
+complete -f -c agent-router -n '_agent_router_using_command edit' -a '(agent-router completion-resolve)'
+complete -f -c agent-router -n '_agent_router_using_command export' -a '(agent-router completion-resolve)'
+        `.trim()
+      );
+    } else {
+      err("Unsupported shell. Supported: bash, zsh, fish");
+      process.exit(1);
+    }
+  });
+  cli.command("completion-resolve", "Internal command used by shell autocomplete").action(async () => {
+    try {
+      const stacks = await listStacks(paths);
+      log(stacks.join("\n"));
+    } catch {
+    }
+  });
+  cli.help();
+  cli.version(VERSION);
+  try {
+    cli.parse([process.argv[0] ?? "node", process.argv[1] ?? "agent-router", ...argv], {
+      run: false
+    });
+    if (cli.matchedCommand) {
+      await cli.runMatchedCommand();
+    } else if (argv.length > 0 && !argv.includes("--help") && !argv.includes("-h") && !argv.includes("--version") && !argv.includes("-v")) {
+      cli.outputHelp();
+      return 1;
+    }
+    return 0;
+  } catch (e) {
+    if (e instanceof RouterError) {
+      err(`error: ${e.message}`);
+      if (e instanceof ModelValidationError && e.missing.length > 0) {
+        err("");
+        for (const m of e.missing) err(`  ${m.path.padEnd(48)} ${m.modelId}`);
+      }
+      const ctor = e.constructor;
+      return ctor.exitCode ?? 1;
+    }
+    err(`unexpected error: ${e.message}`);
+    return 1;
+  }
+}
+function isInvokedAsScript() {
+  if (!import.meta.url.startsWith("file:")) return false;
+  const argv1 = process.argv[1];
+  if (!argv1) return false;
+  try {
+    return realpathSync(fileURLToPath(import.meta.url)) === realpathSync(path8.resolve(argv1));
+  } catch {
+    return false;
+  }
+}
+if (isInvokedAsScript()) {
+  main(process.argv.slice(2)).then(
+    (code) => process.exit(code),
+    (e) => {
+      err(e);
+      process.exit(1);
+    }
+  );
+}
+export {
+  main
+};
+//# sourceMappingURL=cli.js.map