@hanzo/dev 1.0.0 → 1.2.0

package/dist/cli/dev.js

@@ -1,5 +1,4 @@
 #!/usr/bin/env node
-#!/usr/bin/env node
 "use strict";
 var __create = Object.create;
 var __defProp = Object.defineProperty;
@@ -922,9 +921,9 @@ var require_command = __commonJS({
   "node_modules/commander/lib/command.js"(exports2) {
     var EventEmitter = require("events").EventEmitter;
     var childProcess = require("child_process");
-    var path = require("path");
-    var fs = require("fs");
-    var process2 = require("process");
+    var path2 = require("path");
+    var fs2 = require("fs");
+    var process3 = require("process");
     var { Argument: Argument2, humanReadableArgName } = require_argument();
     var { CommanderError: CommanderError2 } = require_error();
     var { Help: Help2 } = require_help();
@@ -970,10 +969,10 @@ var require_command = __commonJS({
         this._showHelpAfterError = false;
         this._showSuggestionAfterError = true;
         this._outputConfiguration = {
-          writeOut: (str) => process2.stdout.write(str),
-          writeErr: (str) => process2.stderr.write(str),
-          getOutHelpWidth: () => process2.stdout.isTTY ? process2.stdout.columns : void 0,
-          getErrHelpWidth: () => process2.stderr.isTTY ? process2.stderr.columns : void 0,
+          writeOut: (str) => process3.stdout.write(str),
+          writeErr: (str) => process3.stderr.write(str),
+          getOutHelpWidth: () => process3.stdout.isTTY ? process3.stdout.columns : void 0,
+          getErrHelpWidth: () => process3.stderr.isTTY ? process3.stderr.columns : void 0,
           outputError: (str, write) => write(str)
         };
         this._hidden = false;
@@ -1330,7 +1329,7 @@ Expecting one of '${allowedValues.join("', '")}'`);
         if (this._exitCallback) {
           this._exitCallback(new CommanderError2(exitCode, code, message));
         }
-        process2.exit(exitCode);
+        process3.exit(exitCode);
       }
       /**
        * Register callback `fn` for the command.
@@ -1661,8 +1660,8 @@ Expecting one of '${allowedValues.join("', '")}'`);
         }
         parseOptions = parseOptions || {};
         if (argv === void 0) {
-          argv = process2.argv;
-          if (process2.versions && process2.versions.electron) {
+          argv = process3.argv;
+          if (process3.versions && process3.versions.electron) {
             parseOptions.from = "electron";
           }
         }
@@ -1675,7 +1674,7 @@ Expecting one of '${allowedValues.join("', '")}'`);
             userArgs = argv.slice(2);
             break;
           case "electron":
-            if (process2.defaultApp) {
+            if (process3.defaultApp) {
               this._scriptPath = argv[1];
               userArgs = argv.slice(2);
             } else {
@@ -1746,10 +1745,10 @@ Expecting one of '${allowedValues.join("', '")}'`);
         let launchWithNode = false;
         const sourceExt = [".js", ".ts", ".tsx", ".mjs", ".cjs"];
         function findFile(baseDir, baseName) {
-          const localBin = path.resolve(baseDir, baseName);
-          if (fs.existsSync(localBin)) return localBin;
-          if (sourceExt.includes(path.extname(baseName))) return void 0;
-          const foundExt = sourceExt.find((ext) => fs.existsSync(`${localBin}${ext}`));
+          const localBin = path2.resolve(baseDir, baseName);
+          if (fs2.existsSync(localBin)) return localBin;
+          if (sourceExt.includes(path2.extname(baseName))) return void 0;
+          const foundExt = sourceExt.find((ext) => fs2.existsSync(`${localBin}${ext}`));
           if (foundExt) return `${localBin}${foundExt}`;
           return void 0;
         }
@@ -1760,41 +1759,41 @@ Expecting one of '${allowedValues.join("', '")}'`);
         if (this._scriptPath) {
           let resolvedScriptPath;
           try {
-            resolvedScriptPath = fs.realpathSync(this._scriptPath);
+            resolvedScriptPath = fs2.realpathSync(this._scriptPath);
           } catch (err) {
             resolvedScriptPath = this._scriptPath;
           }
-          executableDir = path.resolve(path.dirname(resolvedScriptPath), executableDir);
+          executableDir = path2.resolve(path2.dirname(resolvedScriptPath), executableDir);
         }
         if (executableDir) {
           let localFile = findFile(executableDir, executableFile);
           if (!localFile && !subcommand._executableFile && this._scriptPath) {
-            const legacyName = path.basename(this._scriptPath, path.extname(this._scriptPath));
+            const legacyName = path2.basename(this._scriptPath, path2.extname(this._scriptPath));
             if (legacyName !== this._name) {
               localFile = findFile(executableDir, `${legacyName}-${subcommand._name}`);
             }
           }
           executableFile = localFile || executableFile;
         }
-        launchWithNode = sourceExt.includes(path.extname(executableFile));
+        launchWithNode = sourceExt.includes(path2.extname(executableFile));
         let proc;
-        if (process2.platform !== "win32") {
+        if (process3.platform !== "win32") {
           if (launchWithNode) {
             args.unshift(executableFile);
-            args = incrementNodeInspectorPort(process2.execArgv).concat(args);
-            proc = childProcess.spawn(process2.argv[0], args, { stdio: "inherit" });
+            args = incrementNodeInspectorPort(process3.execArgv).concat(args);
+            proc = childProcess.spawn(process3.argv[0], args, { stdio: "inherit" });
           } else {
             proc = childProcess.spawn(executableFile, args, { stdio: "inherit" });
           }
         } else {
           args.unshift(executableFile);
-          args = incrementNodeInspectorPort(process2.execArgv).concat(args);
-          proc = childProcess.spawn(process2.execPath, args, { stdio: "inherit" });
+          args = incrementNodeInspectorPort(process3.execArgv).concat(args);
+          proc = childProcess.spawn(process3.execPath, args, { stdio: "inherit" });
         }
         if (!proc.killed) {
           const signals = ["SIGUSR1", "SIGUSR2", "SIGTERM", "SIGINT", "SIGHUP"];
           signals.forEach((signal) => {
-            process2.on(signal, () => {
+            process3.on(signal, () => {
               if (proc.killed === false && proc.exitCode === null) {
                 proc.kill(signal);
               }
@@ -1803,10 +1802,10 @@ Expecting one of '${allowedValues.join("', '")}'`);
         }
         const exitCallback = this._exitCallback;
         if (!exitCallback) {
-          proc.on("close", process2.exit.bind(process2));
+          proc.on("close", process3.exit.bind(process3));
         } else {
           proc.on("close", () => {
-            exitCallback(new CommanderError2(process2.exitCode || 0, "commander.executeSubCommandAsync", "(close)"));
+            exitCallback(new CommanderError2(process3.exitCode || 0, "commander.executeSubCommandAsync", "(close)"));
           });
         }
         proc.on("error", (err) => {
@@ -1821,7 +1820,7 @@ Expecting one of '${allowedValues.join("', '")}'`);
             throw new Error(`'${executableFile}' not executable`);
           }
           if (!exitCallback) {
-            process2.exit(1);
+            process3.exit(1);
           } else {
             const wrappedError = new CommanderError2(1, "commander.executeSubCommandAsync", "(error)");
             wrappedError.nestedError = err;
@@ -2287,11 +2286,11 @@ Expecting one of '${allowedValues.join("', '")}'`);
        */
       _parseOptionsEnv() {
         this.options.forEach((option) => {
-          if (option.envVar && option.envVar in process2.env) {
+          if (option.envVar && option.envVar in process3.env) {
             const optionKey = option.attributeName();
             if (this.getOptionValue(optionKey) === void 0 || ["default", "config", "env"].includes(this.getOptionValueSource(optionKey))) {
               if (option.required || option.optional) {
-                this.emit(`optionEnv:${option.name()}`, process2.env[option.envVar]);
+                this.emit(`optionEnv:${option.name()}`, process3.env[option.envVar]);
               } else {
                 this.emit(`optionEnv:${option.name()}`);
               }
@@ -2559,7 +2558,7 @@ Expecting one of '${allowedValues.join("', '")}'`);
        * @return {Command}
        */
       nameFromFilename(filename) {
-        this._name = path.basename(filename, path.extname(filename));
+        this._name = path2.basename(filename, path2.extname(filename));
         return this;
       }
       /**
@@ -2573,9 +2572,9 @@ Expecting one of '${allowedValues.join("', '")}'`);
        * @param {string} [path]
        * @return {string|null|Command}
        */
-      executableDir(path2) {
-        if (path2 === void 0) return this._executableDir;
-        this._executableDir = path2;
+      executableDir(path3) {
+        if (path3 === void 0) return this._executableDir;
+        this._executableDir = path3;
         return this;
       }
       /**
@@ -2667,7 +2666,7 @@ Expecting one of '${allowedValues.join("', '")}'`);
        */
       help(contextOptions) {
         this.outputHelp(contextOptions);
-        let exitCode = process2.exitCode || 0;
+        let exitCode = process3.exitCode || 0;
         if (exitCode === 0 && contextOptions && typeof contextOptions !== "function" && contextOptions.error) {
           exitCode = 1;
         }
@@ -3060,10 +3059,10 @@ function _supportsColor(haveStream, { streamIsTTY, sniffFlags = true } = {}) {
     return 3;
   }
   if ("TERM_PROGRAM" in env) {
-    const version = Number.parseInt((env.TERM_PROGRAM_VERSION || "").split(".")[0], 10);
+    const version2 = Number.parseInt((env.TERM_PROGRAM_VERSION || "").split(".")[0], 10);
     switch (env.TERM_PROGRAM) {
       case "iTerm.app": {
-        return version >= 3 ? 3 : 2;
+        return version2 >= 3 ? 3 : 2;
       }
       case "Apple_Terminal": {
         return 2;
@@ -3272,18 +3271,347 @@ var chalkStderr = createChalk({ level: stderrColor ? stderrColor.level : 0 });
 var source_default = chalk;
 
 // src/cli/dev.ts
+var import_inquirer = __toESM(require("inquirer"));
+var import_child_process = require("child_process");
+var fs = __toESM(require("fs"));
+var path = __toESM(require("path"));
+var os2 = __toESM(require("os"));
 var program2 = new Command();
-program2.name("@hanzo/dev").description("Hanzo Dev - Meta AI development CLI").version("1.0.0");
-program2.command("claude [query...]").description("Run Claude AI").action((query) => {
-  console.log(source_default.blue("\u{1F916} Running Claude AI..."));
-  console.log("Query:", query.join(" "));
+function loadEnvFiles() {
+  const envFiles = [".env", ".env.local", ".env.development", ".env.production"];
+  const cwd = process.cwd();
+  envFiles.forEach((file) => {
+    const filePath = path.join(cwd, file);
+    if (fs.existsSync(filePath)) {
+      const content = fs.readFileSync(filePath, "utf-8");
+      content.split("\n").forEach((line) => {
+        const match = line.match(/^([^=]+)=(.*)$/);
+        if (match) {
+          const key = match[1].trim();
+          const value = match[2].trim();
+          if (!process.env[key]) {
+            process.env[key] = value;
+          }
+        }
+      });
+    }
+  });
+}
+loadEnvFiles();
+var TOOLS = {
+  claude: {
+    name: "Claude (Anthropic)",
+    command: "claude-code",
+    checkCommand: "which claude-code",
+    description: "Claude Code - AI coding assistant",
+    color: source_default.blue,
+    apiKeys: ["ANTHROPIC_API_KEY", "CLAUDE_API_KEY"],
+    priority: 1
+  },
+  aider: {
+    name: "Aider",
+    command: "aider",
+    checkCommand: "which aider",
+    description: "AI pair programming in your terminal",
+    color: source_default.green,
+    apiKeys: ["OPENAI_API_KEY", "ANTHROPIC_API_KEY", "CLAUDE_API_KEY"],
+    priority: 2
+  },
+  openhands: {
+    name: "OpenHands",
+    command: "openhands",
+    checkCommand: "which openhands",
+    description: "AI software development agent",
+    color: source_default.magenta,
+    apiKeys: ["OPENAI_API_KEY", "ANTHROPIC_API_KEY", "LLM_API_KEY"],
+    priority: 3
+  },
+  gemini: {
+    name: "Gemini (Google)",
+    command: "gemini",
+    checkCommand: "which gemini",
+    description: "Google Gemini AI assistant",
+    color: source_default.yellow,
+    apiKeys: ["GOOGLE_API_KEY", "GEMINI_API_KEY"],
+    priority: 4
+  },
+  codex: {
+    name: "OpenAI Codex",
+    command: "codex",
+    checkCommand: "which codex",
+    description: "OpenAI coding assistant",
+    color: source_default.cyan,
+    apiKeys: ["OPENAI_API_KEY"],
+    priority: 5
+  }
+};
+function hasApiKey(tool) {
+  const toolConfig = TOOLS[tool];
+  if (!toolConfig || !toolConfig.apiKeys) return false;
+  return toolConfig.apiKeys.some((key) => !!process.env[key]);
+}
+async function isToolInstalled(tool) {
+  return new Promise((resolve) => {
+    var _a;
+    const checkCmd = ((_a = TOOLS[tool]) == null ? void 0 : _a.checkCommand) || `which ${tool}`;
+    const check = (0, import_child_process.spawn)("sh", ["-c", checkCmd]);
+    check.on("close", (code) => {
+      resolve(code === 0);
+    });
+  });
+}
+async function getAvailableTools() {
+  const available = [];
+  for (const toolKey of Object.keys(TOOLS)) {
+    const isInstalled = await isToolInstalled(toolKey);
+    const hasKey = hasApiKey(toolKey);
+    if (isInstalled || hasKey) {
+      available.push(toolKey);
+    }
+  }
+  return available.sort((a, b) => {
+    const priorityA = TOOLS[a].priority;
+    const priorityB = TOOLS[b].priority;
+    return priorityA - priorityB;
+  });
+}
+async function getDefaultTool() {
+  const availableTools = await getAvailableTools();
+  if (availableTools.length === 0) return null;
+  for (const tool of availableTools) {
+    if (await isToolInstalled(tool) && hasApiKey(tool)) {
+      return tool;
+    }
+  }
+  return availableTools[0];
+}
+function runTool(tool, args = []) {
+  const toolConfig = TOOLS[tool];
+  if (!toolConfig) {
+    console.error(source_default.red(`Unknown tool: ${tool}`));
+    process.exit(1);
+  }
+  console.log(toolConfig.color(`
+\u{1F680} Launching ${toolConfig.name}...
+`));
+  const child = (0, import_child_process.spawn)(toolConfig.command, args, {
+    stdio: "inherit",
+    shell: true,
+    env: process.env
+    // Pass through all environment variables
+  });
+  child.on("error", (error) => {
+    var _a;
+    console.error(source_default.red(`Failed to start ${toolConfig.name}: ${error.message}`));
+    if (!hasApiKey(tool)) {
+      console.log(source_default.yellow(`
+Make sure you have one of these API keys configured:`));
+      (_a = toolConfig.apiKeys) == null ? void 0 : _a.forEach((key) => {
+        console.log(source_default.gray(`  - ${key}`));
+      });
+    }
+    process.exit(1);
+  });
+  child.on("exit", (code) => {
+    if (code !== 0) {
+      console.error(source_default.red(`${toolConfig.name} exited with code ${code}`));
+    }
+    process.exit(code || 0);
+  });
+}
+async function interactiveMode() {
+  console.log(source_default.bold.cyan("\n\u{1F916} Hanzo Dev - AI Development Assistant\n"));
+  const envFiles = [".env", ".env.local", ".env.development", ".env.production"];
+  const detectedEnvFiles = envFiles.filter((file) => fs.existsSync(path.join(process.cwd(), file)));
+  if (detectedEnvFiles.length > 0) {
+    console.log(source_default.gray("\u{1F4C4} Detected environment files:"));
+    detectedEnvFiles.forEach((file) => {
+      console.log(source_default.gray(`   - ${file}`));
+    });
+    console.log();
+  }
+  const availableTools = await getAvailableTools();
+  const defaultTool = await getDefaultTool();
+  if (availableTools.length === 0) {
+    console.log(source_default.yellow("No AI tools available. Please either:"));
+    console.log(source_default.yellow("\n1. Install a tool:"));
+    console.log(source_default.gray("   npm install -g @hanzo/claude-code"));
+    console.log(source_default.gray("   pip install aider-chat"));
+    console.log(source_default.gray("   pip install openhands"));
+    console.log(source_default.yellow("\n2. Or configure API keys in your .env file:"));
+    console.log(source_default.gray("   ANTHROPIC_API_KEY=sk-ant-..."));
+    console.log(source_default.gray("   OPENAI_API_KEY=sk-..."));
+    console.log(source_default.gray("   GOOGLE_API_KEY=..."));
+    process.exit(1);
+  }
+  console.log(source_default.gray("\u{1F511} Detected API keys:"));
+  const allApiKeys = /* @__PURE__ */ new Set();
+  Object.values(TOOLS).forEach((tool) => {
+    var _a;
+    (_a = tool.apiKeys) == null ? void 0 : _a.forEach((key) => allApiKeys.add(key));
+  });
+  let hasAnyKey = false;
+  allApiKeys.forEach((key) => {
+    if (process.env[key]) {
+      console.log(source_default.green(`   \u2713 ${key}`));
+      hasAnyKey = true;
+    }
+  });
+  if (!hasAnyKey) {
+    console.log(source_default.gray("   (none detected)"));
+  }
+  console.log();
+  const choices = await Promise.all(availableTools.map(async (tool) => {
+    const toolConfig = TOOLS[tool];
+    const isInstalled = await isToolInstalled(tool);
+    const hasKey = hasApiKey(tool);
+    let status = "";
+    if (isInstalled && hasKey) {
+      status = source_default.green(" [Installed + API Key]");
+    } else if (isInstalled) {
+      status = source_default.yellow(" [Installed]");
+    } else if (hasKey) {
+      status = source_default.cyan(" [API Key Only]");
+    }
+    return {
+      name: `${toolConfig.name} - ${toolConfig.description}${status}`,
+      value: tool,
+      short: toolConfig.name
+    };
+  }));
+  const { selectedTool } = await import_inquirer.default.prompt([
+    {
+      type: "list",
+      name: "selectedTool",
+      message: "Select an AI tool to launch:",
+      choices,
+      default: defaultTool
+    }
+  ]);
+  const { passDirectory } = await import_inquirer.default.prompt([
+    {
+      type: "confirm",
+      name: "passDirectory",
+      message: `Open in current directory (${process.cwd()})?`,
+      default: true
+    }
+  ]);
+  const args = passDirectory ? ["."] : [];
+  runTool(selectedTool, args);
+}
+var packagePath = path.join(__dirname, "../../package.json");
+var version = "1.2.0";
+try {
+  const packageJson = JSON.parse(fs.readFileSync(packagePath, "utf-8"));
+  version = packageJson.version;
+} catch (error) {
+}
+program2.name("dev").description("Hanzo Dev - Meta AI development CLI that manages and runs all AI coding assistants").version(version);
+Object.entries(TOOLS).forEach(([toolKey, toolConfig]) => {
+  program2.command(`${toolKey} [args...]`).description(`Launch ${toolConfig.name}`).action(async (args) => {
+    var _a;
+    const isInstalled = await isToolInstalled(toolKey);
+    const hasKey = hasApiKey(toolKey);
+    if (!isInstalled && !hasKey) {
+      console.error(source_default.red(`${toolConfig.name} is not available.`));
+      console.log(source_default.yellow(`
+To use ${toolConfig.name}, you need to either:`));
+      console.log(source_default.yellow("1. Install it:"));
+      console.log(source_default.gray(`   Follow installation instructions for ${toolConfig.name}`));
+      console.log(source_default.yellow("\n2. Configure API keys:"));
+      (_a = toolConfig.apiKeys) == null ? void 0 : _a.forEach((key) => {
+        console.log(source_default.gray(`   ${key}=your-api-key`));
+      });
+      process.exit(1);
+    }
+    if (!isInstalled) {
+      console.log(source_default.yellow(`Note: ${toolConfig.name} is not installed locally, using API mode.`));
+    }
+    runTool(toolKey, args);
+  });
 });
-program2.command("codex [query...]").description("Run OpenAI Codex").action((query) => {
-  console.log(source_default.green("\u{1F916} Running OpenAI Codex..."));
-  console.log("Query:", query.join(" "));
+program2.command("list").alias("ls").description("List all available AI tools and API keys").action(async () => {
+  console.log(source_default.bold.cyan("\n\u{1F4CB} AI Tools Status:\n"));
+  const envFiles = [".env", ".env.local", ".env.development", ".env.production"];
+  const detectedEnvFiles = envFiles.filter((file) => fs.existsSync(path.join(process.cwd(), file)));
+  if (detectedEnvFiles.length > 0) {
+    console.log(source_default.bold("Environment files:"));
+    detectedEnvFiles.forEach((file) => {
+      console.log(source_default.gray(`  \u{1F4C4} ${file}`));
+    });
+    console.log();
+  }
+  console.log(source_default.bold("API Keys:"));
+  const allApiKeys = /* @__PURE__ */ new Set();
+  Object.values(TOOLS).forEach((tool) => {
+    var _a;
+    (_a = tool.apiKeys) == null ? void 0 : _a.forEach((key) => allApiKeys.add(key));
+  });
+  let hasAnyKey = false;
+  allApiKeys.forEach((key) => {
+    var _a;
+    if (process.env[key]) {
+      console.log(source_default.green(`  \u2713 ${key} = ${(_a = process.env[key]) == null ? void 0 : _a.substring(0, 10)}...`));
+      hasAnyKey = true;
+    }
+  });
+  if (!hasAnyKey) {
+    console.log(source_default.gray("  (no API keys detected)"));
+  }
+  console.log();
+  console.log(source_default.bold("Tools:"));
+  for (const [toolKey, toolConfig] of Object.entries(TOOLS)) {
+    const isInstalled = await isToolInstalled(toolKey);
+    const hasKey = hasApiKey(toolKey);
+    let status = source_default.red("\u2717 Not Available");
+    if (isInstalled && hasKey) {
+      status = source_default.green("\u2713 Ready (Installed + API Key)");
+    } else if (isInstalled) {
+      status = source_default.yellow("\u26A0 Installed (No API Key)");
+    } else if (hasKey) {
+      status = source_default.cyan("\u2601 API Mode (Not Installed)");
+    }
+    console.log(`  ${status} ${toolConfig.color(toolConfig.name)}`);
+    console.log(source_default.gray(`     ${toolConfig.description}`));
+    if (!hasKey && toolConfig.apiKeys) {
+      console.log(source_default.gray(`     Requires: ${toolConfig.apiKeys.join(" or ")}`));
+    }
+  }
+});
+program2.command("status").description("Show current working directory and environment").action(() => {
+  console.log(source_default.bold.cyan("\n\u{1F4CA} Hanzo Dev Status\n"));
+  console.log(`Current Directory: ${source_default.green(process.cwd())}`);
+  console.log(`User: ${source_default.green(os2.userInfo().username)}`);
+  console.log(`Node Version: ${source_default.green(process.version)}`);
+  console.log(`Platform: ${source_default.green(os2.platform())}`);
+  const envFiles = [".env", ".env.local", ".env.development", ".env.production"];
+  const detectedEnvFiles = envFiles.filter((file) => fs.existsSync(path.join(process.cwd(), file)));
+  if (detectedEnvFiles.length > 0) {
+    console.log(`
+Environment Files:`);
+    detectedEnvFiles.forEach((file) => {
+      console.log(source_default.green(`  \u2713 ${file}`));
+    });
+  }
 });
-program2.command("gemini [query...]").description("Run Google Gemini").action((query) => {
-  console.log(source_default.yellow("\u{1F916} Running Google Gemini..."));
-  console.log("Query:", query.join(" "));
+program2.action(async () => {
+  const defaultTool = await getDefaultTool();
+  if (defaultTool && process.argv.length === 2) {
+    console.log(source_default.gray(`Auto-selecting ${TOOLS[defaultTool].name} based on available API keys...`));
+    runTool(defaultTool, ["."]);
+  } else {
+    interactiveMode();
+  }
 });
 program2.parse();
+if (process.argv.length === 2) {
+  (async () => {
+    const defaultTool = await getDefaultTool();
+    if (defaultTool) {
+      console.log(source_default.gray(`Auto-selecting ${TOOLS[defaultTool].name} based on available API keys...`));
+      runTool(defaultTool, ["."]);
+    } else {
+      interactiveMode();
+    }
+  })();
+}

package/package.json

@@ -1,14 +1,13 @@
 {
   "name": "@hanzo/dev",
-  "version": "1.0.0",
+  "version": "1.2.0",
   "description": "Hanzo Dev - Meta AI development CLI that manages and runs all LLMs and CLI tools",
   "main": "dist/index.js",
   "bin": {
-    "dev": "./dist/cli/dev.js",
-    "hanzo-dev": "./dist/cli/dev.js"
+    "dev": "./dist/cli/dev.js"
   },
   "scripts": {
-    "build": "esbuild src/cli/dev.ts --bundle --platform=node --target=node16 --outfile=dist/cli/dev.js --external:vscode --external:inquirer --banner:js='#!/usr/bin/env node' && chmod +x dist/cli/dev.js",
+    "build": "esbuild src/cli/dev.ts --bundle --platform=node --target=node16 --outfile=dist/cli/dev.js --external:vscode --external:inquirer && chmod +x dist/cli/dev.js",
     "dev": "tsc --watch",
     "test": "jest",
     "prepublishOnly": "npm run build"

package/src/cli/dev.ts

@@ -1,36 +1,429 @@
 #!/usr/bin/env node
 import { Command } from 'commander';
 import chalk from 'chalk';
+import inquirer from 'inquirer';
+import { spawn } from 'child_process';
+import * as fs from 'fs';
+import * as path from 'path';
+import * as os from 'os';
 
 const program = new Command();
 
+// Load environment variables from .env files
+function loadEnvFiles(): void {
+  const envFiles = ['.env', '.env.local', '.env.development', '.env.production'];
+  const cwd = process.cwd();
+  
+  envFiles.forEach(file => {
+    const filePath = path.join(cwd, file);
+    if (fs.existsSync(filePath)) {
+      const content = fs.readFileSync(filePath, 'utf-8');
+      content.split('\n').forEach(line => {
+        const match = line.match(/^([^=]+)=(.*)$/);
+        if (match) {
+          const key = match[1].trim();
+          const value = match[2].trim();
+          // Only set if not already in environment
+          if (!process.env[key]) {
+            process.env[key] = value;
+          }
+        }
+      });
+    }
+  });
+}
+
+// Load env files on startup
+loadEnvFiles();
+
+// Available tools configuration with API key detection
+const TOOLS = {
+  claude: {
+    name: 'Claude (Anthropic)',
+    command: 'claude-code',
+    checkCommand: 'which claude-code',
+    description: 'Claude Code - AI coding assistant',
+    color: chalk.blue,
+    apiKeys: ['ANTHROPIC_API_KEY', 'CLAUDE_API_KEY'],
+    priority: 1
+  },
+  aider: {
+    name: 'Aider',
+    command: 'aider',
+    checkCommand: 'which aider',
+    description: 'AI pair programming in your terminal',
+    color: chalk.green,
+    apiKeys: ['OPENAI_API_KEY', 'ANTHROPIC_API_KEY', 'CLAUDE_API_KEY'],
+    priority: 2
+  },
+  openhands: {
+    name: 'OpenHands',
+    command: 'openhands',
+    checkCommand: 'which openhands',
+    description: 'AI software development agent',
+    color: chalk.magenta,
+    apiKeys: ['OPENAI_API_KEY', 'ANTHROPIC_API_KEY', 'LLM_API_KEY'],
+    priority: 3
+  },
+  gemini: {
+    name: 'Gemini (Google)',
+    command: 'gemini',
+    checkCommand: 'which gemini',
+    description: 'Google Gemini AI assistant',
+    color: chalk.yellow,
+    apiKeys: ['GOOGLE_API_KEY', 'GEMINI_API_KEY'],
+    priority: 4
+  },
+  codex: {
+    name: 'OpenAI Codex',
+    command: 'codex',
+    checkCommand: 'which codex',
+    description: 'OpenAI coding assistant',
+    color: chalk.cyan,
+    apiKeys: ['OPENAI_API_KEY'],
+    priority: 5
+  }
+};
+
+// Check if a tool has API keys configured
+function hasApiKey(tool: string): boolean {
+  const toolConfig = TOOLS[tool as keyof typeof TOOLS];
+  if (!toolConfig || !toolConfig.apiKeys) return false;
+  
+  return toolConfig.apiKeys.some(key => !!process.env[key]);
+}
+
+// Check if a tool is installed
+async function isToolInstalled(tool: string): Promise<boolean> {
+  return new Promise((resolve) => {
+    const checkCmd = TOOLS[tool as keyof typeof TOOLS]?.checkCommand || `which ${tool}`;
+    const check = spawn('sh', ['-c', checkCmd]);
+    check.on('close', (code) => {
+      resolve(code === 0);
+    });
+  });
+}
+
+// Get list of available tools (installed OR has API key)
+async function getAvailableTools(): Promise<string[]> {
+  const available: string[] = [];
+  for (const toolKey of Object.keys(TOOLS)) {
+    const isInstalled = await isToolInstalled(toolKey);
+    const hasKey = hasApiKey(toolKey);
+    if (isInstalled || hasKey) {
+      available.push(toolKey);
+    }
+  }
+  // Sort by priority
+  return available.sort((a, b) => {
+    const priorityA = TOOLS[a as keyof typeof TOOLS].priority;
+    const priorityB = TOOLS[b as keyof typeof TOOLS].priority;
+    return priorityA - priorityB;
+  });
+}
+
+// Get default tool based on API keys and installation
+async function getDefaultTool(): Promise<string | null> {
+  const availableTools = await getAvailableTools();
+  if (availableTools.length === 0) return null;
+  
+  // Prefer tools that have both API key and are installed
+  for (const tool of availableTools) {
+    if (await isToolInstalled(tool) && hasApiKey(tool)) {
+      return tool;
+    }
+  }
+  
+  // Otherwise return first available
+  return availableTools[0];
+}
+
+// Run a tool with optional arguments
+function runTool(tool: string, args: string[] = []): void {
+  const toolConfig = TOOLS[tool as keyof typeof TOOLS];
+  if (!toolConfig) {
+    console.error(chalk.red(`Unknown tool: ${tool}`));
+    process.exit(1);
+  }
+
+  console.log(toolConfig.color(`\n🚀 Launching ${toolConfig.name}...\n`));
+  
+  const child = spawn(toolConfig.command, args, {
+    stdio: 'inherit',
+    shell: true,
+    env: process.env // Pass through all environment variables
+  });
+
+  child.on('error', (error) => {
+    console.error(chalk.red(`Failed to start ${toolConfig.name}: ${error.message}`));
+    if (!hasApiKey(tool)) {
+      console.log(chalk.yellow(`\nMake sure you have one of these API keys configured:`));
+      toolConfig.apiKeys?.forEach(key => {
+        console.log(chalk.gray(`  - ${key}`));
+      });
+    }
+    process.exit(1);
+  });
+
+  child.on('exit', (code) => {
+    if (code !== 0) {
+      console.error(chalk.red(`${toolConfig.name} exited with code ${code}`));
+    }
+    process.exit(code || 0);
+  });
+}
+
+// Interactive mode
+async function interactiveMode(): Promise<void> {
+  console.log(chalk.bold.cyan('\n🤖 Hanzo Dev - AI Development Assistant\n'));
+  
+  // Show detected environment files
+  const envFiles = ['.env', '.env.local', '.env.development', '.env.production'];
+  const detectedEnvFiles = envFiles.filter(file => fs.existsSync(path.join(process.cwd(), file)));
+  if (detectedEnvFiles.length > 0) {
+    console.log(chalk.gray('📄 Detected environment files:'));
+    detectedEnvFiles.forEach(file => {
+      console.log(chalk.gray(`   - ${file}`));
+    });
+    console.log();
+  }
+  
+  const availableTools = await getAvailableTools();
+  const defaultTool = await getDefaultTool();
+  
+  if (availableTools.length === 0) {
+    console.log(chalk.yellow('No AI tools available. Please either:'));
+    console.log(chalk.yellow('\n1. Install a tool:'));
+    console.log(chalk.gray('   npm install -g @hanzo/claude-code'));
+    console.log(chalk.gray('   pip install aider-chat'));
+    console.log(chalk.gray('   pip install openhands'));
+    
+    console.log(chalk.yellow('\n2. Or configure API keys in your .env file:'));
+    console.log(chalk.gray('   ANTHROPIC_API_KEY=sk-ant-...'));
+    console.log(chalk.gray('   OPENAI_API_KEY=sk-...'));
+    console.log(chalk.gray('   GOOGLE_API_KEY=...'));
+    process.exit(1);
+  }
+
+  // Show available API keys
+  console.log(chalk.gray('🔑 Detected API keys:'));
+  const allApiKeys = new Set<string>();
+  Object.values(TOOLS).forEach(tool => {
+    tool.apiKeys?.forEach(key => allApiKeys.add(key));
+  });
+  
+  let hasAnyKey = false;
+  allApiKeys.forEach(key => {
+    if (process.env[key]) {
+      console.log(chalk.green(`   ✓ ${key}`));
+      hasAnyKey = true;
+    }
+  });
+  
+  if (!hasAnyKey) {
+    console.log(chalk.gray('   (none detected)'));
+  }
+  console.log();
+
+  const choices = await Promise.all(availableTools.map(async tool => {
+    const toolConfig = TOOLS[tool as keyof typeof TOOLS];
+    const isInstalled = await isToolInstalled(tool);
+    const hasKey = hasApiKey(tool);
+    
+    let status = '';
+    if (isInstalled && hasKey) {
+      status = chalk.green(' [Installed + API Key]');
+    } else if (isInstalled) {
+      status = chalk.yellow(' [Installed]');
+    } else if (hasKey) {
+      status = chalk.cyan(' [API Key Only]');
+    }
+    
+    return {
+      name: `${toolConfig.name} - ${toolConfig.description}${status}`,
+      value: tool,
+      short: toolConfig.name
+    };
+  }));
+
+  const { selectedTool } = await inquirer.prompt([
+    {
+      type: 'list',
+      name: 'selectedTool',
+      message: 'Select an AI tool to launch:',
+      choices: choices,
+      default: defaultTool
+    }
+  ]);
+
+  // Check if we should pass the current directory
+  const { passDirectory } = await inquirer.prompt([
+    {
+      type: 'confirm',
+      name: 'passDirectory',
+      message: `Open in current directory (${process.cwd()})?`,
+      default: true
+    }
+  ]);
+
+  const args = passDirectory ? ['.'] : [];
+  runTool(selectedTool, args);
+}
+
+// Setup version from package.json
+const packagePath = path.join(__dirname, '../../package.json');
+let version = '1.2.0';
+try {
+  const packageJson = JSON.parse(fs.readFileSync(packagePath, 'utf-8'));
+  version = packageJson.version;
+} catch (error) {
+  // Use default version if package.json not found
+}
+
 program
-  .name('@hanzo/dev')
-  .description('Hanzo Dev - Meta AI development CLI')
-  .version('1.0.0');
+  .name('dev')
+  .description('Hanzo Dev - Meta AI development CLI that manages and runs all AI coding assistants')
+  .version(version);
+
+// Direct tool commands
+Object.entries(TOOLS).forEach(([toolKey, toolConfig]) => {
+  program
+    .command(`${toolKey} [args...]`)
+    .description(`Launch ${toolConfig.name}`)
+    .action(async (args) => {
+      const isInstalled = await isToolInstalled(toolKey);
+      const hasKey = hasApiKey(toolKey);
+      
+      if (!isInstalled && !hasKey) {
+        console.error(chalk.red(`${toolConfig.name} is not available.`));
+        console.log(chalk.yellow(`\nTo use ${toolConfig.name}, you need to either:`));
+        console.log(chalk.yellow('1. Install it:'));
+        console.log(chalk.gray(`   Follow installation instructions for ${toolConfig.name}`));
+        console.log(chalk.yellow('\n2. Configure API keys:'));
+        toolConfig.apiKeys?.forEach(key => {
+          console.log(chalk.gray(`   ${key}=your-api-key`));
+        });
+        process.exit(1);
+      }
+      
+      if (!isInstalled) {
+        console.log(chalk.yellow(`Note: ${toolConfig.name} is not installed locally, using API mode.`));
+      }
+      
+      runTool(toolKey, args);
+    });
+});
 
+// List installed tools
 program
-  .command('claude [query...]')
-  .description('Run Claude AI')
-  .action((query) => {
-    console.log(chalk.blue('🤖 Running Claude AI...'));
-    console.log('Query:', query.join(' '));
+  .command('list')
+  .alias('ls')
+  .description('List all available AI tools and API keys')
+  .action(async () => {
+    console.log(chalk.bold.cyan('\n📋 AI Tools Status:\n'));
+    
+    // Show environment files
+    const envFiles = ['.env', '.env.local', '.env.development', '.env.production'];
+    const detectedEnvFiles = envFiles.filter(file => fs.existsSync(path.join(process.cwd(), file)));
+    if (detectedEnvFiles.length > 0) {
+      console.log(chalk.bold('Environment files:'));
+      detectedEnvFiles.forEach(file => {
+        console.log(chalk.gray(`  📄 ${file}`));
+      });
+      console.log();
+    }
+    
+    // Show API keys
+    console.log(chalk.bold('API Keys:'));
+    const allApiKeys = new Set<string>();
+    Object.values(TOOLS).forEach(tool => {
+      tool.apiKeys?.forEach(key => allApiKeys.add(key));
+    });
+    
+    let hasAnyKey = false;
+    allApiKeys.forEach(key => {
+      if (process.env[key]) {
+        console.log(chalk.green(`  ✓ ${key} = ${process.env[key]?.substring(0, 10)}...`));
+        hasAnyKey = true;
+      }
+    });
+    
+    if (!hasAnyKey) {
+      console.log(chalk.gray('  (no API keys detected)'));
+    }
+    console.log();
+    
+    // Show tools
+    console.log(chalk.bold('Tools:'));
+    for (const [toolKey, toolConfig] of Object.entries(TOOLS)) {
+      const isInstalled = await isToolInstalled(toolKey);
+      const hasKey = hasApiKey(toolKey);
+      
+      let status = chalk.red('✗ Not Available');
+      if (isInstalled && hasKey) {
+        status = chalk.green('✓ Ready (Installed + API Key)');
+      } else if (isInstalled) {
+        status = chalk.yellow('⚠ Installed (No API Key)');
+      } else if (hasKey) {
+        status = chalk.cyan('☁ API Mode (Not Installed)');
+      }
+      
+      console.log(`  ${status} ${toolConfig.color(toolConfig.name)}`);
+      console.log(chalk.gray(`     ${toolConfig.description}`));
+      if (!hasKey && toolConfig.apiKeys) {
+        console.log(chalk.gray(`     Requires: ${toolConfig.apiKeys.join(' or ')}`));
+      }
+    }
   });
 
+// Status command
 program
-  .command('codex [query...]')
-  .description('Run OpenAI Codex')
-  .action((query) => {
-    console.log(chalk.green('🤖 Running OpenAI Codex...'));
-    console.log('Query:', query.join(' '));
+  .command('status')
+  .description('Show current working directory and environment')
+  .action(() => {
+    console.log(chalk.bold.cyan('\n📊 Hanzo Dev Status\n'));
+    console.log(`Current Directory: ${chalk.green(process.cwd())}`);
+    console.log(`User: ${chalk.green(os.userInfo().username)}`);
+    console.log(`Node Version: ${chalk.green(process.version)}`);
+    console.log(`Platform: ${chalk.green(os.platform())}`);
+    
+    // Show environment files
+    const envFiles = ['.env', '.env.local', '.env.development', '.env.production'];
+    const detectedEnvFiles = envFiles.filter(file => fs.existsSync(path.join(process.cwd(), file)));
+    if (detectedEnvFiles.length > 0) {
+      console.log(`\nEnvironment Files:`);
+      detectedEnvFiles.forEach(file => {
+        console.log(chalk.green(`  ✓ ${file}`));
+      });
+    }
   });
 
+// Default action - run default tool or interactive mode
 program
-  .command('gemini [query...]')
-  .description('Run Google Gemini')
-  .action((query) => {
-    console.log(chalk.yellow('🤖 Running Google Gemini...'));
-    console.log('Query:', query.join(' '));
+  .action(async () => {
+    const defaultTool = await getDefaultTool();
+    if (defaultTool && process.argv.length === 2) {
+      // If we have a default tool and no arguments, run it directly
+      console.log(chalk.gray(`Auto-selecting ${TOOLS[defaultTool as keyof typeof TOOLS].name} based on available API keys...`));
+      runTool(defaultTool, ['.']);
+    } else {
+      // Otherwise show interactive mode
+      interactiveMode();
+    }
   });
 
-program.parse();
+// Parse arguments
+program.parse();
+
+// If no arguments provided, check for default tool
+if (process.argv.length === 2) {
+  (async () => {
+    const defaultTool = await getDefaultTool();
+    if (defaultTool) {
+      console.log(chalk.gray(`Auto-selecting ${TOOLS[defaultTool as keyof typeof TOOLS].name} based on available API keys...`));
+      runTool(defaultTool, ['.']);
+    } else {
+      interactiveMode();
+    }
+  })();
+}