opencode-athena 0.5.0 → 0.6.0

package/dist/cli/index.js

@@ -2,16 +2,17 @@
 import { join, dirname } from 'path';
 import { fileURLToPath } from 'url';
 import { confirm, select, checkbox } from '@inquirer/prompts';
-import chalk3 from 'chalk';
+import chalk4 from 'chalk';
 import { Command } from 'commander';
+import { existsSync, readFileSync, copyFileSync, mkdirSync, writeFileSync } from 'fs';
 import { homedir } from 'os';
 import { exec, execSync } from 'child_process';
-import ora3 from 'ora';
-import { existsSync, readFileSync } from 'fs';
+import ora2 from 'ora';
 import { mkdir, writeFile, readdir, copyFile, rm } from 'fs/promises';
 import { promisify } from 'util';
 import 'yaml';
 import { z } from 'zod';
+import * as semver from 'semver';
 
 var __defProp = Object.defineProperty;
 var __getOwnPropNames = Object.getOwnPropertyNames;
@@ -424,7 +425,28 @@ init_esm_shims();
 
 // src/shared/constants.ts
 init_esm_shims();
-var VERSION = "0.0.1";
+function getPackageVersion() {
+  try {
+    const currentDir = dirname(fileURLToPath(import.meta.url));
+    const possiblePaths = [
+      join(currentDir, "..", "..", "package.json"),
+      join(currentDir, "..", "..", "..", "package.json")
+    ];
+    for (const pkgPath of possiblePaths) {
+      if (!existsSync(pkgPath)) continue;
+      const content = readFileSync(pkgPath, "utf-8");
+      try {
+        const pkg = JSON.parse(content);
+        if (pkg.version) return pkg.version;
+      } catch {
+      }
+    }
+    return "0.0.0";
+  } catch {
+    return "0.0.0";
+  }
+}
+var VERSION = getPackageVersion();
 var DISPLAY_NAME = "OpenCode Athena";
 var TAGLINE = "Strategic wisdom meets practical execution";
 var CONFIG_PATHS = {
@@ -676,39 +698,39 @@ var logger = {
    * Log an informational message
    */
   info: (message) => {
-    console.log(chalk3.blue("i"), message);
+    console.log(chalk4.blue("i"), message);
   },
   /**
    * Log a success message
    */
   success: (message) => {
-    console.log(chalk3.green("\u2713"), message);
+    console.log(chalk4.green("\u2713"), message);
   },
   /**
    * Log a warning message
    */
   warn: (message) => {
-    console.log(chalk3.yellow("!"), message);
+    console.log(chalk4.yellow("!"), message);
   },
   /**
    * Log an error message
    */
   error: (message) => {
-    console.log(chalk3.red("\u2716"), message);
+    console.log(chalk4.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);
+      console.log(chalk4.gray("[debug]"), message);
     }
   },
   /**
    * Log a step in a process
    */
   step: (step, total, message) => {
-    console.log(chalk3.cyan(`[${step}/${total}]`), message);
+    console.log(chalk4.cyan(`[${step}/${total}]`), message);
   },
   /**
    * Log a blank line
@@ -721,7 +743,7 @@ var logger = {
    */
   section: (title) => {
     console.log();
-    console.log(chalk3.bold(title));
+    console.log(chalk4.bold(title));
     console.log();
   },
   /**
@@ -729,21 +751,21 @@ var logger = {
    */
   keyValue: (key, value, indent = 0) => {
     const padding = "  ".repeat(indent);
-    console.log(`${padding}${chalk3.gray(`${key}:`)} ${value}`);
+    console.log(`${padding}${chalk4.gray(`${key}:`)} ${value}`);
   },
   /**
    * Log a list item
    */
   listItem: (item, indent = 0) => {
     const padding = "  ".repeat(indent);
-    console.log(`${padding}${chalk3.gray("-")} ${item}`);
+    console.log(`${padding}${chalk4.gray("-")} ${item}`);
   },
   /**
    * Display the Athena banner
    */
   banner: () => {
     console.log(
-      chalk3.cyan(`
+      chalk4.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
@@ -759,7 +781,7 @@ var logger = {
   successBanner: (message) => {
     const line = "\u2550".repeat(message.length + 4);
     console.log(
-      chalk3.green(`
+      chalk4.green(`
 \u2554${line}\u2557
 \u2551  ${message}  \u2551
 \u255A${line}\u255D
@@ -1119,7 +1141,7 @@ async function doctor(options) {
     status: omoInstalled.installed ? "pass" : "fail",
     message: omoInstalled.installed ? `Version ${omoInstalled.version}` : "Not installed",
     fix: async () => {
-      const spinner = ora3("Installing oh-my-opencode...").start();
+      const spinner = ora2("Installing oh-my-opencode...").start();
       try {
         await fileManager.installDependencies(["oh-my-opencode"]);
         spinner.succeed("oh-my-opencode installed");
@@ -1135,7 +1157,7 @@ async function doctor(options) {
     status: commandsDirExists ? "pass" : "warn",
     message: commandsDirExists ? "Exists" : "Not found",
     fix: async () => {
-      const spinner = ora3("Creating commands directory...").start();
+      const spinner = ora2("Creating commands directory...").start();
       try {
         await fileManager.ensureDir(CONFIG_PATHS.commandsDir);
         await fileManager.copyCommands();
@@ -1177,16 +1199,16 @@ async function doctor(options) {
     switch (result.status) {
       case "pass":
         icon = "\u2713";
-        color = chalk3.green;
+        color = chalk4.green;
         break;
       case "warn":
         icon = "!";
-        color = chalk3.yellow;
+        color = chalk4.yellow;
         hasWarnings = true;
         break;
       case "fail":
         icon = "\u2716";
-        color = chalk3.red;
+        color = chalk4.red;
         hasFailures = true;
         if (result.fix) {
           fixableIssues.push(result);
@@ -1214,7 +1236,7 @@ async function doctor(options) {
       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.`);
+      logger.info(`Run ${chalk4.cyan("opencode-athena doctor --fix")} to attempt automatic fixes.`);
     }
   } else if (hasWarnings) {
     logger.warn("Some checks have warnings, but Athena should work.");
@@ -1231,26 +1253,26 @@ async function info() {
   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.`);
+    logger.info(`Run ${chalk4.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");
+  const nodeStatus = prereqs.node.installed ? prereqs.node.compatible ? chalk4.green("\u2713") : chalk4.yellow("!") : chalk4.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");
+  const opencodeStatus = prereqs.opencode.installed ? prereqs.opencode.compatible ? chalk4.green("\u2713") : chalk4.yellow("!") : chalk4.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");
+  const claudeStatus = athenaConfig.subscriptions.claude.enabled ? chalk4.green("enabled") : chalk4.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");
+  const openaiStatus = athenaConfig.subscriptions.openai.enabled ? chalk4.green("enabled") : chalk4.gray("disabled");
   logger.keyValue("OpenAI", openaiStatus);
-  const googleStatus = athenaConfig.subscriptions.google.enabled ? chalk3.green("enabled") : chalk3.gray("disabled");
+  const googleStatus = athenaConfig.subscriptions.google.enabled ? chalk4.green("enabled") : chalk4.gray("disabled");
   logger.keyValue(
     "Google",
     `${googleStatus}${athenaConfig.subscriptions.google.authMethod !== "none" ? ` (${athenaConfig.subscriptions.google.authMethod})` : ""}`
@@ -1284,14 +1306,14 @@ async function info() {
     { name: "LSP Tools", enabled: features.lspTools }
   ];
   for (const feature of featureList) {
-    const status = feature.enabled ? chalk3.green("on") : chalk3.gray("off");
+    const status = feature.enabled ? chalk4.green("on") : chalk4.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.keyValue("context7", mcps.context7 ? chalk4.green("on") : chalk4.gray("off"));
+  logger.keyValue("exa", mcps.exa ? chalk4.green("on") : chalk4.gray("off"));
+  logger.keyValue("grep_app", mcps.grepApp ? chalk4.green("on") : chalk4.gray("off"));
   logger.section("Installed Plugins");
   const plugins = await getInstalledPlugins();
   if (Object.keys(plugins).length === 0) {
@@ -2037,6 +2059,273 @@ async function gatherAdvanced(defaults) {
   };
 }
 
+// src/cli/utils/config-loader.ts
+init_esm_shims();
+function loadExistingConfigs() {
+  const result = {
+    athena: null,
+    athenaValid: false,
+    athenaVersion: null,
+    omo: null,
+    omoValid: false
+  };
+  if (existsSync(CONFIG_PATHS.globalAthenaConfig)) {
+    try {
+      const content = readFileSync(CONFIG_PATHS.globalAthenaConfig, "utf-8");
+      result.athena = JSON.parse(content);
+      result.athenaVersion = result.athena?.version || "0.0.1";
+      result.athenaValid = result.athena !== null && typeof result.athena.version === "string";
+    } catch {
+    }
+  }
+  if (existsSync(CONFIG_PATHS.globalOmoConfig)) {
+    try {
+      const content = readFileSync(CONFIG_PATHS.globalOmoConfig, "utf-8");
+      result.omo = JSON.parse(content);
+      result.omoValid = result.omo !== null;
+    } catch {
+    }
+  }
+  return result;
+}
+function extractSubscriptions(athena) {
+  try {
+    const subs = athena.subscriptions;
+    if (!subs) return null;
+    const claude = subs.claude;
+    const openai = subs.openai;
+    const google = subs.google;
+    const copilot = subs.githubCopilot;
+    return {
+      hasClaude: claude?.enabled === true,
+      claudeTier: claude?.tier || "none",
+      hasOpenAI: openai?.enabled === true,
+      hasGoogle: google?.enabled === true,
+      googleAuth: google?.authMethod || "none",
+      hasGitHubCopilot: copilot?.enabled === true,
+      copilotPlan: copilot?.plan || "none",
+      copilotEnabledModels: copilot?.enabledModels || []
+    };
+  } catch {
+    return null;
+  }
+}
+function extractModels(athena) {
+  try {
+    const models = athena.models;
+    if (!models) return null;
+    return {
+      sisyphus: models.sisyphus || "",
+      oracle: models.oracle || "",
+      librarian: models.librarian || "",
+      frontend: models.frontend,
+      documentWriter: models.documentWriter,
+      multimodalLooker: models.multimodalLooker,
+      explore: models.explore,
+      settings: models.settings,
+      custom: models.custom
+    };
+  } catch {
+    return null;
+  }
+}
+function extractMethodology(athena) {
+  try {
+    const bmad = athena.bmad;
+    if (!bmad) return null;
+    return {
+      defaultTrack: bmad.defaultTrack || "bmad-method",
+      autoStatusUpdate: bmad.autoStatusUpdate !== false
+    };
+  } catch {
+    return null;
+  }
+}
+function extractFeatures(athena) {
+  try {
+    const features = athena.features;
+    const mcps = athena.mcps;
+    if (!features) return null;
+    const enabledFeatures = [];
+    if (features.autoStatus) enabledFeatures.push("auto-status");
+    if (features.parallelExecution) enabledFeatures.push("parallel");
+    if (features.notifications) enabledFeatures.push("notifications");
+    if (features.contextMonitor) enabledFeatures.push("context-monitor");
+    if (features.commentChecker) enabledFeatures.push("comment-checker");
+    if (features.lspTools) enabledFeatures.push("lsp-tools");
+    const mcpList = [];
+    if (mcps?.context7) mcpList.push("context7");
+    if (mcps?.exa) mcpList.push("exa");
+    if (mcps?.grepApp) mcpList.push("grep_app");
+    return {
+      enabledFeatures,
+      mcps: mcpList
+    };
+  } catch {
+    return null;
+  }
+}
+function extractAdvanced(athena) {
+  try {
+    const bmad = athena.bmad;
+    return {
+      parallelStoryLimit: bmad?.parallelStoryLimit || 3,
+      experimental: []
+    };
+  } catch {
+    return null;
+  }
+}
+function detectNewFeatures(existingAthena) {
+  const newFeatures = [];
+  const features = existingAthena.features;
+  if (features?.autoGitOperations === void 0) {
+    newFeatures.push("autoGitOperations");
+  }
+  return newFeatures;
+}
+
+// src/cli/utils/config-merger.ts
+init_esm_shims();
+function deepMerge(baseObj, newObj) {
+  const result = { ...baseObj };
+  for (const [key, value] of Object.entries(newObj)) {
+    if (value !== null && typeof value === "object" && !Array.isArray(value) && typeof result[key] === "object" && result[key] !== null && !Array.isArray(result[key])) {
+      result[key] = deepMerge(
+        result[key],
+        value
+      );
+    } else {
+      result[key] = value;
+    }
+  }
+  return result;
+}
+function mergeConfigs(options) {
+  const { existingAthena, fullAnswers } = options;
+  const freshAthena = generateAthenaConfig(fullAnswers);
+  const freshOmo = generateOmoConfig(fullAnswers);
+  const mergedAthena = deepMerge(existingAthena, freshAthena);
+  mergedAthena.version = VERSION;
+  return {
+    athena: mergedAthena,
+    omo: freshOmo
+  };
+}
+function createBackups() {
+  const timestamp = (/* @__PURE__ */ new Date()).toISOString().replace(/[:.]/g, "-");
+  const result = {
+    athenaBackup: null,
+    omoBackup: null,
+    opencodeBackup: null
+  };
+  if (existsSync(CONFIG_PATHS.globalAthenaConfig)) {
+    result.athenaBackup = `${CONFIG_PATHS.globalAthenaConfig}.backup-${timestamp}`;
+    copyFileSync(CONFIG_PATHS.globalAthenaConfig, result.athenaBackup);
+  }
+  if (existsSync(CONFIG_PATHS.globalOmoConfig)) {
+    result.omoBackup = `${CONFIG_PATHS.globalOmoConfig}.backup-${timestamp}`;
+    copyFileSync(CONFIG_PATHS.globalOmoConfig, result.omoBackup);
+  }
+  if (existsSync(CONFIG_PATHS.globalOpencodeConfig)) {
+    result.opencodeBackup = `${CONFIG_PATHS.globalOpencodeConfig}.backup-${timestamp}`;
+    copyFileSync(CONFIG_PATHS.globalOpencodeConfig, result.opencodeBackup);
+  }
+  return result;
+}
+function writeMergedConfigs(configs) {
+  const athenaDir = dirname(CONFIG_PATHS.globalAthenaConfig);
+  if (!existsSync(athenaDir)) {
+    mkdirSync(athenaDir, { recursive: true });
+  }
+  writeFileSync(CONFIG_PATHS.globalAthenaConfig, JSON.stringify(configs.athena, null, 2), "utf-8");
+  writeFileSync(CONFIG_PATHS.globalOmoConfig, JSON.stringify(configs.omo, null, 2), "utf-8");
+}
+
+// src/cli/utils/migrations/index.ts
+init_esm_shims();
+
+// src/cli/utils/migrations/types.ts
+init_esm_shims();
+
+// src/cli/utils/migrations/migrations.ts
+init_esm_shims();
+var MIGRATIONS = [
+  {
+    fromVersion: "0.0.1",
+    toVersion: "0.1.0",
+    description: "Initial version normalization",
+    migrateAthena: (config) => config
+  },
+  {
+    fromVersion: "0.4.0",
+    toVersion: "0.5.0",
+    description: "Add autoGitOperations feature flag",
+    migrateAthena: (config) => {
+      const features = config.features || {};
+      if (features.autoGitOperations === void 0) {
+        features.autoGitOperations = false;
+      }
+      return { ...config, features };
+    }
+  }
+];
+
+// src/cli/utils/migrations/runner.ts
+init_esm_shims();
+function migrateConfigs(athenaConfig, omoConfig, fromVersion) {
+  const targetVersion = VERSION;
+  const migrationsApplied = [];
+  const breakingChangeWarnings = [];
+  let hasBreakingChanges = false;
+  let currentAthena = { ...athenaConfig };
+  let currentOmo = { ...omoConfig };
+  const normalizedFrom = semver.valid(semver.coerce(fromVersion)) || "0.0.0";
+  const normalizedTarget = semver.valid(semver.coerce(targetVersion)) || VERSION;
+  const sortedMigrations = [...MIGRATIONS].sort((a, b) => {
+    const aVersion = semver.valid(semver.coerce(a.fromVersion)) || "0.0.0";
+    const bVersion = semver.valid(semver.coerce(b.fromVersion)) || "0.0.0";
+    return semver.compare(aVersion, bVersion);
+  });
+  for (const migration of sortedMigrations) {
+    const migrationFrom = semver.valid(semver.coerce(migration.fromVersion)) || "0.0.0";
+    const migrationTo = semver.valid(semver.coerce(migration.toVersion)) || "0.0.0";
+    if (semver.gt(migrationFrom, normalizedFrom)) continue;
+    if (semver.lte(migrationTo, normalizedFrom)) continue;
+    if (semver.gt(migrationTo, normalizedTarget)) continue;
+    if (migration.migrateAthena) {
+      currentAthena = migration.migrateAthena(currentAthena);
+    }
+    if (migration.migrateOmo) {
+      currentOmo = migration.migrateOmo(currentOmo);
+    }
+    migrationsApplied.push(
+      `${migration.fromVersion} \u2192 ${migration.toVersion}: ${migration.description}`
+    );
+    if (isBreakingMigration(migration)) {
+      hasBreakingChanges = true;
+      breakingChangeWarnings.push(
+        `Migration ${migration.fromVersion} \u2192 ${migration.toVersion} contains breaking changes: ${migration.description}`
+      );
+    }
+  }
+  currentAthena.version = targetVersion;
+  return {
+    fromVersion,
+    toVersion: targetVersion,
+    migrationsApplied,
+    athenaConfig: currentAthena,
+    omoConfig: currentOmo,
+    hasBreakingChanges,
+    breakingChangeWarnings
+  };
+}
+function isBreakingMigration(migration) {
+  const fromMajor = semver.major(semver.coerce(migration.fromVersion) || "0.0.0");
+  const toMajor = semver.major(semver.coerce(migration.toVersion) || "0.0.0");
+  return toMajor > fromMajor;
+}
+
 // src/cli/utils/preset-loader.ts
 init_esm_shims();
 var PRESET_NAMES = ["minimal", "standard", "enterprise", "solo-quick"];
@@ -2203,9 +2492,168 @@ function formatPresetSummary(preset, name) {
 }
 
 // src/cli/commands/install.ts
+function detectInstallMode(options, configs) {
+  if (options.reconfigure) {
+    return { mode: "reconfigure" };
+  }
+  if (!configs.athena) {
+    return { mode: "fresh" };
+  }
+  return {
+    mode: "upgrade",
+    existingVersion: configs.athenaVersion || "0.0.1",
+    configs
+  };
+}
+async function runUpgradeFlow(configs, existingVersion, options) {
+  const { athena, omo } = configs;
+  logger.section("Upgrading Configuration");
+  console.log(chalk4.cyan(`
+Current version: ${existingVersion}`));
+  console.log(chalk4.cyan(`New version: ${VERSION}
+`));
+  if (!options.yes) {
+    const proceed = await confirm({
+      message: "Upgrade existing installation?",
+      default: true
+    });
+    if (!proceed) {
+      logger.info("Upgrade cancelled.");
+      process.exit(0);
+    }
+  }
+  const spinner = ora2("Creating backup...").start();
+  const backups = createBackups();
+  const backupCount = [backups.athenaBackup, backups.omoBackup, backups.opencodeBackup].filter(
+    Boolean
+  ).length;
+  spinner.succeed(`Created ${backupCount} backup file(s)`);
+  const migrationSpinner = ora2("Applying migrations...").start();
+  const migrationResult = migrateConfigs(athena || {}, omo || {}, existingVersion);
+  if (migrationResult.migrationsApplied.length > 0) {
+    migrationSpinner.succeed(`Applied ${migrationResult.migrationsApplied.length} migration(s)`);
+    for (const migration of migrationResult.migrationsApplied) {
+      console.log(chalk4.gray(`  \u2022 ${migration}`));
+    }
+  } else {
+    migrationSpinner.succeed("No migrations needed");
+  }
+  if (migrationResult.hasBreakingChanges && !options.yes) {
+    console.log(chalk4.yellow("\nBreaking changes detected:"));
+    for (const warning of migrationResult.breakingChangeWarnings) {
+      console.log(chalk4.yellow(`  \u26A0 ${warning}`));
+    }
+    const continueUpgrade = await confirm({
+      message: "Continue with upgrade despite breaking changes?",
+      default: false
+    });
+    if (!continueUpgrade) {
+      logger.info("Upgrade cancelled. Your backup files are preserved.");
+      process.exit(0);
+    }
+  }
+  const existingSubscriptions = extractSubscriptions(migrationResult.athenaConfig);
+  const existingModels = extractModels(migrationResult.athenaConfig);
+  const existingMethodology = extractMethodology(migrationResult.athenaConfig);
+  const existingFeatures = extractFeatures(migrationResult.athenaConfig);
+  const existingAdvanced = extractAdvanced(migrationResult.athenaConfig);
+  logger.section("Preserved Configuration");
+  if (existingSubscriptions) {
+    console.log(chalk4.bold("Subscriptions:"));
+    if (existingSubscriptions.hasClaude)
+      console.log(chalk4.green(`  \u2713 Claude (${existingSubscriptions.claudeTier})`));
+    if (existingSubscriptions.hasOpenAI) console.log(chalk4.green("  \u2713 OpenAI"));
+    if (existingSubscriptions.hasGoogle)
+      console.log(chalk4.green(`  \u2713 Google (${existingSubscriptions.googleAuth})`));
+    if (existingSubscriptions.hasGitHubCopilot)
+      console.log(chalk4.green(`  \u2713 GitHub Copilot (${existingSubscriptions.copilotPlan})`));
+  }
+  if (existingModels) {
+    console.log(chalk4.bold("\nModel Assignments:"));
+    console.log(chalk4.green(`  \u2713 Sisyphus: ${existingModels.sisyphus}`));
+    console.log(chalk4.green(`  \u2713 Oracle: ${existingModels.oracle}`));
+    console.log(chalk4.green(`  \u2713 Librarian: ${existingModels.librarian}`));
+  }
+  console.log();
+  const newFeatures = detectNewFeatures(migrationResult.athenaConfig);
+  const updatedFeatures = existingFeatures;
+  if (newFeatures.length > 0 && !options.yes) {
+    logger.section("New Features Available");
+    for (const feature of newFeatures) {
+      if (feature === "autoGitOperations") {
+        const enable = await confirm({
+          message: "Enable automatic git operations? (commits, pushes by agents)",
+          default: false
+        });
+        if (updatedFeatures) {
+          if (enable) {
+            updatedFeatures.enabledFeatures.push("auto-git");
+          }
+        }
+      }
+    }
+  }
+  let finalSubscriptions = existingSubscriptions;
+  if (!options.yes) {
+    const changeSubscriptions = await confirm({
+      message: "Do you want to modify your LLM subscriptions?",
+      default: false
+    });
+    if (changeSubscriptions) {
+      logger.section("LLM Subscriptions");
+      finalSubscriptions = await gatherSubscriptions();
+    }
+  }
+  if (!finalSubscriptions) {
+    logger.error("Could not extract subscription information from existing config.");
+    logger.info("Please run with --reconfigure to set up from scratch.");
+    process.exit(1);
+  }
+  const fullAnswers = {
+    subscriptions: finalSubscriptions,
+    models: existingModels || {
+      sisyphus: "",
+      oracle: "",
+      librarian: ""
+    },
+    methodology: existingMethodology || {
+      defaultTrack: "bmad-method",
+      autoStatusUpdate: true
+    },
+    features: updatedFeatures || {
+      enabledFeatures: [],
+      mcps: []
+    },
+    advanced: existingAdvanced || {
+      parallelStoryLimit: 3,
+      experimental: []
+    },
+    installLocation: options.local ? "local" : "global"
+  };
+  const merged = mergeConfigs({
+    existingAthena: migrationResult.athenaConfig,
+    fullAnswers
+  });
+  const writeSpinner = ora2("Writing configuration...").start();
+  writeMergedConfigs(merged);
+  writeSpinner.succeed("Configuration files updated");
+  const fileManager = new FileManager();
+  const commandsSpinner = ora2("Updating bridge commands...").start();
+  const copiedCommands = await fileManager.copyCommands();
+  commandsSpinner.succeed(`Updated ${copiedCommands.length} bridge commands`);
+  logger.successBanner(`UPGRADED TO OPENCODE ATHENA ${VERSION}!`);
+  if (backups.athenaBackup || backups.omoBackup || backups.opencodeBackup) {
+    console.log(chalk4.gray("\nBackups saved:"));
+    if (backups.athenaBackup) console.log(chalk4.gray(`  \u2022 ${backups.athenaBackup}`));
+    if (backups.omoBackup) console.log(chalk4.gray(`  \u2022 ${backups.omoBackup}`));
+    if (backups.opencodeBackup) console.log(chalk4.gray(`  \u2022 ${backups.opencodeBackup}`));
+  }
+  console.log(chalk4.gray("\nRestart OpenCode to use the upgraded configuration."));
+  console.log();
+}
 async function install(options) {
   logger.banner();
-  const spinner = ora3("Checking prerequisites...").start();
+  const spinner = ora2("Checking prerequisites...").start();
   const prereqs = await checkPrerequisites();
   if (!prereqs.node.installed) {
     spinner.fail("Node.js not found");
@@ -2225,15 +2673,14 @@ async function install(options) {
   } 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);
-    }
+  const existingConfigs = loadExistingConfigs();
+  const modeResult = detectInstallMode(options, existingConfigs);
+  if (modeResult.mode === "upgrade" && modeResult.configs && modeResult.existingVersion) {
+    await runUpgradeFlow(modeResult.configs, modeResult.existingVersion, options);
+    return;
+  }
+  if (modeResult.mode === "reconfigure") {
+    logger.info("Reconfiguring from scratch (--reconfigure flag)");
   }
   let preset = null;
   let presetDefaults = null;
@@ -2268,14 +2715,14 @@ async function install(options) {
   if (preset && presetDefaults && presetName) {
     const modelWarnings = validatePresetModels(presetDefaults.models, subscriptions);
     if (modelWarnings.length > 0) {
-      console.log(chalk3.yellow("\nPreset model compatibility warnings:"));
+      console.log(chalk4.yellow("\nPreset model compatibility warnings:"));
       for (const warning of modelWarnings) {
-        console.log(chalk3.yellow(`  - ${warning}`));
+        console.log(chalk4.yellow(`  - ${warning}`));
       }
       console.log();
     }
-    console.log(chalk3.bold("\nPreset Configuration:\n"));
-    console.log(chalk3.gray(formatPresetSummary(preset, presetName)));
+    console.log(chalk4.bold("\nPreset Configuration:\n"));
+    console.log(chalk4.gray(formatPresetSummary(preset, presetName)));
     console.log();
     if (options.yes) {
       shouldCustomize = false;
@@ -2345,10 +2792,10 @@ async function install(options) {
   };
   const generator = new ConfigGenerator(answers);
   const files = await generator.generate();
-  console.log(chalk3.bold("Files to be created/modified:\n"));
+  console.log(chalk4.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}`));
+    const action = file.exists ? chalk4.yellow("update") : chalk4.green("create");
+    console.log(chalk4.gray(`  [${action}] ${file.path}`));
   }
   console.log();
   if (!options.yes) {
@@ -2361,7 +2808,7 @@ async function install(options) {
       process.exit(0);
     }
   }
-  const installSpinner = ora3("Installing OpenCode Athena...").start();
+  const installSpinner = ora2("Installing OpenCode Athena...").start();
   try {
     const fileManager = new FileManager(generator.getConfigDir());
     await fileManager.writeFiles(files);
@@ -2418,30 +2865,30 @@ function getValidModelOrFirst(modelId, availableModels) {
 function printNextSteps(subscriptions) {
   const steps = [];
   if (subscriptions.hasClaude) {
-    steps.push(`Run: ${chalk3.cyan("opencode auth login")} -> Select Anthropic -> Claude Pro/Max`);
+    steps.push(`Run: ${chalk4.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`);
+    steps.push(`Run: ${chalk4.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`);
+    steps.push(`Run: ${chalk4.cyan("opencode auth login")} -> Select Google -> OAuth with Google`);
   }
   if (subscriptions.hasGitHubCopilot) {
-    steps.push(`Run: ${chalk3.cyan("opencode auth login")} -> Select GitHub Copilot`);
+    steps.push(`Run: ${chalk4.cyan("opencode auth login")} -> Select GitHub Copilot`);
   }
   logger.successBanner("OPENCODE ATHENA INSTALLED SUCCESSFULLY!");
-  console.log(chalk3.bold("Next Steps:\n"));
+  console.log(chalk4.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(chalk4.bold("\nThen start OpenCode and try:\n"));
+  console.log(`  ${chalk4.cyan("/athena-dev")}      Implement a BMAD story with Sisyphus`);
+  console.log(`  ${chalk4.cyan("/athena-status")}   Check sprint status`);
+  console.log(`  ${chalk4.cyan("/athena-info")}     View toolkit configuration`);
+  console.log(chalk4.bold("\nFor BMAD project setup:\n"));
+  console.log(`  ${chalk4.cyan("npx bmad-method@alpha install")}   Install BMAD in your project`);
   console.log(
-    chalk3.gray("\nDocumentation: https://github.com/ZebulonRouseFrantzich/opencode-athena")
+    chalk4.gray("\nDocumentation: https://github.com/ZebulonRouseFrantzich/opencode-athena")
   );
   console.log();
 }
@@ -2462,7 +2909,7 @@ async function uninstall(options) {
   }
   logger.section("Uninstalling OpenCode Athena");
   const fileManager = new FileManager();
-  const commandsSpinner = ora3("Removing bridge commands...").start();
+  const commandsSpinner = ora2("Removing bridge commands...").start();
   try {
     const removedCommands = await fileManager.removeCommands();
     if (removedCommands.length > 0) {
@@ -2475,7 +2922,7 @@ async function uninstall(options) {
     logger.error(err instanceof Error ? err.message : String(err));
   }
   if (!options.keepConfig) {
-    const configSpinner = ora3("Removing configuration files...").start();
+    const configSpinner = ora2("Removing configuration files...").start();
     try {
       const removedFiles = await fileManager.removeConfigFiles();
       if (removedFiles.length > 0) {
@@ -2490,7 +2937,7 @@ async function uninstall(options) {
   } else {
     logger.info("Keeping configuration files (--keep-config)");
   }
-  const opencodeSpinner = ora3("Updating opencode.json...").start();
+  const opencodeSpinner = ora2("Updating opencode.json...").start();
   try {
     const updated = await fileManager.removeFromOpencodeConfig();
     if (updated) {
@@ -2503,7 +2950,7 @@ async function uninstall(options) {
     logger.error(err instanceof Error ? err.message : String(err));
   }
   if (!options.keepDeps) {
-    const depsSpinner = ora3("Removing npm dependencies...").start();
+    const depsSpinner = ora2("Removing npm dependencies...").start();
     try {
       const packagesToRemove = [
         "oh-my-opencode",
@@ -2522,7 +2969,7 @@ async function uninstall(options) {
   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.`);
+    logger.info(`Run ${chalk4.cyan("opencode-athena install")} to reinstall with existing config.`);
   }
   console.log();
 }
@@ -2550,7 +2997,7 @@ async function checkPackageUpdate(name, currentVersion) {
 async function update(options) {
   logger.banner();
   logger.section("Checking for Updates");
-  const spinner = ora3("Checking package versions...").start();
+  const spinner = ora2("Checking package versions...").start();
   const installedPlugins = await getInstalledPlugins();
   const packagesToCheck = [
     "oh-my-opencode",
@@ -2578,7 +3025,7 @@ async function update(options) {
   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);
+    const status = pkg.updateAvailable ? chalk4.yellow(`${pkg.current} -> ${pkg.latest}`) : chalk4.green(pkg.current);
     logger.keyValue(pkg.name, status);
   }
   console.log();
@@ -2589,7 +3036,7 @@ async function update(options) {
   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.`);
+    logger.info(`Run ${chalk4.cyan("opencode-athena update")} (without --check) to apply updates.`);
     return;
   }
   const proceed = await confirm({
@@ -2604,7 +3051,7 @@ async function update(options) {
   const fileManager = new FileManager();
   const athenaUpdate = updatesAvailable.find((u) => u.name === "opencode-athena");
   if (athenaUpdate) {
-    const athenaSpinner = ora3("Updating opencode-athena...").start();
+    const athenaSpinner = ora2("Updating opencode-athena...").start();
     try {
       await execAsync3("npm install -g opencode-athena@latest");
       athenaSpinner.succeed(`opencode-athena updated to ${athenaUpdate.latest}`);
@@ -2615,7 +3062,7 @@ async function update(options) {
   }
   const pluginUpdates = updatesAvailable.filter((u) => u.name !== "opencode-athena");
   if (pluginUpdates.length > 0) {
-    const pluginSpinner = ora3("Updating plugins...").start();
+    const pluginSpinner = ora2("Updating plugins...").start();
     try {
       const packages = pluginUpdates.map((u) => `${u.name}@latest`);
       await fileManager.installDependencies(packages);
@@ -2625,7 +3072,7 @@ async function update(options) {
       logger.error(err instanceof Error ? err.message : String(err));
     }
   }
-  const commandsSpinner = ora3("Updating bridge commands...").start();
+  const commandsSpinner = ora2("Updating bridge commands...").start();
   try {
     await fileManager.copyCommands();
     commandsSpinner.succeed("Bridge commands updated");
@@ -2640,34 +3087,37 @@ async function update(options) {
 // src/cli/index.ts
 var program = new Command();
 program.name("opencode-athena").description(
-  `${chalk3.cyan(DISPLAY_NAME)} - ${TAGLINE}
+  `${chalk4.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) => {
+).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).option("--reconfigure", "Force full reconfiguration (ignore existing config)", false).action(async (options) => {
   if (options.listPresets) {
     displayPresets();
     return;
   }
   await install(options);
 });
+program.command("upgrade").description("Upgrade OpenCode Athena configuration to latest version").option("-y, --yes", "Skip confirmation prompts", false).action(async (options) => {
+  await install({ ...options, preset: "none", advanced: false, global: true, local: false });
+});
 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"));
+  console.log(chalk4.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(chalk4.bold(`  ${preset.name}`));
+    console.log(chalk4.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"));
+  console.log(chalk4.gray("Usage: opencode-athena install --preset <name>"));
+  console.log(chalk4.gray("       opencode-athena install --preset standard --yes\n"));
 }
 program.parse();
 //# sourceMappingURL=index.js.map