opencode-athena 0.8.1-beta.2 → 0.8.1-beta.3

package/README.md

@@ -393,7 +393,7 @@ For full model capabilities, use direct provider subscriptions when possible.
 │  ┌─────────────────────────────────────────────────────────────────────┐   │
 │  │                         CLI Installer                                │   │
 │  │   npx opencode-athena install    npx opencode-athena doctor         │   │
-│  │   npx opencode-athena update     npx opencode-athena uninstall      │   │
+│  │   npx opencode-athena upgrade    npx opencode-athena uninstall      │   │
 │  └─────────────────────────────────────────────────────────────────────┘   │
 │                                                                              │
 │  ┌─────────────────────────────────────────────────────────────────────┐   │

package/dist/cli/index.js

@@ -7,7 +7,7 @@ import { Command } from 'commander';
 import { existsSync, readFileSync, mkdirSync, copyFileSync, unlinkSync, readdirSync, renameSync, writeFileSync } from 'fs';
 import { homedir } from 'os';
 import { exec, execSync } from 'child_process';
-import ora2 from 'ora';
+import ora4 from 'ora';
 import { mkdir, writeFile, readdir, copyFile, rm } from 'fs/promises';
 import { promisify } from 'util';
 import 'yaml';
@@ -1152,7 +1152,7 @@ async function doctor(options) {
     status: omoInstalled.installed ? "pass" : "fail",
     message: omoInstalled.installed ? `Version ${omoInstalled.version}` : "Not installed",
     fix: async () => {
-      const spinner = ora2("Installing oh-my-opencode...").start();
+      const spinner = ora4("Installing oh-my-opencode...").start();
       try {
         await fileManager.installDependencies(["oh-my-opencode"]);
         spinner.succeed("oh-my-opencode installed");
@@ -1168,7 +1168,7 @@ async function doctor(options) {
     status: commandsDirExists ? "pass" : "warn",
     message: commandsDirExists ? "Exists" : "Not found",
     fix: async () => {
-      const spinner = ora2("Creating commands directory...").start();
+      const spinner = ora4("Creating commands directory...").start();
       try {
         await fileManager.ensureDir(CONFIG_PATHS.commandsDir);
         await fileManager.copyCommands();
@@ -2583,7 +2583,7 @@ Current version: ${existingVersion}`));
       process.exit(0);
     }
   }
-  const spinner = ora2("Creating backup...").start();
+  const spinner = ora4("Creating backup...").start();
   const backups = createBackups();
   const backupCount = [backups.athenaBackup, backups.omoBackup, backups.opencodeBackup].filter(
     Boolean
@@ -2597,7 +2597,7 @@ Current version: ${existingVersion}`));
       moved.push(`${fileMigrationResult.backupsMoved} backup(s)`);
     console.log(chalk4.gray(`  Migrated ${moved.join(", ")} to new athena/ directory`));
   }
-  const migrationSpinner = ora2("Applying migrations...").start();
+  const migrationSpinner = ora4("Applying migrations...").start();
   const migrationResult = migrateConfigs(athena || {}, omo || {}, existingVersion);
   if (migrationResult.migrationsApplied.length > 0) {
     migrationSpinner.succeed(`Applied ${migrationResult.migrationsApplied.length} migration(s)`);
@@ -2702,11 +2702,18 @@ Current version: ${existingVersion}`));
     existingAthena: migrationResult.athenaConfig,
     fullAnswers
   });
-  const writeSpinner = ora2("Writing configuration...").start();
+  const writeSpinner = ora4("Writing configuration...").start();
   writeMergedConfigs(merged);
   writeSpinner.succeed("Configuration files updated");
   const fileManager = new FileManager();
-  const commandsSpinner = ora2("Updating bridge commands...").start();
+  const generator = new ConfigGenerator(fullAnswers);
+  const packages = generator.getRequiredPackages();
+  if (packages.length > 0) {
+    const installSpinner = ora4(`Installing packages: ${packages.join(", ")}...`).start();
+    await fileManager.installDependencies(packages);
+    installSpinner.succeed(`Installed ${packages.length} package(s)`);
+  }
+  const commandsSpinner = ora4("Updating bridge commands...").start();
   const copiedCommands = await fileManager.copyCommands();
   commandsSpinner.succeed(`Updated ${copiedCommands.length} bridge commands`);
   logger.successBanner(`UPGRADED TO OPENCODE ATHENA ${VERSION}!`);
@@ -2721,7 +2728,7 @@ Current version: ${existingVersion}`));
 }
 async function install(options) {
   logger.banner();
-  const spinner = ora2("Checking prerequisites...").start();
+  const spinner = ora4("Checking prerequisites...").start();
   const prereqs = await checkPrerequisites();
   if (!prereqs.node.installed) {
     spinner.fail("Node.js not found");
@@ -2876,7 +2883,7 @@ async function install(options) {
       process.exit(0);
     }
   }
-  const installSpinner = ora2("Installing OpenCode Athena...").start();
+  const installSpinner = ora4("Installing OpenCode Athena...").start();
   try {
     const fileManager = new FileManager(generator.getConfigDir());
     await fileManager.writeFiles(files);
@@ -2977,7 +2984,7 @@ async function uninstall(options) {
   }
   logger.section("Uninstalling OpenCode Athena");
   const fileManager = new FileManager();
-  const commandsSpinner = ora2("Removing bridge commands...").start();
+  const commandsSpinner = ora4("Removing bridge commands...").start();
   try {
     const removedCommands = await fileManager.removeCommands();
     if (removedCommands.length > 0) {
@@ -2990,7 +2997,7 @@ async function uninstall(options) {
     logger.error(err instanceof Error ? err.message : String(err));
   }
   if (!options.keepConfig) {
-    const configSpinner = ora2("Removing configuration files...").start();
+    const configSpinner = ora4("Removing configuration files...").start();
     try {
       const removedFiles = await fileManager.removeConfigFiles();
       if (removedFiles.length > 0) {
@@ -3005,7 +3012,7 @@ async function uninstall(options) {
   } else {
     logger.info("Keeping configuration files (--keep-config)");
   }
-  const opencodeSpinner = ora2("Updating opencode.json...").start();
+  const opencodeSpinner = ora4("Updating opencode.json...").start();
   try {
     const updated = await fileManager.removeFromOpencodeConfig();
     if (updated) {
@@ -3018,7 +3025,7 @@ async function uninstall(options) {
     logger.error(err instanceof Error ? err.message : String(err));
   }
   if (!options.keepDeps) {
-    const depsSpinner = ora2("Removing npm dependencies...").start();
+    const depsSpinner = ora4("Removing npm dependencies...").start();
     try {
       const packagesToRemove = [
         "oh-my-opencode",
@@ -3042,7 +3049,7 @@ async function uninstall(options) {
   console.log();
 }
 
-// src/cli/commands/update.ts
+// src/cli/commands/upgrade.ts
 init_esm_shims();
 var execAsync3 = promisify(exec);
 function detectReleaseChannel(version) {
@@ -3068,10 +3075,17 @@ async function checkPackageUpdate(name, currentVersion) {
     updateAvailable: hasUpdate
   };
 }
-async function update(options) {
+async function upgrade(options) {
   logger.banner();
+  const configs = loadExistingConfigs();
+  if (!configs.athena) {
+    logger.error("No existing Athena installation found.");
+    logger.info(`Run ${chalk4.cyan("opencode-athena install")} to install for the first time.`);
+    process.exit(1);
+  }
+  const existingVersion = configs.athenaVersion || "0.0.1";
   logger.section("Checking for Updates");
-  const spinner = ora2("Checking package versions...").start();
+  const spinner = ora4("Checking package versions...").start();
   const installedPlugins = await getInstalledPlugins();
   const packagesToCheck = [
     "oh-my-opencode",
@@ -3105,29 +3119,160 @@ async function update(options) {
     logger.keyValue(pkg.name, status);
   }
   console.log();
-  if (updatesAvailable.length === 0) {
+  if (updatesAvailable.length === 0 && existingVersion === VERSION) {
     logger.success("All packages are up to date!");
     return;
   }
-  logger.info(`${updatesAvailable.length} update(s) available`);
+  if (updatesAvailable.length > 0) {
+    logger.info(`${updatesAvailable.length} package update(s) available`);
+  }
+  const coercedExisting = semver__default.coerce(existingVersion);
+  const coercedTarget = semver__default.coerce(VERSION);
+  if (coercedExisting && coercedTarget && semver__default.lt(coercedExisting, coercedTarget)) {
+    logger.info(`Configuration upgrade needed: ${existingVersion} -> ${VERSION}`);
+  }
   if (options.check) {
     console.log();
-    logger.info(`Run ${chalk4.cyan("opencode-athena update")} (without --check) to apply updates.`);
+    logger.info(
+      `Run ${chalk4.cyan("opencode-athena upgrade")} (without --check) to apply upgrades.`
+    );
     return;
   }
-  const proceed = await confirm({
-    message: `Update ${updatesAvailable.length} package(s)?`,
-    default: true
-  });
-  if (!proceed) {
-    logger.info("Update cancelled.");
+  const actionCount = updatesAvailable.length + (existingVersion !== VERSION ? 1 : 0);
+  if (actionCount === 0) {
+    logger.success("Everything is up to date!");
     return;
   }
-  logger.section("Applying Updates");
+  if (!options.yes) {
+    const proceed = await confirm({
+      message: `Upgrade ${actionCount > 1 ? `${actionCount} item(s)` : "configuration"}?`,
+      default: true
+    });
+    if (!proceed) {
+      logger.info("Upgrade cancelled.");
+      process.exit(0);
+    }
+  }
+  logger.section("Upgrading Configuration");
+  console.log(chalk4.cyan(`
+Current version: ${existingVersion}`));
+  console.log(chalk4.cyan(`New version: ${VERSION}
+`));
+  const backupSpinner = ora4("Creating backup...").start();
+  const backups = createBackups();
+  const backupCount = [backups.athenaBackup, backups.omoBackup, backups.opencodeBackup].filter(
+    Boolean
+  ).length;
+  backupSpinner.succeed(`Created ${backupCount} backup file(s)`);
+  const fileMigrationResult = migrateLegacyFiles();
+  if (fileMigrationResult.stateFileMoved || fileMigrationResult.backupsMoved > 0) {
+    const moved = [];
+    if (fileMigrationResult.stateFileMoved) moved.push("state file");
+    if (fileMigrationResult.backupsMoved > 0)
+      moved.push(`${fileMigrationResult.backupsMoved} backup(s)`);
+    console.log(chalk4.gray(`  Migrated ${moved.join(", ")} to new athena/ directory`));
+  }
+  const migrationSpinner = ora4("Applying migrations...").start();
+  const migrationResult = migrateConfigs(configs.athena || {}, configs.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);
+  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 (enable) {
+          const migratedFeatures = migrationResult.athenaConfig.features;
+          migratedFeatures.autoGitOperations = true;
+        }
+      }
+    }
+  }
+  if (!existingSubscriptions) {
+    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: existingSubscriptions,
+    models: existingModels || {
+      sisyphus: "",
+      oracle: "",
+      librarian: ""
+    },
+    methodology: existingMethodology || {
+      defaultTrack: "bmad-method",
+      autoStatusUpdate: true
+    },
+    features: existingFeatures || {
+      enabledFeatures: [],
+      mcps: []
+    },
+    advanced: existingAdvanced || {
+      parallelStoryLimit: 3,
+      experimental: []
+    },
+    installLocation: "global"
+  };
+  const merged = mergeConfigs({
+    existingAthena: migrationResult.athenaConfig,
+    fullAnswers
+  });
+  const writeSpinner = ora4("Writing configuration...").start();
+  writeMergedConfigs(merged);
+  writeSpinner.succeed("Configuration files updated");
+  logger.section("Updating Packages");
   const fileManager = new FileManager();
   const athenaUpdate = updatesAvailable.find((u) => u.name === "opencode-athena");
   if (athenaUpdate) {
-    const athenaSpinner = ora2("Updating opencode-athena...").start();
+    const athenaSpinner = ora4("Updating opencode-athena...").start();
     try {
       const channel = detectReleaseChannel(VERSION);
       await fileManager.installDependencies([`opencode-athena@${channel}`]);
@@ -3136,10 +3281,25 @@ async function update(options) {
       athenaSpinner.fail("Failed to update opencode-athena");
       logger.error(err instanceof Error ? err.message : String(err));
     }
+  } else {
+    const generator = new ConfigGenerator(fullAnswers);
+    const packages = generator.getRequiredPackages();
+    const athenaPackage = packages.find((p) => p.startsWith("opencode-athena"));
+    if (athenaPackage) {
+      const athenaSpinner = ora4("Installing opencode-athena...").start();
+      try {
+        const channel = detectReleaseChannel(VERSION);
+        await fileManager.installDependencies([`opencode-athena@${channel}`]);
+        athenaSpinner.succeed("opencode-athena installed");
+      } catch (err) {
+        athenaSpinner.fail("Failed to install 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 = ora2("Updating plugins...").start();
+    const pluginSpinner = ora4("Updating plugins...").start();
     try {
       const packages = pluginUpdates.map((u) => `${u.name}@latest`);
       await fileManager.installDependencies(packages);
@@ -3148,17 +3308,37 @@ async function update(options) {
       pluginSpinner.fail("Failed to update plugins");
       logger.error(err instanceof Error ? err.message : String(err));
     }
+  } else {
+    const generator = new ConfigGenerator(fullAnswers);
+    const allPackages = generator.getRequiredPackages();
+    const pluginPackages = allPackages.filter((p) => !p.startsWith("opencode-athena"));
+    if (pluginPackages.length > 0) {
+      const pluginSpinner = ora4(`Installing plugins: ${pluginPackages.join(", ")}...`).start();
+      try {
+        await fileManager.installDependencies(pluginPackages);
+        pluginSpinner.succeed(`Installed ${pluginPackages.length} plugin(s)`);
+      } catch (err) {
+        pluginSpinner.fail("Failed to install plugins");
+        logger.error(err instanceof Error ? err.message : String(err));
+      }
+    }
   }
-  const commandsSpinner = ora2("Updating bridge commands...").start();
+  const commandsSpinner = ora4("Updating bridge commands...").start();
   try {
-    await fileManager.copyCommands();
-    commandsSpinner.succeed("Bridge commands updated");
+    const copiedCommands = await fileManager.copyCommands();
+    commandsSpinner.succeed(`Updated ${copiedCommands.length} bridge commands`);
   } catch (_err) {
     commandsSpinner.warn("Could not update 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();
-  logger.success("Update complete!");
-  logger.info("Restart OpenCode to use the updated version.");
 }
 
 // src/cli/index.ts
@@ -3178,10 +3358,7 @@ program.command("install").description("Install and configure OpenCode Athena").
   }
   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: void 0, 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("upgrade").description("Upgrade OpenCode Athena to latest version").option("--check", "Check for updates without installing", false).option("-y, --yes", "Skip confirmation prompts", false).action(upgrade);
 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);