refactor: complete forge→commando rename in lib/

- Rename Forge class to Commando in core.ts
- Update cli.ts to use Commando, fix error messages for cmdo
- Update all comments, variable names, log messages
- Fix forgeCmd → commandoCmd parameter names
- Update config-resolver.ts variable names
- Update module-resolver.ts and auto-install.ts references
- All 76 tests passing

🤖 Generated with [Claude Code](https://claude.com/claude-code)

Co-Authored-By: Claude Opus 4.5 <noreply@anthropic.com>

Author: jdillon

lib/auto-install.ts

@@ -26,9 +26,9 @@ export const RESTART_EXIT_CODE = 42;
 /**
  * Sync dependencies and handle restart if needed
  *
- * @param config - Forge configuration
+ * @param config - Commando configuration
  * @param commandoDir - Project .commando/ directory path
- * @param isRestarted - True if this is a restarted process (from --forge-restarted flag)
+ * @param isRestarted - True if this is a restarted process (from --commando-restarted flag)
  * @returns True if process should exit for restart
  * @throws Error if dependencies missing on restarted process
  */
@@ -130,7 +130,7 @@ export async function autoInstallDependencies(
       log.debug({ originalMessage: err.message }, 'Wrapping auto-install error');
       throw new Error(
         `Failed to install dependencies: ${err.message}\n\n` +
-          `Try running: forge module install`,
+          `Try running: cmdo module install`,
       );
     }
 

lib/builtins.ts

@@ -35,7 +35,7 @@ export const version: CommandoCommand = {
   execute: async () => {
     const info = await getVersion();
 
-    console.log('Forge Version Information:');
+    console.log('Commando Version Information:');
     console.log();
     console.log(`  Version:    ${info.version}`);
     console.log(`  Full:       ${info.semver}`);

lib/cli.ts

@@ -44,7 +44,7 @@ export async function main(): Promise<void> {
   if (cliArgs.includes('--version') || cliArgs.includes('-V')) {
     const { getVersionString } = await import('./version');
     const version = await getVersionString();
-    console.log(`commando version ${version}`);
+    console.log(`cmdo version ${version}`);
     process.exit(0);
   }
 
@@ -191,11 +191,11 @@ async function buildCLI(config: CommandoConfig): Promise<Command> {
     exit(1);
   });
 
-  // Initialize Forge and register commands
-  const { Forge } = await import("./core");
-  const forge = new Forge(config);
-  await forge.initialize(); // Throws ExitNotification if restart needed
-  await forge.registerCommands(program);
+  // Initialize Commando and register commands
+  const { Commando } = await import("./core");
+  const commando = new Commando(config);
+  await commando.initialize(); // Throws ExitNotification if restart needed
+  await commando.registerCommands(program);
 
   return program;
 }
@@ -239,7 +239,7 @@ function handleError(err: any): never {
     if (unknownCmd) {
       showCommanderError(`unknown command '${unknownCmd}'`);
     } else {
-      showCommanderError("unknown command. Run 'forge --help' to see available commands");
+      showCommanderError("unknown command. Run 'cmdo --help' to see available commands");
     }
   }
 
@@ -274,7 +274,7 @@ function handleError(err: any): never {
 function showCommanderError(message: string): never {
   const cleanMessage = message.replace(/^error:\s*/i, "");
   console.error(`ERROR: ${cleanMessage}`);
-  console.error(`Try 'forge --help' for more information.`);
+  console.error(`Try 'cmdo --help' for more information.`);
   runtimeExit(1);
 }
 

lib/command.ts

@@ -26,7 +26,7 @@ export type {
 } from './types';
 
 // ============================================================================
-// Core API - Forge utilities
+// Core API - Commando utilities
 // ============================================================================
 
 export { createLogger } from './logging/logger';

lib/commando-home.ts

@@ -31,8 +31,8 @@ export function getCommandoHomePath(): string {
 }
 
 /**
- * Get the node_modules directory for Forge
- * This is where Forge looks for installed modules
+ * Get the node_modules directory for Commando
+ * This is where Commando looks for installed modules
  *
  * Derived from COMMANDO_HOME/node_modules
  */
@@ -53,7 +53,7 @@ export async function ensureCommandoHome(): Promise<void> {
     log.debug({ commandoHome }, 'Creating commando home directory');
     mkdirSync(commandoHome, { recursive: true });
   } else {
-    log.debug({ commandoHome }, 'Forge home already exists');
+    log.debug({ commandoHome }, 'Commando home already exists');
   }
 
   const pkgPath = join(commandoHome, 'package.json');
@@ -187,7 +187,7 @@ export async function syncDependencies(
     log.debug({ mode, missing }, 'Manual mode, not auto-installing');
     throw new Error(
       `Missing dependencies: ${missing.join(', ')}\n` +
-        `Run: forge module install`,
+        `Run: cmdo module install`,
     );
   }
 

lib/config-resolver.ts

@@ -163,11 +163,11 @@ async function findProjectRoot(options: {
  * 1. Discover project root (.commando directory)
  * 2. Load .commando/config.yml if project exists
  * 3. DEFERRED: Merge with user config (~/.commando/config) and defaults
- * 4. DEFERRED: Apply ENV var overrides beyond existing FORGE_* vars
+ * 4. DEFERRED: Apply ENV var overrides beyond existing COMMANDO_* vars
  * 5. Return CommandoConfig
  *
  * @param bootstrapConfig - Bootstrap options from CLI args
- * @returns CommandoConfig with all data needed for Forge initialization
+ * @returns CommandoConfig with all data needed for Commando initialization
  * @throws Error on critical failures (e.g., YAML parse error)
  */
 export async function resolveConfig(
@@ -186,7 +186,7 @@ export async function resolveConfig(
   log.debug(`Project root: ${projectRoot || "(none)"}`);
 
   // 2. Load project config if present
-  let forgeConfig: Partial<CommandoConfig> = {};
+  let commandoConfig: Partial<CommandoConfig> = {};
 
   if (projectRoot) {
     try {
@@ -219,8 +219,8 @@ export async function resolveConfig(
       log.debug(`Config search completed in ${configLoadDuration}ms`);
 
       if (result?.config) {
-        forgeConfig = result.config;
-        const configKeys = Object.keys(forgeConfig);
+        commandoConfig = result.config;
+        const configKeys = Object.keys(commandoConfig);
         log.debug(`Loaded config from ${result.filepath} (${configKeys.length} keys: ${configKeys.join(', ')})`);
       } else {
         log.debug(`No config file found in ${commandoDir} (using defaults)`);
@@ -241,15 +241,15 @@ export async function resolveConfig(
   //   - User config (~/.commando/config)
   //   - Project config (.commando/config)
   //   - Local overrides (.commando/config.local)
-  //   - ENV vars (FORGE_*)
+  //   - ENV vars (COMMANDO_*)
   // For now: Just use .commando/config directly
 
   // 4. DEFERRED: Extended ENV var support
   // TODO: Support ENV var overrides for config values
-  //   - FORGE_INSTALL_MODE=manual
-  //   - FORGE_OFFLINE=true
+  //   - COMMANDO_INSTALL_MODE=manual
+  //   - COMMANDO_OFFLINE=true
   //   - etc.
-  // Current: Only COMMANDO_PROJECT, FORGE_HOME supported
+  // Current: Only COMMANDO_PROJECT, COMMANDO_HOME supported
 
   // 5. Build CommandoConfig
   const config: CommandoConfig = {
@@ -268,12 +268,12 @@ export async function resolveConfig(
     colorMode: bootstrapConfig.colorMode,
     isRestarted: bootstrapConfig.isRestarted,
 
-    // Forge config (from .commando/config.yml)
-    modules: forgeConfig.modules,
-    dependencies: forgeConfig.dependencies,
-    settings: forgeConfig.settings,
-    installMode: forgeConfig.installMode,
-    offline: forgeConfig.offline,
+    // Commando config (from .commando/config.yml)
+    modules: commandoConfig.modules,
+    dependencies: commandoConfig.dependencies,
+    settings: commandoConfig.settings,
+    installMode: commandoConfig.installMode,
+    offline: commandoConfig.offline,
   };
 
   log.debug(`Config resolved: ${JSON.stringify(config, null, 2)}`);

lib/core.ts

@@ -137,11 +137,11 @@ export function discoverCommands(
  *
  * Handles:
  * - Module resolution (local .commando/ or npm package)
- * - Symlink rewriting for correct forge instance
+ * - Symlink rewriting for correct commando instance
  * - Command discovery via discoverCommands()
  *
  * @param modulePath - Module path (relative, absolute, or package name)
- * @param commandoDir - Forge directory for resolution
+ * @param commandoDir - Commando directory for resolution
  * @returns Object with groupName, description, and discovered commands
  */
 export async function loadModule(
@@ -160,7 +160,7 @@ export async function loadModule(
   log.debug({ durationMs: resolveDuration, fullPath }, 'Module path resolved');
 
   // Rewrite path to go through symlink in node_modules
-  // This ensures user commands import forge from the correct instance
+  // This ensures user commands import commando from the correct instance
   // Requires bun --preserve-symlinks
   const symlinkStart = Date.now();
   const symlinkPath = await rewriteModulePath(fullPath, commandoDir);
@@ -190,9 +190,9 @@ export async function loadModule(
 // ============================================================================
 
 /**
- * Main forge runner
+ * Main commando runner
  */
-export class Forge {
+export class Commando {
   public config: CommandoConfig;  // Public so commands can access
   private log: Logger;
 
@@ -209,7 +209,7 @@ export class Forge {
   public globalOptions: Record<string, any>;
 
   constructor(config: CommandoConfig) {
-    this.log = createLogger('forge');
+    this.log = createLogger('commando');
     this.log.debug({ config });
 
     this.config = config;
@@ -264,7 +264,7 @@ export class Forge {
   }
 
   /**
-   * Initialize Forge instance
+   * Initialize Commando instance
    *
    * Handles:
    * - Loading builtin commands (always)
@@ -275,7 +275,7 @@ export class Forge {
    * @throws ExitNotification if restart needed after dependency installation
    */
   async initialize(): Promise<void> {
-    log.debug('Starting Forge initialization');
+    log.debug('Starting Commando initialization');
 
     // 1. Always load builtins (available everywhere)
     log.debug('Phase 1: Loading builtins');
@@ -372,12 +372,12 @@ export class Forge {
     const groupDetails = Object.fromEntries(
       Object.entries(this.commandGroups).map(([group, data]) => [group, Object.keys(data.commands)])
     );
-    log.debug({ topLevel, groups, groupDetails }, 'Forge initialization complete');
+    log.debug({ topLevel, groups, groupDetails }, 'Commando initialization complete');
   }
 
   /**
    * Register all discovered commands with Commander program
-   * This is the bridge between Forge and Commander
+   * This is the bridge between Commando and Commander
    */
   async registerCommands(program: Command): Promise<void> {
     log.debug(
@@ -386,8 +386,8 @@ export class Forge {
     );
 
     // Register top-level commands first
-    for (const [cmdName, forgeCmd] of Object.entries(this.topLevelCommands)) {
-      const cmd = this.buildCommanderCommand(cmdName, forgeCmd);
+    for (const [cmdName, commandoCmd] of Object.entries(this.topLevelCommands)) {
+      const cmd = this.buildCommanderCommand(cmdName, commandoCmd);
       cmd.copyInheritedSettings(program);  // Copy inherited settings from program
       program.addCommand(cmd);
       log.debug({ cmdName }, 'Registered top-level command');
@@ -405,8 +405,8 @@ export class Forge {
       }
 
       // Add each command to the group
-      for (const [cmdName, forgeCmd] of Object.entries(group.commands)) {
-        const cmd = this.buildCommanderCommand(cmdName, forgeCmd, groupName);
+      for (const [cmdName, commandoCmd] of Object.entries(group.commands)) {
+        const cmd = this.buildCommanderCommand(cmdName, commandoCmd, groupName);
         cmd.copyInheritedSettings(groupCmd);  // Copy from group command
         groupCmd.addCommand(cmd);
       }
@@ -420,25 +420,25 @@ export class Forge {
 
   /**
    * Build a Commander Command from a CommandoCommand definition
-   * Internal method - bridges Forge commands to Commander
+   * Internal method - bridges Commando commands to Commander
    */
   private buildCommanderCommand(
     name: string,
-    forgeCmd: CommandoCommand,
+    commandoCmd: CommandoCommand,
     groupName?: string
   ): Command {
     // 1. Create Commander Command
     const cmd = new Command(name);
-    cmd.description(forgeCmd.description);
+    cmd.description(commandoCmd.description);
 
     // 2. Let command customize Commander Command (if defined)
-    if (forgeCmd.defineCommand) {
-      forgeCmd.defineCommand(cmd);
+    if (commandoCmd.defineCommand) {
+      commandoCmd.defineCommand(cmd);
     } else {
       // No defineCommand - use simple model: usage string + allowUnknown
-      if (forgeCmd.usage) {
+      if (commandoCmd.usage) {
         // Add usage as argument definition (e.g., '<text...>' or '[options]')
-        cmd.argument(forgeCmd.usage, '');
+        cmd.argument(commandoCmd.usage, '');
       } else {
         // No usage specified - allow any arguments
         cmd.allowUnknownOption(true);
@@ -476,7 +476,7 @@ export class Forge {
       };
 
       try {
-        await forgeCmd.execute(options, positionalArgs, context);
+        await commandoCmd.execute(options, positionalArgs, context);
       } catch (err) {
         die(`Command failed: ${name}\n${err}`);
       }

lib/logging/index.ts

@@ -14,7 +14,7 @@
  * limitations under the License.
  */
 /**
- * Logging API for Forge
+ * Logging API for Commando
  *
  * Public exports for the logging system
  */

lib/logging/logger.ts

@@ -142,7 +142,7 @@ export async function shutdownLogging(): Promise<void> {
 export function createLogger(name?: string): pino.Logger {
   ensureInitialized();
 
-  return rootLogger!.child({ name: name || 'forge' });
+  return rootLogger!.child({ name: name || 'commando' });
 }
 
 /**

lib/module-resolver.ts

@@ -62,11 +62,11 @@ export async function resolveModule(
   }
 
   // 2. Package modules (from node_modules)
-  // Examples: "@jdillon/forge-standard/hello", "cowsay"
+  // Examples: "@jdillon/commando-standard/hello", "cowsay"
   log.debug({ strategy: 'package', modulePath }, 'Using package module strategy');
   const nodeModules = getNodeModulesPath();
 
-  // For scoped packages with subpaths like "@jdillon/forge-standard/hello"
+  // For scoped packages with subpaths like "@jdillon/commando-standard/hello"
   // we need to resolve the full path including the submodule
   const packagePath = join(nodeModules, modulePath);
   const attemptedPaths: string[] = [];
@@ -99,6 +99,6 @@ export async function resolveModule(
       `Attempted paths:\n  ${attemptedPaths.join('\n  ')}\n\n` +
       `Suggestions:\n` +
       `  1. Add to config.yml dependencies section\n` +
-      `  2. Run: forge module install`,
+      `  2. Run: cmdo module install`,
   );
 }