opencode-athena 0.0.1

package/dist/cli/index.js

@@ -0,0 +1,2185 @@
+#!/usr/bin/env node
+import { join, dirname } from 'path';
+import { fileURLToPath } from 'url';
+import { confirm, select, checkbox } from '@inquirer/prompts';
+import chalk3 from 'chalk';
+import { Command } from 'commander';
+import { homedir } from 'os';
+import ora3 from 'ora';
+import { exec } from 'child_process';
+import { existsSync, readFileSync } from 'fs';
+import { mkdir, writeFile, readdir, copyFile, rm } from 'fs/promises';
+import { promisify } from 'util';
+import 'yaml';
+import { z } from 'zod';
+
+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 });
+};
+var init_esm_shims = __esm({
+  "node_modules/tsup/assets/esm_shims.js"() {
+  }
+});
+
+// src/cli/questions/models.ts
+var models_exports = {};
+__export(models_exports, {
+  gatherModels: () => gatherModels,
+  getAvailableModels: () => getAvailableModels,
+  getModelList: () => getModelList,
+  validatePresetModels: () => validatePresetModels
+});
+function getAvailableModels(subscriptions) {
+  return AVAILABLE_MODELS.filter((model) => {
+    if (model.provider === "anthropic" && !subscriptions.hasClaude) return false;
+    if (model.provider === "openai" && !subscriptions.hasOpenAI) return false;
+    if (model.provider === "google" && !subscriptions.hasGoogle) return false;
+    return true;
+  });
+}
+function isModelAvailable(modelId, availableModels) {
+  return availableModels.some((m) => m.id === modelId);
+}
+function getValidModelOrFallback(presetModel, role, subscriptions, availableModels) {
+  if (presetModel && isModelAvailable(presetModel, availableModels)) {
+    return presetModel;
+  }
+  return getSuggestedModel(role, subscriptions, availableModels);
+}
+function createModelChoices(models) {
+  return models.map((model) => ({
+    name: `${model.name} - ${model.description}`,
+    value: model.id
+  }));
+}
+function getSuggestedModel(role, _subscriptions, availableModels) {
+  const suggestions = {
+    sisyphus: [
+      "anthropic/claude-opus-4-5-thinking",
+      "anthropic/claude-sonnet-4-5-thinking",
+      "openai/gpt-5.1-high",
+      "google/gemini-2.5-pro"
+    ],
+    oracle: [
+      "openai/gpt-5.1-high",
+      "anthropic/claude-opus-4-5-thinking",
+      "anthropic/claude-sonnet-4-5-thinking",
+      "google/gemini-2.5-pro"
+    ],
+    librarian: ["anthropic/claude-sonnet-4-5", "openai/gpt-4o", "google/gemini-2.5-flash"],
+    frontend: ["anthropic/claude-sonnet-4-5", "google/gemini-2.5-pro", "openai/gpt-4o"],
+    documentWriter: ["google/gemini-2.5-pro", "anthropic/claude-sonnet-4-5", "openai/gpt-4o"],
+    multimodalLooker: ["google/gemini-2.5-flash", "openai/gpt-4o", "anthropic/claude-sonnet-4-5"]
+  };
+  const roleDefaults = suggestions[role] || [];
+  const availableIds = availableModels.map((m) => m.id);
+  for (const modelId of roleDefaults) {
+    if (availableIds.includes(modelId)) {
+      return modelId;
+    }
+  }
+  return availableModels[0]?.id;
+}
+async function gatherModels(subscriptions, defaults) {
+  const availableModels = getAvailableModels(subscriptions);
+  if (availableModels.length === 0) {
+    throw new Error(
+      "No models available. Please enable at least one provider (Claude, OpenAI, or Google)."
+    );
+  }
+  const choices = createModelChoices(availableModels);
+  const sisyphusDefault = getValidModelOrFallback(
+    defaults?.sisyphus,
+    "sisyphus",
+    subscriptions,
+    availableModels
+  );
+  const oracleDefault = getValidModelOrFallback(
+    defaults?.oracle,
+    "oracle",
+    subscriptions,
+    availableModels
+  );
+  const librarianDefault = getValidModelOrFallback(
+    defaults?.librarian,
+    "librarian",
+    subscriptions,
+    availableModels
+  );
+  const sisyphus = await select({
+    message: "Model for Sisyphus (main orchestrator - implements stories)?",
+    choices,
+    default: sisyphusDefault
+  });
+  const oracle = await select({
+    message: "Model for Oracle (debugging and complex reasoning)?",
+    choices,
+    default: oracleDefault
+  });
+  const librarian = await select({
+    message: "Model for Librarian (research and documentation lookup)?",
+    choices,
+    default: librarianDefault
+  });
+  const frontend = getValidModelOrFallback(
+    defaults?.frontend,
+    "frontend",
+    subscriptions,
+    availableModels
+  );
+  const documentWriter = getValidModelOrFallback(
+    defaults?.documentWriter,
+    "documentWriter",
+    subscriptions,
+    availableModels
+  );
+  const multimodalLooker = getValidModelOrFallback(
+    defaults?.multimodalLooker,
+    "multimodalLooker",
+    subscriptions,
+    availableModels
+  );
+  return {
+    sisyphus,
+    oracle,
+    librarian,
+    frontend,
+    documentWriter,
+    multimodalLooker
+  };
+}
+function getModelList(subscriptions) {
+  return getAvailableModels(subscriptions);
+}
+function validatePresetModels(presetModels, subscriptions) {
+  const warnings = [];
+  const availableModels = getAvailableModels(subscriptions);
+  const checkModel = (model, role) => {
+    if (model && !isModelAvailable(model, availableModels)) {
+      warnings.push(
+        `Preset model for ${role} (${model}) is not available with your subscriptions. A fallback will be used.`
+      );
+    }
+  };
+  checkModel(presetModels.sisyphus, "Sisyphus");
+  checkModel(presetModels.oracle, "Oracle");
+  checkModel(presetModels.librarian, "Librarian");
+  checkModel(presetModels.frontend, "Frontend");
+  checkModel(presetModels.documentWriter, "Document Writer");
+  checkModel(presetModels.multimodalLooker, "Multimodal Looker");
+  return warnings;
+}
+var AVAILABLE_MODELS;
+var init_models = __esm({
+  "src/cli/questions/models.ts"() {
+    init_esm_shims();
+    AVAILABLE_MODELS = [
+      // Anthropic models
+      {
+        id: "anthropic/claude-sonnet-4-5",
+        name: "Claude Sonnet 4.5",
+        provider: "anthropic",
+        description: "Latest Sonnet - balanced performance and speed"
+      },
+      {
+        id: "anthropic/claude-opus-4-5",
+        name: "Claude Opus 4.5",
+        provider: "anthropic",
+        description: "Most capable Claude model"
+      },
+      {
+        id: "anthropic/claude-sonnet-4-5-thinking",
+        name: "Claude Sonnet 4.5 (Thinking)",
+        provider: "anthropic",
+        description: "Sonnet with extended thinking enabled"
+      },
+      {
+        id: "anthropic/claude-opus-4-5-thinking",
+        name: "Claude Opus 4.5 (Thinking)",
+        provider: "anthropic",
+        description: "Opus with extended thinking enabled"
+      },
+      // OpenAI models
+      {
+        id: "openai/gpt-4o",
+        name: "GPT-4o",
+        provider: "openai",
+        description: "Fast multimodal model"
+      },
+      {
+        id: "openai/gpt-5.1",
+        name: "GPT-5.1",
+        provider: "openai",
+        description: "Latest GPT model"
+      },
+      {
+        id: "openai/gpt-5.1-high",
+        name: "GPT-5.1 High",
+        provider: "openai",
+        description: "GPT-5.1 with high reasoning effort"
+      },
+      // Google models
+      {
+        id: "google/gemini-2.5-pro",
+        name: "Gemini 2.5 Pro",
+        provider: "google",
+        description: "Latest Gemini Pro model"
+      },
+      {
+        id: "google/gemini-2.5-flash",
+        name: "Gemini 2.5 Flash",
+        provider: "google",
+        description: "Fast Gemini model"
+      },
+      {
+        id: "google/gemini-2.0-flash",
+        name: "Gemini 2.0 Flash",
+        provider: "google",
+        description: "Previous generation fast model"
+      }
+    ];
+  }
+});
+
+// src/cli/index.ts
+init_esm_shims();
+
+// src/shared/constants.ts
+init_esm_shims();
+var VERSION = "0.0.1";
+var DISPLAY_NAME = "OpenCode Athena";
+var TAGLINE = "Strategic wisdom meets practical execution";
+var CONFIG_PATHS = {
+  /** Global OpenCode config directory */
+  globalConfigDir: join(homedir(), ".config", "opencode"),
+  /** Global Athena config file */
+  globalAthenaConfig: join(homedir(), ".config", "opencode", "athena.json"),
+  /** Global OpenCode config file */
+  globalOpencodeConfig: join(homedir(), ".config", "opencode", "opencode.json"),
+  /** Global oh-my-opencode config file */
+  globalOmoConfig: join(homedir(), ".config", "opencode", "oh-my-opencode.json"),
+  /** Commands directory */
+  commandsDir: join(homedir(), ".config", "opencode", "command"),
+  /** Plugin directory */
+  pluginDir: join(homedir(), ".config", "opencode", "plugin"),
+  /** Athena state file (for story tracking) */
+  stateFile: join(homedir(), ".config", "opencode", "athena-state.json")
+};
+var DEFAULTS = {
+  /** Maximum parallel stories */
+  parallelStoryLimit: 3};
+var MIN_VERSIONS = {
+  node: "20.0.0",
+  opencode: "1.0.132"
+};
+
+// src/cli/commands/doctor.ts
+init_esm_shims();
+
+// src/cli/utils/file-manager.ts
+init_esm_shims();
+var execAsync = promisify(exec);
+function getPackageRoot() {
+  const currentFileDir = dirname(fileURLToPath(import.meta.url));
+  const bundledRoot = join(currentFileDir, "..", "..");
+  if (existsSync(join(bundledRoot, "commands"))) {
+    return bundledRoot;
+  }
+  const devRoot = join(currentFileDir, "..", "..", "..");
+  if (existsSync(join(devRoot, "commands"))) {
+    return devRoot;
+  }
+  return bundledRoot;
+}
+var FileManager = class {
+  configDir;
+  constructor(configDir) {
+    this.configDir = configDir || CONFIG_PATHS.globalConfigDir;
+  }
+  /**
+   * Get the configuration directory path
+   */
+  getConfigDir() {
+    return this.configDir;
+  }
+  /**
+   * Ensure a directory exists
+   */
+  async ensureDir(dir) {
+    if (!existsSync(dir)) {
+      await mkdir(dir, { recursive: true });
+    }
+  }
+  /**
+   * Write multiple files atomically
+   */
+  async writeFiles(files) {
+    for (const file of files) {
+      const dir = dirname(file.path);
+      await this.ensureDir(dir);
+      await writeFile(file.path, file.content, "utf-8");
+    }
+  }
+  /**
+   * Read a JSON configuration file
+   */
+  readJsonFile(path2) {
+    if (!existsSync(path2)) {
+      return null;
+    }
+    try {
+      const content = readFileSync(path2, "utf-8");
+      return JSON.parse(content);
+    } catch {
+      return null;
+    }
+  }
+  /**
+   * Write a JSON configuration file
+   */
+  async writeJsonFile(path2, data) {
+    const dir = dirname(path2);
+    await this.ensureDir(dir);
+    await writeFile(path2, JSON.stringify(data, null, 2), "utf-8");
+  }
+  /**
+   * Check if a file exists
+   */
+  exists(path2) {
+    return existsSync(path2);
+  }
+  /**
+   * Install npm dependencies in the config directory
+   */
+  async installDependencies(packages) {
+    if (packages.length === 0) return;
+    await this.ensureDir(this.configDir);
+    const packageJsonPath = join(this.configDir, "package.json");
+    if (!existsSync(packageJsonPath)) {
+      await writeFile(
+        packageJsonPath,
+        JSON.stringify(
+          {
+            name: "opencode-config",
+            private: true,
+            type: "module"
+          },
+          null,
+          2
+        )
+      );
+    }
+    const packageList = packages.join(" ");
+    await execAsync(`npm install ${packageList}`, {
+      cwd: this.configDir,
+      timeout: 12e4
+    });
+  }
+  /**
+   * Uninstall npm dependencies from the config directory
+   */
+  async uninstallDependencies(packages) {
+    if (packages.length === 0) return;
+    const packageList = packages.join(" ");
+    try {
+      await execAsync(`npm uninstall ${packageList}`, {
+        cwd: this.configDir,
+        timeout: 6e4
+      });
+    } catch {
+    }
+  }
+  /**
+   * Copy bridge commands from package to config directory
+   */
+  async copyCommands() {
+    const commandsDir = CONFIG_PATHS.commandsDir;
+    await this.ensureDir(commandsDir);
+    const packageRoot = getPackageRoot();
+    const sourceCommandsDir = join(packageRoot, "commands");
+    const copiedFiles = [];
+    if (existsSync(sourceCommandsDir)) {
+      const files = await readdir(sourceCommandsDir);
+      for (const file of files) {
+        if (file.endsWith(".md")) {
+          const sourcePath = join(sourceCommandsDir, file);
+          const destPath = join(commandsDir, file);
+          await copyFile(sourcePath, destPath);
+          copiedFiles.push(file);
+        }
+      }
+    }
+    return copiedFiles;
+  }
+  /**
+   * Remove bridge commands from config directory
+   */
+  async removeCommands() {
+    const commandsDir = CONFIG_PATHS.commandsDir;
+    const removedFiles = [];
+    if (!existsSync(commandsDir)) {
+      return removedFiles;
+    }
+    const files = await readdir(commandsDir);
+    for (const file of files) {
+      if (file.startsWith("athena-") && file.endsWith(".md")) {
+        const filePath = join(commandsDir, file);
+        await rm(filePath);
+        removedFiles.push(file);
+      }
+    }
+    return removedFiles;
+  }
+  /**
+   * Remove Athena configuration files
+   */
+  async removeConfigFiles() {
+    const removedFiles = [];
+    const filesToRemove = [CONFIG_PATHS.globalAthenaConfig, CONFIG_PATHS.stateFile];
+    for (const file of filesToRemove) {
+      if (existsSync(file)) {
+        await rm(file);
+        removedFiles.push(file);
+      }
+    }
+    return removedFiles;
+  }
+  /**
+   * Remove Athena from opencode.json plugin list
+   */
+  async removeFromOpencodeConfig() {
+    const opencodeConfig = this.readJsonFile(CONFIG_PATHS.globalOpencodeConfig);
+    if (!opencodeConfig || !opencodeConfig.plugin) {
+      return false;
+    }
+    const athenaPlugins = [
+      "opencode-athena",
+      "oh-my-opencode",
+      "opencode-antigravity-auth",
+      "opencode-openai-codex-auth"
+    ];
+    const originalLength = opencodeConfig.plugin.length;
+    opencodeConfig.plugin = opencodeConfig.plugin.filter(
+      (p) => !athenaPlugins.some((ap) => p.includes(ap))
+    );
+    if (opencodeConfig.plugin.length !== originalLength) {
+      await this.writeJsonFile(CONFIG_PATHS.globalOpencodeConfig, opencodeConfig);
+      return true;
+    }
+    return false;
+  }
+  /**
+   * Backup a file before modifying
+   */
+  async backupFile(path2) {
+    if (!existsSync(path2)) {
+      return null;
+    }
+    const backupPath = `${path2}.backup`;
+    await copyFile(path2, backupPath);
+    return backupPath;
+  }
+  /**
+   * Restore a file from backup
+   */
+  async restoreFromBackup(backupPath) {
+    const originalPath = backupPath.replace(/\.backup$/, "");
+    if (existsSync(backupPath)) {
+      await copyFile(backupPath, originalPath);
+      await rm(backupPath);
+    }
+  }
+};
+
+// src/cli/utils/logger.ts
+init_esm_shims();
+var logger = {
+  /**
+   * Log an informational message
+   */
+  info: (message) => {
+    console.log(chalk3.blue("i"), message);
+  },
+  /**
+   * Log a success message
+   */
+  success: (message) => {
+    console.log(chalk3.green("\u2713"), message);
+  },
+  /**
+   * Log a warning message
+   */
+  warn: (message) => {
+    console.log(chalk3.yellow("!"), message);
+  },
+  /**
+   * Log an error message
+   */
+  error: (message) => {
+    console.log(chalk3.red("\u2716"), message);
+  },
+  /**
+   * Log a debug message (only when DEBUG env var is set)
+   */
+  debug: (message) => {
+    if (process.env.DEBUG) {
+      console.log(chalk3.gray("[debug]"), message);
+    }
+  },
+  /**
+   * Log a step in a process
+   */
+  step: (step, total, message) => {
+    console.log(chalk3.cyan(`[${step}/${total}]`), message);
+  },
+  /**
+   * Log a blank line
+   */
+  blank: () => {
+    console.log();
+  },
+  /**
+   * Log a section header
+   */
+  section: (title) => {
+    console.log();
+    console.log(chalk3.bold(title));
+    console.log();
+  },
+  /**
+   * Log a key-value pair
+   */
+  keyValue: (key, value, indent = 0) => {
+    const padding = "  ".repeat(indent);
+    console.log(`${padding}${chalk3.gray(`${key}:`)} ${value}`);
+  },
+  /**
+   * Log a list item
+   */
+  listItem: (item, indent = 0) => {
+    const padding = "  ".repeat(indent);
+    console.log(`${padding}${chalk3.gray("-")} ${item}`);
+  },
+  /**
+   * Display the Athena banner
+   */
+  banner: () => {
+    console.log(
+      chalk3.cyan(`
+\u2554\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2557
+\u2551                     OPENCODE ATHENA                           \u2551
+\u2551          Strategic Wisdom Meets Practical Execution           \u2551
+\u2560\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2563
+\u2551  Unifying oh-my-opencode + BMAD METHOD for OpenCode           \u2551
+\u255A\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u255D
+`)
+    );
+  },
+  /**
+   * Display a success banner
+   */
+  successBanner: (message) => {
+    const line = "\u2550".repeat(message.length + 4);
+    console.log(
+      chalk3.green(`
+\u2554${line}\u2557
+\u2551  ${message}  \u2551
+\u255A${line}\u255D
+`)
+    );
+  }
+};
+
+// src/cli/utils/prerequisites.ts
+init_esm_shims();
+var execAsync2 = promisify(exec);
+function parseVersion(version) {
+  const match = version.match(/^v?(\d+)\.(\d+)\.(\d+)/);
+  if (!match) return null;
+  return {
+    major: Number.parseInt(match[1], 10),
+    minor: Number.parseInt(match[2], 10),
+    patch: Number.parseInt(match[3], 10)
+  };
+}
+function compareVersions(a, b) {
+  const parsedA = parseVersion(a);
+  const parsedB = parseVersion(b);
+  if (!parsedA || !parsedB) return 0;
+  if (parsedA.major !== parsedB.major) {
+    return parsedA.major < parsedB.major ? -1 : 1;
+  }
+  if (parsedA.minor !== parsedB.minor) {
+    return parsedA.minor < parsedB.minor ? -1 : 1;
+  }
+  if (parsedA.patch !== parsedB.patch) {
+    return parsedA.patch < parsedB.patch ? -1 : 1;
+  }
+  return 0;
+}
+async function checkNode() {
+  try {
+    const { stdout } = await execAsync2("node --version");
+    const version = stdout.trim().replace(/^v/, "");
+    const compatible = compareVersions(version, MIN_VERSIONS.node) >= 0;
+    return { installed: true, version, compatible };
+  } catch {
+    return { installed: false, compatible: false };
+  }
+}
+async function checkOpenCode() {
+  try {
+    const { stdout } = await execAsync2("opencode --version");
+    const version = stdout.trim();
+    const compatible = compareVersions(version, MIN_VERSIONS.opencode) >= 0;
+    return { installed: true, version, compatible };
+  } catch {
+    return { installed: false, compatible: false };
+  }
+}
+async function checkAthena() {
+  if (!existsSync(CONFIG_PATHS.globalAthenaConfig)) {
+    return { installed: false };
+  }
+  try {
+    const content = readFileSync(CONFIG_PATHS.globalAthenaConfig, "utf-8");
+    const config = JSON.parse(content);
+    return {
+      installed: true,
+      version: config.version
+    };
+  } catch {
+    return { installed: true };
+  }
+}
+async function checkPrerequisites() {
+  const [node, opencode, athena] = await Promise.all([checkNode(), checkOpenCode(), checkAthena()]);
+  return { node, opencode, athena };
+}
+async function checkOhMyOpenCode() {
+  try {
+    const { stdout } = await execAsync2("npm list oh-my-opencode --json", {
+      cwd: CONFIG_PATHS.globalConfigDir
+    });
+    const data = JSON.parse(stdout);
+    const version = data.dependencies?.["oh-my-opencode"]?.version;
+    return { installed: !!version, version };
+  } catch {
+    return { installed: false };
+  }
+}
+async function getInstalledPlugins() {
+  try {
+    const { stdout } = await execAsync2("npm list --depth=0 --json", {
+      cwd: CONFIG_PATHS.globalConfigDir
+    });
+    const data = JSON.parse(stdout);
+    const deps = data.dependencies || {};
+    const result = {};
+    for (const [name, info2] of Object.entries(deps)) {
+      result[name] = info2.version || "unknown";
+    }
+    return result;
+  } catch {
+    return {};
+  }
+}
+function validateJsonFile(path2) {
+  if (!existsSync(path2)) {
+    return { valid: false, error: "File does not exist" };
+  }
+  try {
+    const content = readFileSync(path2, "utf-8");
+    JSON.parse(content);
+    return { valid: true };
+  } catch (err) {
+    return {
+      valid: false,
+      error: err instanceof Error ? err.message : "Invalid JSON"
+    };
+  }
+}
+
+// src/cli/utils/validators.ts
+init_esm_shims();
+
+// src/shared/schemas.ts
+init_esm_shims();
+var SubscriptionSchema = z.object({
+  claude: z.object({
+    enabled: z.boolean(),
+    tier: z.enum(["max5x", "max20x", "pro", "none"])
+  }),
+  openai: z.object({
+    enabled: z.boolean()
+  }),
+  google: z.object({
+    enabled: z.boolean(),
+    authMethod: z.enum(["antigravity", "personal", "api", "none"])
+  })
+});
+var BmadConfigSchema = z.object({
+  defaultTrack: z.enum(["quick-flow", "bmad-method", "enterprise"]),
+  autoStatusUpdate: z.boolean(),
+  parallelStoryLimit: z.number().int().min(0).max(10)
+});
+var FeaturesSchema = z.object({
+  bmadBridge: z.boolean(),
+  autoStatus: z.boolean(),
+  parallelExecution: z.boolean(),
+  notifications: z.boolean(),
+  contextMonitor: z.boolean(),
+  commentChecker: z.boolean(),
+  lspTools: z.boolean()
+});
+var McpsSchema = z.object({
+  context7: z.boolean(),
+  exa: z.boolean(),
+  grepApp: z.boolean()
+});
+var ModelsSchema = z.object({
+  sisyphus: z.string().describe("Model for main orchestrator agent"),
+  oracle: z.string().describe("Model for debugging/reasoning agent"),
+  librarian: z.string().describe("Model for research/documentation agent"),
+  frontend: z.string().optional().describe("Model for UI/UX agent"),
+  documentWriter: z.string().optional().describe("Model for documentation generation agent"),
+  multimodalLooker: z.string().optional().describe("Model for image analysis agent")
+});
+var AthenaConfigSchema = z.object({
+  $schema: z.string().optional(),
+  version: z.string(),
+  subscriptions: SubscriptionSchema,
+  models: ModelsSchema,
+  bmad: BmadConfigSchema,
+  features: FeaturesSchema,
+  mcps: McpsSchema
+});
+z.object({
+  storyId: z.string().optional().describe(
+    "Specific story ID (e.g., '2.3'). If omitted, loads the next pending story from sprint-status.yaml."
+  )
+});
+z.object({
+  storyId: z.string().describe("The story ID (e.g., '2.3')"),
+  status: z.enum(["in_progress", "completed", "blocked", "needs_review"]).describe("The new status for the story"),
+  notes: z.string().optional().describe("Notes about the status change (required for 'blocked' status)"),
+  completionSummary: z.string().optional().describe("Summary of what was implemented (required for 'completed' status)")
+});
+z.object({
+  includeArchitecture: z.boolean().optional().default(true),
+  includePrd: z.boolean().optional().default(false),
+  includeSprintStatus: z.boolean().optional().default(true)
+});
+z.object({
+  storyIds: z.array(z.string()).describe("Array of story IDs to implement in parallel"),
+  maxConcurrent: z.number().int().min(1).max(5).optional().default(3)
+});
+z.object({
+  action: z.enum(["get", "set", "reset"]).describe("Configuration action to perform"),
+  key: z.string().optional().describe("Configuration key (dot notation, e.g., 'bmad.autoStatusUpdate')"),
+  value: z.unknown().optional().describe("Value to set (for 'set' action)")
+});
+var StoryStatusEnum = z.enum([
+  "pending",
+  "in_progress",
+  "completed",
+  "blocked",
+  "needs_review"
+]);
+z.enum([
+  "pending",
+  "in_progress",
+  "completed",
+  "blocked",
+  "needs_review",
+  "loading"
+]);
+z.object({
+  sprint_number: z.number().int().optional(),
+  current_epic: z.string().optional(),
+  current_story: z.string().nullable().optional(),
+  completed_stories: z.array(z.string()).default([]),
+  pending_stories: z.array(z.string()).default([]),
+  in_progress_stories: z.array(z.string()).default([]),
+  blocked_stories: z.array(z.string()).default([]),
+  stories_needing_review: z.array(z.string()).optional(),
+  story_updates: z.record(
+    z.object({
+      status: StoryStatusEnum,
+      updated_at: z.string(),
+      notes: z.string().optional(),
+      completion_summary: z.string().optional()
+    })
+  ).optional(),
+  last_modified: z.string().optional()
+});
+
+// src/cli/utils/validators.ts
+function validateAthenaConfig(config) {
+  const result = { valid: true, errors: [], warnings: [] };
+  const parseResult = AthenaConfigSchema.safeParse(config);
+  if (!parseResult.success) {
+    result.valid = false;
+    for (const issue of parseResult.error.issues) {
+      result.errors.push(`${issue.path.join(".")}: ${issue.message}`);
+    }
+  }
+  return result;
+}
+function validateJsonConfig(path2) {
+  const result = { valid: true, errors: [], warnings: [] };
+  if (!existsSync(path2)) {
+    result.valid = false;
+    result.errors.push("File does not exist");
+    return result;
+  }
+  try {
+    const content = readFileSync(path2, "utf-8");
+    JSON.parse(content);
+  } catch (err) {
+    result.valid = false;
+    result.errors.push(err instanceof Error ? err.message : "Invalid JSON");
+  }
+  return result;
+}
+
+// src/cli/commands/doctor.ts
+async function doctor(options) {
+  logger.banner();
+  logger.section("Running Diagnostics");
+  const results = [];
+  const fileManager = new FileManager();
+  const prereqs = await checkPrerequisites();
+  results.push({
+    name: "Node.js",
+    status: prereqs.node.installed ? prereqs.node.compatible ? "pass" : "warn" : "fail",
+    message: prereqs.node.installed ? prereqs.node.compatible ? `Version ${prereqs.node.version} is compatible` : `Version ${prereqs.node.version} detected, 20+ recommended` : "Not installed"
+  });
+  results.push({
+    name: "OpenCode",
+    status: prereqs.opencode.installed ? prereqs.opencode.compatible ? "pass" : "warn" : "fail",
+    message: prereqs.opencode.installed ? prereqs.opencode.compatible ? `Version ${prereqs.opencode.version} is compatible` : `Version ${prereqs.opencode.version} detected, 1.0.132+ recommended` : "Not installed"
+  });
+  const athenaConfigValid = validateJsonFile(CONFIG_PATHS.globalAthenaConfig);
+  if (athenaConfigValid.valid) {
+    const config = fileManager.readJsonFile(CONFIG_PATHS.globalAthenaConfig);
+    const schemaValidation = validateAthenaConfig(config);
+    results.push({
+      name: "Athena Config",
+      status: schemaValidation.valid ? "pass" : "warn",
+      message: schemaValidation.valid ? "Valid configuration" : `Schema issues: ${schemaValidation.errors.join(", ")}`
+    });
+  } else {
+    results.push({
+      name: "Athena Config",
+      status: "fail",
+      message: athenaConfigValid.error || "Not found",
+      fix: async () => {
+        logger.info("Run 'opencode-athena install' to create configuration");
+      }
+    });
+  }
+  const opencodeConfigValid = validateJsonConfig(CONFIG_PATHS.globalOpencodeConfig);
+  results.push({
+    name: "OpenCode Config",
+    status: opencodeConfigValid.valid ? "pass" : "fail",
+    message: opencodeConfigValid.valid ? "Valid JSON" : opencodeConfigValid.errors[0] || "Invalid"
+  });
+  const omoConfigValid = validateJsonConfig(CONFIG_PATHS.globalOmoConfig);
+  results.push({
+    name: "oh-my-opencode Config",
+    status: omoConfigValid.valid ? "pass" : "warn",
+    message: omoConfigValid.valid ? "Valid JSON" : omoConfigValid.errors[0] || "Not found"
+  });
+  const omoInstalled = await checkOhMyOpenCode();
+  results.push({
+    name: "oh-my-opencode Plugin",
+    status: omoInstalled.installed ? "pass" : "fail",
+    message: omoInstalled.installed ? `Version ${omoInstalled.version}` : "Not installed",
+    fix: async () => {
+      const spinner = ora3("Installing oh-my-opencode...").start();
+      try {
+        await fileManager.installDependencies(["oh-my-opencode"]);
+        spinner.succeed("oh-my-opencode installed");
+      } catch (err) {
+        spinner.fail("Failed to install oh-my-opencode");
+        throw err;
+      }
+    }
+  });
+  const commandsDirExists = fileManager.exists(CONFIG_PATHS.commandsDir);
+  results.push({
+    name: "Commands Directory",
+    status: commandsDirExists ? "pass" : "warn",
+    message: commandsDirExists ? "Exists" : "Not found",
+    fix: async () => {
+      const spinner = ora3("Creating commands directory...").start();
+      try {
+        await fileManager.ensureDir(CONFIG_PATHS.commandsDir);
+        await fileManager.copyCommands();
+        spinner.succeed("Commands directory created and populated");
+      } catch (err) {
+        spinner.fail("Failed to create commands directory");
+        throw err;
+      }
+    }
+  });
+  logger.section("Diagnostic Results");
+  let hasFailures = false;
+  let hasWarnings = false;
+  const fixableIssues = [];
+  for (const result of results) {
+    let icon;
+    let color;
+    switch (result.status) {
+      case "pass":
+        icon = "\u2713";
+        color = chalk3.green;
+        break;
+      case "warn":
+        icon = "!";
+        color = chalk3.yellow;
+        hasWarnings = true;
+        break;
+      case "fail":
+        icon = "\u2716";
+        color = chalk3.red;
+        hasFailures = true;
+        if (result.fix) {
+          fixableIssues.push(result);
+        }
+        break;
+    }
+    console.log(`  ${color(icon)} ${result.name}: ${result.message}`);
+  }
+  console.log();
+  if (hasFailures) {
+    logger.error("Some checks failed.");
+    if (fixableIssues.length > 0 && options.fix) {
+      logger.section("Applying Fixes");
+      for (const issue of fixableIssues) {
+        if (issue.fix) {
+          try {
+            await issue.fix();
+          } catch (err) {
+            logger.error(
+              `Failed to fix ${issue.name}: ${err instanceof Error ? err.message : String(err)}`
+            );
+          }
+        }
+      }
+      logger.blank();
+      logger.info("Run 'opencode-athena doctor' again to verify fixes.");
+    } else if (fixableIssues.length > 0) {
+      logger.info(`Run ${chalk3.cyan("opencode-athena doctor --fix")} to attempt automatic fixes.`);
+    }
+  } else if (hasWarnings) {
+    logger.warn("Some checks have warnings, but Athena should work.");
+  } else {
+    logger.success("All checks passed! OpenCode Athena is healthy.");
+  }
+}
+
+// src/cli/commands/info.ts
+init_esm_shims();
+async function info() {
+  logger.banner();
+  const fileManager = new FileManager();
+  const athenaConfig = fileManager.readJsonFile(CONFIG_PATHS.globalAthenaConfig);
+  if (!athenaConfig) {
+    logger.warn("OpenCode Athena is not installed.");
+    logger.info(`Run ${chalk3.cyan("opencode-athena install")} to get started.`);
+    return;
+  }
+  logger.section("Version Information");
+  logger.keyValue("Athena Version", athenaConfig.version || VERSION);
+  logger.section("Prerequisites");
+  const prereqs = await checkPrerequisites();
+  const nodeStatus = prereqs.node.installed ? prereqs.node.compatible ? chalk3.green("\u2713") : chalk3.yellow("!") : chalk3.red("\u2716");
+  logger.keyValue("Node.js", `${nodeStatus} ${prereqs.node.version || "not found"}`);
+  const opencodeStatus = prereqs.opencode.installed ? prereqs.opencode.compatible ? chalk3.green("\u2713") : chalk3.yellow("!") : chalk3.red("\u2716");
+  logger.keyValue("OpenCode", `${opencodeStatus} ${prereqs.opencode.version || "not found"}`);
+  logger.section("Configured Providers");
+  const claudeStatus = athenaConfig.subscriptions.claude.enabled ? chalk3.green("enabled") : chalk3.gray("disabled");
+  logger.keyValue(
+    "Claude",
+    `${claudeStatus}${athenaConfig.subscriptions.claude.tier !== "none" ? ` (${athenaConfig.subscriptions.claude.tier})` : ""}`
+  );
+  const openaiStatus = athenaConfig.subscriptions.openai.enabled ? chalk3.green("enabled") : chalk3.gray("disabled");
+  logger.keyValue("OpenAI", openaiStatus);
+  const googleStatus = athenaConfig.subscriptions.google.enabled ? chalk3.green("enabled") : chalk3.gray("disabled");
+  logger.keyValue(
+    "Google",
+    `${googleStatus}${athenaConfig.subscriptions.google.authMethod !== "none" ? ` (${athenaConfig.subscriptions.google.authMethod})` : ""}`
+  );
+  logger.section("Agent Models");
+  logger.keyValue("Sisyphus", athenaConfig.models.sisyphus);
+  logger.keyValue("Oracle", athenaConfig.models.oracle);
+  logger.keyValue("Librarian", athenaConfig.models.librarian);
+  if (athenaConfig.models.frontend) {
+    logger.keyValue("Frontend", athenaConfig.models.frontend);
+  }
+  if (athenaConfig.models.documentWriter) {
+    logger.keyValue("Doc Writer", athenaConfig.models.documentWriter);
+  }
+  if (athenaConfig.models.multimodalLooker) {
+    logger.keyValue("Multimodal", athenaConfig.models.multimodalLooker);
+  }
+  logger.section("BMAD Settings");
+  logger.keyValue("Default Track", athenaConfig.bmad.defaultTrack);
+  logger.keyValue("Auto Status Update", athenaConfig.bmad.autoStatusUpdate ? "yes" : "no");
+  logger.keyValue("Parallel Story Limit", athenaConfig.bmad.parallelStoryLimit.toString());
+  logger.section("Features");
+  const features = athenaConfig.features;
+  const featureList = [
+    { name: "BMAD Bridge", enabled: features.bmadBridge },
+    { name: "Auto Status", enabled: features.autoStatus },
+    { name: "Parallel Exec", enabled: features.parallelExecution },
+    { name: "Notifications", enabled: features.notifications },
+    { name: "Context Monitor", enabled: features.contextMonitor },
+    { name: "Comment Checker", enabled: features.commentChecker },
+    { name: "LSP Tools", enabled: features.lspTools }
+  ];
+  for (const feature of featureList) {
+    const status = feature.enabled ? chalk3.green("on") : chalk3.gray("off");
+    logger.keyValue(feature.name, status);
+  }
+  logger.section("MCP Servers");
+  const mcps = athenaConfig.mcps;
+  logger.keyValue("context7", mcps.context7 ? chalk3.green("on") : chalk3.gray("off"));
+  logger.keyValue("exa", mcps.exa ? chalk3.green("on") : chalk3.gray("off"));
+  logger.keyValue("grep_app", mcps.grepApp ? chalk3.green("on") : chalk3.gray("off"));
+  logger.section("Installed Plugins");
+  const plugins = await getInstalledPlugins();
+  if (Object.keys(plugins).length === 0) {
+    logger.info("No plugins installed in OpenCode config directory");
+  } else {
+    for (const [name, version] of Object.entries(plugins)) {
+      logger.keyValue(name, version);
+    }
+  }
+  logger.section("Configuration Paths");
+  logger.keyValue("Config Dir", CONFIG_PATHS.globalConfigDir);
+  logger.keyValue("Athena Config", CONFIG_PATHS.globalAthenaConfig);
+  logger.keyValue("Commands Dir", CONFIG_PATHS.commandsDir);
+  console.log();
+}
+
+// src/cli/commands/install.ts
+init_esm_shims();
+
+// src/cli/generators/config-generator.ts
+init_esm_shims();
+
+// src/cli/generators/athena-config.ts
+init_esm_shims();
+
+// src/cli/questions/features.ts
+init_esm_shims();
+var AVAILABLE_FEATURES = [
+  {
+    name: "BMAD Bridge Commands (/athena-dev, /athena-review, etc.)",
+    value: "bmad-bridge"
+  },
+  {
+    name: "Auto Sprint Status Updates - Update sprint-status.yaml automatically",
+    value: "auto-status"
+  },
+  {
+    name: "Parallel Story Execution - Work on multiple stories simultaneously",
+    value: "parallel"
+  },
+  {
+    name: "Session Notifications - Desktop notifications for completions",
+    value: "notifications"
+  },
+  {
+    name: "Context Window Monitoring - Track context usage",
+    value: "context-monitor"
+  },
+  {
+    name: "Comment Checker - Ensure code is not over-commented",
+    value: "comment-checker"
+  },
+  {
+    name: "LSP Refactoring Tools - Enable lsp_rename, lsp_find_references, etc.",
+    value: "lsp-tools"
+  }
+];
+var ALL_FEATURE_VALUES = AVAILABLE_FEATURES.map((f) => f.value);
+var AVAILABLE_MCPS = [
+  {
+    name: "context7 - Documentation lookup and context retrieval",
+    value: "context7"
+  },
+  {
+    name: "websearch_exa - Web search capabilities",
+    value: "exa"
+  },
+  {
+    name: "grep_app - GitHub code search",
+    value: "grep_app"
+  }
+];
+var ALL_MCP_VALUES = AVAILABLE_MCPS.map((m) => m.value);
+function createFeatureChoices(defaults) {
+  const enabledSet = new Set(defaults ?? ALL_FEATURE_VALUES);
+  return AVAILABLE_FEATURES.map((feature) => ({
+    ...feature,
+    checked: enabledSet.has(feature.value)
+  }));
+}
+function createMcpChoices(defaults) {
+  const enabledSet = new Set(defaults ?? ALL_MCP_VALUES);
+  return AVAILABLE_MCPS.map((mcp) => ({
+    ...mcp,
+    checked: enabledSet.has(mcp.value)
+  }));
+}
+async function gatherFeatures(defaults) {
+  const enabledFeatures = await checkbox({
+    message: "Select features to enable:",
+    choices: createFeatureChoices(defaults?.enabledFeatures)
+  });
+  const mcps = await checkbox({
+    message: "Select MCP servers to enable:",
+    choices: createMcpChoices(defaults?.mcps)
+  });
+  return {
+    enabledFeatures,
+    mcps
+  };
+}
+function featuresToFlags(enabledFeatures) {
+  return {
+    bmadBridge: enabledFeatures.includes("bmad-bridge"),
+    autoStatus: enabledFeatures.includes("auto-status"),
+    parallelExecution: enabledFeatures.includes("parallel"),
+    notifications: enabledFeatures.includes("notifications"),
+    contextMonitor: enabledFeatures.includes("context-monitor"),
+    commentChecker: enabledFeatures.includes("comment-checker"),
+    lspTools: enabledFeatures.includes("lsp-tools")
+  };
+}
+function mcpsToFlags(mcps) {
+  return {
+    context7: mcps.includes("context7"),
+    exa: mcps.includes("exa"),
+    grepApp: mcps.includes("grep_app")
+  };
+}
+
+// src/cli/generators/athena-config.ts
+function generateAthenaConfig(answers) {
+  const { subscriptions, models, methodology, features, advanced } = answers;
+  return {
+    $schema: "https://raw.githubusercontent.com/ZebulonRouseFrantzich/opencode-athena/main/config/schemas/athena.schema.json",
+    version: VERSION,
+    subscriptions: {
+      claude: {
+        enabled: subscriptions.hasClaude,
+        tier: subscriptions.claudeTier
+      },
+      openai: {
+        enabled: subscriptions.hasOpenAI
+      },
+      google: {
+        enabled: subscriptions.hasGoogle,
+        authMethod: subscriptions.googleAuth
+      }
+    },
+    models: {
+      sisyphus: models.sisyphus,
+      oracle: models.oracle,
+      librarian: models.librarian,
+      frontend: models.frontend,
+      documentWriter: models.documentWriter,
+      multimodalLooker: models.multimodalLooker
+    },
+    bmad: {
+      defaultTrack: methodology.defaultTrack,
+      autoStatusUpdate: methodology.autoStatusUpdate,
+      parallelStoryLimit: advanced.parallelStoryLimit ?? 3
+    },
+    features: featuresToFlags(features.enabledFeatures),
+    mcps: mcpsToFlags(features.mcps)
+  };
+}
+
+// src/cli/generators/omo-config.ts
+init_esm_shims();
+function generateOmoConfig(answers) {
+  const { subscriptions, models, features, advanced } = answers;
+  const config = {
+    $schema: "https://raw.githubusercontent.com/code-yeongyu/oh-my-opencode/master/assets/oh-my-opencode.schema.json"
+  };
+  if (subscriptions.hasGoogle && subscriptions.googleAuth === "antigravity") {
+    config.google_auth = false;
+  }
+  config.agents = {
+    // Main orchestrator
+    Sisyphus: {
+      model: models.sisyphus
+    },
+    // Debugging/reasoning agent
+    oracle: {
+      model: models.oracle
+    },
+    // Research agent
+    librarian: {
+      model: models.librarian
+    },
+    // UI/UX agent
+    "frontend-ui-ux-engineer": {
+      model: models.frontend || models.sisyphus
+    },
+    // Documentation agent
+    "document-writer": {
+      model: models.documentWriter || models.librarian
+    },
+    // Image analysis agent
+    "multimodal-looker": {
+      model: models.multimodalLooker || models.librarian
+    }
+  };
+  const disabledHooks = [];
+  if (!features.enabledFeatures.includes("context-monitor")) {
+    disabledHooks.push("context-window-monitor");
+  }
+  if (!features.enabledFeatures.includes("comment-checker")) {
+    disabledHooks.push("comment-checker");
+  }
+  if (!features.enabledFeatures.includes("notifications")) {
+    disabledHooks.push("session-notification", "background-notification");
+  }
+  if (disabledHooks.length > 0) {
+    config.disabled_hooks = disabledHooks;
+  }
+  const allMcps = ["context7", "websearch_exa", "grep_app"];
+  const enabledMcpIds = features.mcps.map((mcp) => {
+    if (mcp === "exa") return "websearch_exa";
+    return mcp;
+  });
+  const disabledMcps = allMcps.filter((mcp) => !enabledMcpIds.includes(mcp));
+  if (disabledMcps.length > 0) {
+    config.disabled_mcps = disabledMcps;
+  }
+  if (advanced.experimental && advanced.experimental.length > 0) {
+    config.experimental = {};
+    if (advanced.experimental.includes("aggressive-truncation")) {
+      config.experimental.aggressive_truncation = true;
+    }
+    if (advanced.experimental.includes("auto-resume")) {
+      config.experimental.auto_resume = true;
+    }
+  }
+  return config;
+}
+
+// src/cli/generators/opencode-config.ts
+init_esm_shims();
+async function generateOpencodeConfig(answers, configDir) {
+  const configPath = join(configDir, "opencode.json");
+  let existingConfig = {};
+  if (existsSync(configPath)) {
+    try {
+      const content = readFileSync(configPath, "utf-8");
+      existingConfig = JSON.parse(content);
+    } catch {
+    }
+  }
+  const plugins = ["opencode-athena/plugin", "oh-my-opencode"];
+  if (answers.subscriptions.hasGoogle && answers.subscriptions.googleAuth === "antigravity") {
+    plugins.push("opencode-antigravity-auth");
+  }
+  if (answers.subscriptions.hasOpenAI) {
+    plugins.push("opencode-openai-codex-auth");
+  }
+  const existingPlugins = existingConfig.plugin || [];
+  const mergedPlugins = [.../* @__PURE__ */ new Set([...existingPlugins, ...plugins])];
+  const config = {
+    ...existingConfig,
+    $schema: existingConfig.$schema || "https://opencode.ai/config.json",
+    plugin: mergedPlugins
+  };
+  if (answers.subscriptions.hasClaude) {
+    const existingProvider = existingConfig.provider || {};
+    const existingAnthropic = existingProvider.anthropic || {};
+    const existingAnthropicModels = existingAnthropic.models || {};
+    config.provider = {
+      ...existingProvider,
+      anthropic: {
+        ...existingAnthropic,
+        models: {
+          ...existingAnthropicModels,
+          // Add thinking model variants
+          "claude-opus-4-5-thinking": {
+            id: "claude-opus-4-5",
+            options: {
+              thinking: {
+                type: "enabled",
+                budgetTokens: 32e3
+              }
+            }
+          },
+          "claude-sonnet-4-5-thinking": {
+            id: "claude-sonnet-4-5",
+            options: {
+              thinking: {
+                type: "enabled",
+                budgetTokens: 1e4
+              }
+            }
+          }
+        }
+      }
+    };
+  }
+  if (answers.subscriptions.hasOpenAI) {
+    const existingProvider = config.provider || {};
+    const existingOpenAI = existingProvider.openai || {};
+    const existingOpenAIModels = existingOpenAI.models || {};
+    config.provider = {
+      ...existingProvider,
+      openai: {
+        ...existingOpenAI,
+        models: {
+          ...existingOpenAIModels,
+          // Add reasoning effort configurations
+          "gpt-5.1-high": {
+            id: "gpt-5.1",
+            options: {
+              reasoningEffort: "high",
+              reasoningSummary: "auto"
+            }
+          }
+        }
+      }
+    };
+  }
+  return config;
+}
+function getRequiredPlugins(answers) {
+  const plugins = ["opencode-athena", "oh-my-opencode"];
+  if (answers.subscriptions.hasGoogle && answers.subscriptions.googleAuth === "antigravity") {
+    plugins.push("opencode-antigravity-auth");
+  }
+  if (answers.subscriptions.hasOpenAI) {
+    plugins.push("opencode-openai-codex-auth");
+  }
+  return plugins;
+}
+
+// src/cli/generators/config-generator.ts
+var ConfigGenerator = class {
+  answers;
+  configDir;
+  constructor(answers) {
+    this.answers = answers;
+    this.configDir = answers.installLocation === "local" ? join(process.cwd(), ".opencode") : CONFIG_PATHS.globalConfigDir;
+  }
+  /**
+   * Get the configuration directory path
+   */
+  getConfigDir() {
+    return this.configDir;
+  }
+  /**
+   * Generate all configuration files
+   */
+  async generate() {
+    const files = [];
+    const opencodeConfig = await generateOpencodeConfig(this.answers, this.configDir);
+    files.push({
+      path: join(this.configDir, "opencode.json"),
+      content: JSON.stringify(opencodeConfig, null, 2),
+      exists: existsSync(join(this.configDir, "opencode.json"))
+    });
+    const omoConfig = generateOmoConfig(this.answers);
+    files.push({
+      path: join(this.configDir, "oh-my-opencode.json"),
+      content: JSON.stringify(omoConfig, null, 2),
+      exists: existsSync(join(this.configDir, "oh-my-opencode.json"))
+    });
+    const athenaConfig = generateAthenaConfig(this.answers);
+    files.push({
+      path: join(this.configDir, "athena.json"),
+      content: JSON.stringify(athenaConfig, null, 2),
+      exists: existsSync(join(this.configDir, "athena.json"))
+    });
+    return files;
+  }
+  /**
+   * Get the list of npm packages to install
+   */
+  getRequiredPackages() {
+    return getRequiredPlugins(this.answers);
+  }
+};
+
+// src/cli/questions/index.ts
+init_esm_shims();
+
+// src/cli/questions/subscriptions.ts
+init_esm_shims();
+async function gatherSubscriptions() {
+  const hasClaude = await confirm({
+    message: "Do you have a Claude Pro/Max subscription?",
+    default: true
+  });
+  let claudeTier = "none";
+  if (hasClaude) {
+    claudeTier = await select({
+      message: "Which Claude tier?",
+      choices: [
+        { name: "Max 5x - 5x more usage than Pro", value: "max5x" },
+        { name: "Max 20x - 20x more usage than Pro", value: "max20x" },
+        { name: "Pro - Standard Pro subscription", value: "pro" }
+      ]
+    });
+  }
+  const hasOpenAI = await confirm({
+    message: "Do you have a ChatGPT Plus/Pro subscription?",
+    default: true
+  });
+  const hasGoogle = await confirm({
+    message: "Will you use Google/Gemini models?",
+    default: true
+  });
+  let googleAuth = "none";
+  if (hasGoogle) {
+    googleAuth = await select({
+      message: "Google authentication method?",
+      choices: [
+        {
+          name: "Google Workspace (Antigravity OAuth) - Recommended for Workspace users",
+          value: "antigravity"
+        },
+        {
+          name: "Personal Google Account",
+          value: "personal"
+        },
+        {
+          name: "API Key - Direct API access",
+          value: "api"
+        }
+      ]
+    });
+  }
+  return {
+    hasClaude,
+    claudeTier,
+    hasOpenAI,
+    hasGoogle,
+    googleAuth
+  };
+}
+
+// src/cli/questions/index.ts
+init_models();
+
+// src/cli/questions/methodology.ts
+init_esm_shims();
+async function gatherMethodology(defaults) {
+  const defaultTrack = await select({
+    message: "Default BMAD track for new projects?",
+    choices: [
+      {
+        name: "Quick Flow - Fast implementation for small features and bug fixes",
+        value: "quick-flow"
+      },
+      {
+        name: "BMad Method - Full planning for products and platforms (recommended)",
+        value: "bmad-method"
+      },
+      {
+        name: "Enterprise - Extended planning with compliance and scale considerations",
+        value: "enterprise"
+      }
+    ],
+    default: defaults?.defaultTrack ?? "bmad-method"
+  });
+  const autoStatusUpdate = await confirm({
+    message: "Automatically update sprint-status.yaml when stories complete?",
+    default: defaults?.autoStatusUpdate ?? true
+  });
+  return {
+    defaultTrack,
+    autoStatusUpdate
+  };
+}
+
+// src/cli/questions/advanced.ts
+init_esm_shims();
+async function gatherAdvanced(defaults) {
+  const parallelStoryLimit = await select({
+    message: "Maximum parallel stories?",
+    choices: [
+      { name: "1 (sequential - one story at a time)", value: 1 },
+      { name: "2", value: 2 },
+      { name: "3 (recommended)", value: 3 },
+      { name: "5", value: 5 },
+      { name: "Unlimited (0)", value: 0 }
+    ],
+    default: defaults?.parallelStoryLimit ?? 3
+  });
+  const experimentalDefaults = new Set(defaults?.experimental ?? []);
+  const experimental = await checkbox({
+    message: "Enable experimental features?",
+    choices: [
+      {
+        name: "Aggressive Truncation - More aggressive context management",
+        value: "aggressive-truncation",
+        checked: experimentalDefaults.has("aggressive-truncation")
+      },
+      {
+        name: "Auto Resume - Automatically resume interrupted sessions",
+        value: "auto-resume",
+        checked: experimentalDefaults.has("auto-resume")
+      }
+    ]
+  });
+  return {
+    parallelStoryLimit,
+    experimental
+  };
+}
+
+// src/cli/utils/preset-loader.ts
+init_esm_shims();
+var PRESET_NAMES = ["minimal", "standard", "enterprise", "solo-quick"];
+function getPresetsDir() {
+  const currentFileDir = dirname(fileURLToPath(import.meta.url));
+  const bundledRoot = join(currentFileDir, "..", "..");
+  const bundledPresetsDir = join(bundledRoot, "config", "presets");
+  if (existsSync(bundledPresetsDir)) {
+    return bundledPresetsDir;
+  }
+  const devRoot = join(currentFileDir, "..", "..", "..");
+  const devPresetsDir = join(devRoot, "config", "presets");
+  if (existsSync(devPresetsDir)) {
+    return devPresetsDir;
+  }
+  const nodeModulesPath = currentFileDir.split("node_modules")[0];
+  if (nodeModulesPath !== currentFileDir) {
+    const packagePresetsDir = join(
+      nodeModulesPath,
+      "node_modules",
+      "opencode-athena",
+      "config",
+      "presets"
+    );
+    if (existsSync(packagePresetsDir)) {
+      return packagePresetsDir;
+    }
+  }
+  throw new Error(
+    `Could not find presets directory. Searched:
+  - ${bundledPresetsDir}
+  - ${devPresetsDir}`
+  );
+}
+function isValidPresetName(name) {
+  return PRESET_NAMES.includes(name);
+}
+function loadPreset(name) {
+  if (!isValidPresetName(name)) {
+    const validNames = PRESET_NAMES.join(", ");
+    throw new Error(`Invalid preset name: "${name}". Valid presets are: ${validNames}`);
+  }
+  const presetsDir = getPresetsDir();
+  const presetPath = join(presetsDir, `${name}.json`);
+  if (!existsSync(presetPath)) {
+    throw new Error(
+      `Preset file not found: ${presetPath}
+This may indicate a corrupted installation. Try reinstalling opencode-athena.`
+    );
+  }
+  try {
+    const content = readFileSync(presetPath, "utf-8");
+    const preset = JSON.parse(content);
+    if (!preset.version || !preset.models || !preset.bmad || !preset.features) {
+      throw new Error(`Preset "${name}" is missing required fields`);
+    }
+    return preset;
+  } catch (error) {
+    if (error instanceof SyntaxError) {
+      throw new Error(`Invalid JSON in preset file: ${presetPath}
+Error: ${error.message}`);
+    }
+    throw error;
+  }
+}
+function listPresets() {
+  const presetsDir = getPresetsDir();
+  const summaries = [];
+  for (const name of PRESET_NAMES) {
+    const presetPath = join(presetsDir, `${name}.json`);
+    if (existsSync(presetPath)) {
+      try {
+        const content = readFileSync(presetPath, "utf-8");
+        const preset = JSON.parse(content);
+        summaries.push({
+          name,
+          description: preset.description || `${name} preset`,
+          path: presetPath
+        });
+      } catch {
+        summaries.push({
+          name,
+          description: `${name} preset (unable to read)`,
+          path: presetPath
+        });
+      }
+    }
+  }
+  return summaries;
+}
+function presetToDefaults(preset) {
+  return {
+    models: {
+      sisyphus: preset.models.sisyphus,
+      oracle: preset.models.oracle,
+      librarian: preset.models.librarian,
+      frontend: preset.models.frontend,
+      documentWriter: preset.models.documentWriter,
+      multimodalLooker: preset.models.multimodalLooker
+    },
+    methodology: {
+      defaultTrack: preset.bmad.defaultTrack,
+      autoStatusUpdate: preset.bmad.autoStatusUpdate
+    },
+    features: {
+      enabledFeatures: flagsToFeatures(preset.features),
+      mcps: flagsToMcps(preset.mcps)
+    },
+    advanced: {
+      parallelStoryLimit: preset.bmad.parallelStoryLimit,
+      experimental: []
+    }
+  };
+}
+function flagsToFeatures(flags) {
+  const features = [];
+  if (flags.bmadBridge) features.push("bmad-bridge");
+  if (flags.autoStatus) features.push("auto-status");
+  if (flags.parallelExecution) features.push("parallel");
+  if (flags.notifications) features.push("notifications");
+  if (flags.contextMonitor) features.push("context-monitor");
+  if (flags.commentChecker) features.push("comment-checker");
+  if (flags.lspTools) features.push("lsp-tools");
+  return features;
+}
+function flagsToMcps(mcps) {
+  const result = [];
+  if (mcps.context7) result.push("context7");
+  if (mcps.exa) result.push("exa");
+  if (mcps.grepApp) result.push("grep_app");
+  return result;
+}
+function formatPresetSummary(preset, name) {
+  const lines = [];
+  lines.push(`Preset: ${name}`);
+  lines.push(`Description: ${preset.description}`);
+  lines.push("");
+  lines.push("Models:");
+  lines.push(`  Sisyphus: ${preset.models.sisyphus}`);
+  lines.push(`  Oracle: ${preset.models.oracle}`);
+  lines.push(`  Librarian: ${preset.models.librarian}`);
+  lines.push("");
+  lines.push("BMAD Settings:");
+  lines.push(`  Default Track: ${preset.bmad.defaultTrack}`);
+  lines.push(`  Auto Status Update: ${preset.bmad.autoStatusUpdate ? "Yes" : "No"}`);
+  lines.push(`  Parallel Story Limit: ${preset.bmad.parallelStoryLimit}`);
+  lines.push("");
+  lines.push("Features:");
+  const enabledFeatures = flagsToFeatures(preset.features);
+  if (enabledFeatures.length > 0) {
+    lines.push(`  Enabled: ${enabledFeatures.join(", ")}`);
+  } else {
+    lines.push("  Enabled: none");
+  }
+  lines.push("");
+  lines.push("MCP Servers:");
+  const enabledMcps = flagsToMcps(preset.mcps);
+  if (enabledMcps.length > 0) {
+    lines.push(`  Enabled: ${enabledMcps.join(", ")}`);
+  } else {
+    lines.push("  Enabled: none");
+  }
+  return lines.join("\n");
+}
+
+// src/cli/commands/install.ts
+async function install(options) {
+  logger.banner();
+  const spinner = ora3("Checking prerequisites...").start();
+  const prereqs = await checkPrerequisites();
+  if (!prereqs.node.installed) {
+    spinner.fail("Node.js not found");
+    logger.error("Please install Node.js 20+ first: https://nodejs.org/");
+    process.exit(1);
+  }
+  if (!prereqs.node.compatible) {
+    spinner.warn(`Node.js ${prereqs.node.version} detected. Recommended: 20+`);
+  }
+  if (!prereqs.opencode.installed) {
+    spinner.fail("OpenCode not found");
+    logger.error("Please install OpenCode first: https://opencode.ai/docs");
+    process.exit(1);
+  }
+  if (!prereqs.opencode.compatible) {
+    spinner.warn(`OpenCode ${prereqs.opencode.version} detected. Recommended: 1.0.132+`);
+  } else {
+    spinner.succeed(`OpenCode ${prereqs.opencode.version || ""} detected`);
+  }
+  if (prereqs.athena.installed && !options.yes) {
+    const overwrite = await confirm({
+      message: `OpenCode Athena ${prereqs.athena.version || ""} is already installed. Overwrite configuration?`,
+      default: false
+    });
+    if (!overwrite) {
+      logger.info("Installation cancelled.");
+      process.exit(0);
+    }
+  }
+  let preset = null;
+  let presetDefaults = null;
+  let presetName = null;
+  if (options.preset && options.preset !== "none") {
+    if (!isValidPresetName(options.preset)) {
+      logger.error(`Invalid preset: "${options.preset}"`);
+      logger.info(`Valid presets: ${PRESET_NAMES.join(", ")}`);
+      process.exit(1);
+    }
+    try {
+      preset = loadPreset(options.preset);
+      presetDefaults = presetToDefaults(preset);
+      presetName = options.preset;
+      logger.success(`Loaded preset: ${options.preset}`);
+    } catch (error) {
+      logger.error(error instanceof Error ? error.message : String(error));
+      process.exit(1);
+    }
+  }
+  if (!preset && !options.yes) {
+    const selectedPreset = await askForPreset();
+    if (selectedPreset) {
+      preset = selectedPreset.preset;
+      presetDefaults = presetToDefaults(preset);
+      presetName = selectedPreset.name;
+    }
+  }
+  logger.section("LLM Subscriptions");
+  const subscriptions = await gatherSubscriptions();
+  let shouldCustomize = true;
+  if (preset && presetDefaults && presetName) {
+    const modelWarnings = validatePresetModels(presetDefaults.models, subscriptions);
+    if (modelWarnings.length > 0) {
+      console.log(chalk3.yellow("\nPreset model compatibility warnings:"));
+      for (const warning of modelWarnings) {
+        console.log(chalk3.yellow(`  - ${warning}`));
+      }
+      console.log();
+    }
+    console.log(chalk3.bold("\nPreset Configuration:\n"));
+    console.log(chalk3.gray(formatPresetSummary(preset, presetName)));
+    console.log();
+    if (options.yes) {
+      shouldCustomize = false;
+      logger.info("Using preset defaults (--yes flag)");
+    } else {
+      shouldCustomize = await confirm({
+        message: "Would you like to customize these settings?",
+        default: false
+      });
+    }
+  }
+  let models;
+  let methodology;
+  let features;
+  let advanced;
+  if (!shouldCustomize && presetDefaults) {
+    logger.section("Applying Preset Configuration");
+    const availableModels = await Promise.resolve().then(() => (init_models(), models_exports)).then(
+      (m) => m.getAvailableModels(subscriptions)
+    );
+    if (availableModels.length === 0) {
+      logger.error(
+        "No models available. Please enable at least one provider (Claude, OpenAI, or Google)."
+      );
+      process.exit(1);
+    }
+    models = {
+      sisyphus: getValidModelOrFirst(presetDefaults.models.sisyphus, availableModels),
+      oracle: getValidModelOrFirst(presetDefaults.models.oracle, availableModels),
+      librarian: getValidModelOrFirst(presetDefaults.models.librarian, availableModels),
+      frontend: getValidModelOrFirst(presetDefaults.models.frontend, availableModels),
+      documentWriter: getValidModelOrFirst(presetDefaults.models.documentWriter, availableModels),
+      multimodalLooker: getValidModelOrFirst(
+        presetDefaults.models.multimodalLooker,
+        availableModels
+      )
+    };
+    methodology = presetDefaults.methodology;
+    features = presetDefaults.features;
+    advanced = presetDefaults.advanced;
+    logger.success("Preset configuration applied");
+  } else {
+    logger.section("Model Selection");
+    models = await gatherModels(subscriptions, presetDefaults?.models);
+    logger.section("Methodology Preferences");
+    methodology = await gatherMethodology(presetDefaults?.methodology);
+    logger.section("Feature Selection");
+    features = await gatherFeatures(presetDefaults?.features);
+    if (options.advanced) {
+      logger.section("Advanced Configuration");
+      advanced = await gatherAdvanced(presetDefaults?.advanced);
+    } else {
+      advanced = presetDefaults?.advanced ?? {
+        parallelStoryLimit: DEFAULTS.parallelStoryLimit,
+        experimental: []
+      };
+    }
+  }
+  logger.section("Generating Configuration");
+  const answers = {
+    subscriptions,
+    models,
+    methodology,
+    features,
+    advanced,
+    installLocation: options.local ? "local" : "global"
+  };
+  const generator = new ConfigGenerator(answers);
+  const files = await generator.generate();
+  console.log(chalk3.bold("Files to be created/modified:\n"));
+  for (const file of files) {
+    const action = file.exists ? chalk3.yellow("update") : chalk3.green("create");
+    console.log(chalk3.gray(`  [${action}] ${file.path}`));
+  }
+  console.log();
+  if (!options.yes) {
+    const proceed = await confirm({
+      message: "Proceed with installation?",
+      default: true
+    });
+    if (!proceed) {
+      logger.info("Installation cancelled.");
+      process.exit(0);
+    }
+  }
+  const installSpinner = ora3("Installing OpenCode Athena...").start();
+  try {
+    const fileManager = new FileManager(generator.getConfigDir());
+    await fileManager.writeFiles(files);
+    installSpinner.text = "Configuration files written...";
+    const packages = generator.getRequiredPackages();
+    if (packages.length > 0) {
+      installSpinner.text = `Installing dependencies: ${packages.join(", ")}...`;
+      await fileManager.installDependencies(packages);
+    }
+    installSpinner.text = "Installing commands...";
+    const copiedCommands = await fileManager.copyCommands();
+    installSpinner.succeed("Installation complete!");
+    if (copiedCommands.length > 0) {
+      logger.info(`Installed ${copiedCommands.length} bridge commands`);
+    }
+  } catch (error) {
+    installSpinner.fail("Installation failed");
+    logger.error(error instanceof Error ? error.message : String(error));
+    process.exit(1);
+  }
+  printNextSteps(subscriptions);
+}
+async function askForPreset() {
+  const presets = listPresets();
+  const choices = [
+    { name: "No preset - Configure everything manually", value: "none" },
+    ...presets.map((p) => ({
+      name: `${p.name} - ${p.description}`,
+      value: p.name
+    }))
+  ];
+  const selected = await select({
+    message: "Start from a preset?",
+    choices,
+    default: "standard"
+  });
+  if (selected === "none") {
+    return null;
+  }
+  try {
+    const preset = loadPreset(selected);
+    return { preset, name: selected };
+  } catch (error) {
+    logger.warn(`Failed to load preset: ${error instanceof Error ? error.message : String(error)}`);
+    return null;
+  }
+}
+function getValidModelOrFirst(modelId, availableModels) {
+  if (modelId && availableModels.some((m) => m.id === modelId)) {
+    return modelId;
+  }
+  return availableModels[0]?.id ?? "";
+}
+function printNextSteps(subscriptions) {
+  const steps = [];
+  if (subscriptions.hasClaude) {
+    steps.push(`Run: ${chalk3.cyan("opencode auth login")} -> Select Anthropic -> Claude Pro/Max`);
+  }
+  if (subscriptions.hasOpenAI) {
+    steps.push(`Run: ${chalk3.cyan("opencode auth login")} -> Select OpenAI -> ChatGPT Plus/Pro`);
+  }
+  if (subscriptions.hasGoogle) {
+    steps.push(`Run: ${chalk3.cyan("opencode auth login")} -> Select Google -> OAuth with Google`);
+  }
+  logger.successBanner("OPENCODE ATHENA INSTALLED SUCCESSFULLY!");
+  console.log(chalk3.bold("Next Steps:\n"));
+  steps.forEach((step, i) => {
+    console.log(`  ${i + 1}. ${step}`);
+  });
+  console.log(chalk3.bold("\nThen start OpenCode and try:\n"));
+  console.log(`  ${chalk3.cyan("/athena-dev")}      Implement a BMAD story with Sisyphus`);
+  console.log(`  ${chalk3.cyan("/athena-status")}   Check sprint status`);
+  console.log(`  ${chalk3.cyan("/athena-info")}     View toolkit configuration`);
+  console.log(chalk3.bold("\nFor BMAD project setup:\n"));
+  console.log(`  ${chalk3.cyan("npx bmad-method@alpha install")}   Install BMAD in your project`);
+  console.log(
+    chalk3.gray("\nDocumentation: https://github.com/ZebulonRouseFrantzich/opencode-athena")
+  );
+  console.log();
+}
+
+// src/cli/commands/uninstall.ts
+init_esm_shims();
+async function uninstall(options) {
+  logger.banner();
+  logger.warn("This will remove OpenCode Athena from your system.");
+  console.log();
+  const proceed = await confirm({
+    message: "Are you sure you want to uninstall OpenCode Athena?",
+    default: false
+  });
+  if (!proceed) {
+    logger.info("Uninstall cancelled.");
+    return;
+  }
+  logger.section("Uninstalling OpenCode Athena");
+  const fileManager = new FileManager();
+  const commandsSpinner = ora3("Removing bridge commands...").start();
+  try {
+    const removedCommands = await fileManager.removeCommands();
+    if (removedCommands.length > 0) {
+      commandsSpinner.succeed(`Removed ${removedCommands.length} bridge command(s)`);
+    } else {
+      commandsSpinner.info("No bridge commands found");
+    }
+  } catch (err) {
+    commandsSpinner.fail("Failed to remove bridge commands");
+    logger.error(err instanceof Error ? err.message : String(err));
+  }
+  if (!options.keepConfig) {
+    const configSpinner = ora3("Removing configuration files...").start();
+    try {
+      const removedFiles = await fileManager.removeConfigFiles();
+      if (removedFiles.length > 0) {
+        configSpinner.succeed(`Removed ${removedFiles.length} configuration file(s)`);
+      } else {
+        configSpinner.info("No Athena configuration files found");
+      }
+    } catch (err) {
+      configSpinner.fail("Failed to remove configuration files");
+      logger.error(err instanceof Error ? err.message : String(err));
+    }
+  } else {
+    logger.info("Keeping configuration files (--keep-config)");
+  }
+  const opencodeSpinner = ora3("Updating opencode.json...").start();
+  try {
+    const updated = await fileManager.removeFromOpencodeConfig();
+    if (updated) {
+      opencodeSpinner.succeed("Removed Athena plugins from opencode.json");
+    } else {
+      opencodeSpinner.info("No Athena plugins found in opencode.json");
+    }
+  } catch (err) {
+    opencodeSpinner.fail("Failed to update opencode.json");
+    logger.error(err instanceof Error ? err.message : String(err));
+  }
+  if (!options.keepDeps) {
+    const depsSpinner = ora3("Removing npm dependencies...").start();
+    try {
+      const packagesToRemove = [
+        "oh-my-opencode",
+        "opencode-antigravity-auth",
+        "opencode-openai-codex-auth"
+      ];
+      await fileManager.uninstallDependencies(packagesToRemove);
+      depsSpinner.succeed("Removed npm dependencies");
+    } catch (_err) {
+      depsSpinner.warn("Some dependencies could not be removed");
+    }
+  } else {
+    logger.info("Keeping npm dependencies (--keep-deps)");
+  }
+  console.log();
+  logger.success("OpenCode Athena has been uninstalled.");
+  if (options.keepConfig) {
+    logger.info("Configuration files were preserved.");
+    logger.info(`Run ${chalk3.cyan("opencode-athena install")} to reinstall with existing config.`);
+  }
+  console.log();
+}
+
+// src/cli/commands/update.ts
+init_esm_shims();
+var execAsync3 = promisify(exec);
+async function getLatestVersion(packageName) {
+  try {
+    const { stdout } = await execAsync3(`npm view ${packageName} version`);
+    return stdout.trim();
+  } catch {
+    return null;
+  }
+}
+async function checkPackageUpdate(name, currentVersion) {
+  const latest = await getLatestVersion(name);
+  return {
+    name,
+    current: currentVersion,
+    latest: latest || currentVersion,
+    updateAvailable: latest !== null && latest !== currentVersion
+  };
+}
+async function update(options) {
+  logger.banner();
+  logger.section("Checking for Updates");
+  const spinner = ora3("Checking package versions...").start();
+  const installedPlugins = await getInstalledPlugins();
+  const packagesToCheck = [
+    "oh-my-opencode",
+    "opencode-antigravity-auth",
+    "opencode-openai-codex-auth"
+  ];
+  const updates = [];
+  const athenaLatest = await getLatestVersion("opencode-athena");
+  if (athenaLatest) {
+    updates.push({
+      name: "opencode-athena",
+      current: VERSION,
+      latest: athenaLatest,
+      updateAvailable: athenaLatest !== VERSION
+    });
+  }
+  for (const pkgName of packagesToCheck) {
+    const currentVersion = installedPlugins[pkgName];
+    if (currentVersion) {
+      const updateInfo = await checkPackageUpdate(pkgName, currentVersion);
+      updates.push(updateInfo);
+    }
+  }
+  spinner.stop();
+  logger.section("Package Versions");
+  const updatesAvailable = updates.filter((u) => u.updateAvailable);
+  for (const pkg of updates) {
+    const status = pkg.updateAvailable ? chalk3.yellow(`${pkg.current} -> ${pkg.latest}`) : chalk3.green(pkg.current);
+    logger.keyValue(pkg.name, status);
+  }
+  console.log();
+  if (updatesAvailable.length === 0) {
+    logger.success("All packages are up to date!");
+    return;
+  }
+  logger.info(`${updatesAvailable.length} update(s) available`);
+  if (options.check) {
+    console.log();
+    logger.info(`Run ${chalk3.cyan("opencode-athena update")} (without --check) to apply updates.`);
+    return;
+  }
+  const proceed = await confirm({
+    message: `Update ${updatesAvailable.length} package(s)?`,
+    default: true
+  });
+  if (!proceed) {
+    logger.info("Update cancelled.");
+    return;
+  }
+  logger.section("Applying Updates");
+  const fileManager = new FileManager();
+  const athenaUpdate = updatesAvailable.find((u) => u.name === "opencode-athena");
+  if (athenaUpdate) {
+    const athenaSpinner = ora3("Updating opencode-athena...").start();
+    try {
+      await execAsync3("npm install -g opencode-athena@latest");
+      athenaSpinner.succeed(`opencode-athena updated to ${athenaUpdate.latest}`);
+    } catch (err) {
+      athenaSpinner.fail("Failed to update opencode-athena");
+      logger.error(err instanceof Error ? err.message : String(err));
+    }
+  }
+  const pluginUpdates = updatesAvailable.filter((u) => u.name !== "opencode-athena");
+  if (pluginUpdates.length > 0) {
+    const pluginSpinner = ora3("Updating plugins...").start();
+    try {
+      const packages = pluginUpdates.map((u) => `${u.name}@latest`);
+      await fileManager.installDependencies(packages);
+      pluginSpinner.succeed(`Updated ${pluginUpdates.length} plugin(s)`);
+    } catch (err) {
+      pluginSpinner.fail("Failed to update plugins");
+      logger.error(err instanceof Error ? err.message : String(err));
+    }
+  }
+  const commandsSpinner = ora3("Updating bridge commands...").start();
+  try {
+    await fileManager.copyCommands();
+    commandsSpinner.succeed("Bridge commands updated");
+  } catch (_err) {
+    commandsSpinner.warn("Could not update bridge commands");
+  }
+  console.log();
+  logger.success("Update complete!");
+  logger.info("Restart OpenCode to use the updated version.");
+}
+
+// src/cli/index.ts
+var program = new Command();
+program.name("opencode-athena").description(
+  `${chalk3.cyan(DISPLAY_NAME)} - ${TAGLINE}
+Unified oh-my-opencode + BMAD METHOD toolkit for OpenCode`
+).version(VERSION);
+program.command("install").description("Install and configure OpenCode Athena").option(
+  "-p, --preset <preset>",
+  "Use a preset configuration (minimal, standard, enterprise, solo-quick)",
+  "standard"
+).option("-y, --yes", "Skip confirmation prompts", false).option("--advanced", "Show advanced configuration options", false).option("--global", "Install globally (default)", true).option("--local", "Install to current project only", false).option("--list-presets", "List available presets and exit", false).action(async (options) => {
+  if (options.listPresets) {
+    displayPresets();
+    return;
+  }
+  await install(options);
+});
+program.command("update").description("Update OpenCode Athena to latest version").option("--check", "Check for updates without installing", false).action(update);
+program.command("doctor").description("Diagnose and fix common issues").option("--fix", "Automatically fix issues", false).action(doctor);
+program.command("uninstall").description("Remove OpenCode Athena").option("--keep-config", "Keep configuration files", false).option("--keep-deps", "Keep npm dependencies", false).action(uninstall);
+program.command("info").description("Show current configuration and status").action(info);
+function displayPresets() {
+  console.log(chalk3.bold.cyan("\nAvailable Presets:\n"));
+  const presets = listPresets();
+  for (const preset of presets) {
+    console.log(chalk3.bold(`  ${preset.name}`));
+    console.log(chalk3.gray(`    ${preset.description}`));
+    console.log();
+  }
+  console.log(chalk3.gray("Usage: opencode-athena install --preset <name>"));
+  console.log(chalk3.gray("       opencode-athena install --preset standard --yes\n"));
+}
+program.parse();
+//# sourceMappingURL=index.js.map
+//# sourceMappingURL=index.js.map