agdi 1.0.3 → 2.2.0

package/dist/index.js

@@ -2,9 +2,8 @@
 
 // src/index.ts
 import { Command } from "commander";
-import chalk3 from "chalk";
-import ora2 from "ora";
-import { input as input3, select as select2, confirm as confirm2 } from "@inquirer/prompts";
+import chalk9 from "chalk";
+import ora4 from "ora";
 
 // src/core/llm/index.ts
 var PuterProvider = class {
@@ -73,33 +72,41 @@ var GeminiProvider = class {
     };
   }
 };
-var PUTER_MODELS = {
-  // OpenAI Models
-  "gpt-5": "GPT-5 (Aug 2025)",
-  "gpt-5-mini": "GPT-5 Mini",
-  "gpt-4o": "GPT-4o",
-  "o3-mini": "o3 Mini (Jan 2025)",
-  "o1": "o1 (Reasoning)",
-  // Claude Models
-  "claude-opus-4-5": "Claude 4.5 Opus (Nov 2025)",
-  "claude-sonnet-4-5": "Claude 4.5 Sonnet (Sep 2025)",
-  "claude-sonnet-4": "Claude Sonnet 4",
-  "claude-3-5-sonnet": "Claude 3.5 Sonnet",
-  // Google Models  
-  "gemini-3-pro-preview": "Gemini 3 Pro (Preview)",
-  "google/gemini-2.5-flash": "Gemini 2.5 Flash",
-  "google/gemini-2.5-pro": "Gemini 2.5 Pro",
-  // Meta Llama
-  "meta/llama-4-maverick": "Llama 4 Maverick (Apr 2025)",
-  "meta/llama-4-scout": "Llama 4 Scout",
-  "meta/llama-3.3-70b": "Llama 3.3 70B",
-  // DeepSeek
-  "deepseek/deepseek-v3.2": "DeepSeek V3.2 (Dec 2025)",
-  "deepseek/deepseek-reasoner": "DeepSeek R1",
-  // xAI
-  "x-ai/grok-3": "Grok 3",
-  // Mistral
-  "mistral/mistral-large": "Mistral Large"
+var OpenRouterProvider = class {
+  config;
+  constructor(config) {
+    this.config = config;
+  }
+  async generate(prompt, systemPrompt) {
+    const response = await fetch("https://openrouter.ai/api/v1/chat/completions", {
+      method: "POST",
+      headers: {
+        "Content-Type": "application/json",
+        "Authorization": `Bearer ${this.config.apiKey}`,
+        "HTTP-Referer": "https://agdi.dev",
+        "X-Title": "Agdi CLI"
+      },
+      body: JSON.stringify({
+        model: this.config.model || "anthropic/claude-3.5-sonnet",
+        messages: [
+          ...systemPrompt ? [{ role: "system", content: systemPrompt }] : [],
+          { role: "user", content: prompt }
+        ]
+      })
+    });
+    if (!response.ok) {
+      const error = await response.text();
+      throw new Error(`OpenRouter API error: ${response.status} - ${error}`);
+    }
+    const data = await response.json();
+    return {
+      text: data.choices?.[0]?.message?.content || "",
+      usage: data.usage ? {
+        inputTokens: data.usage.prompt_tokens,
+        outputTokens: data.usage.completion_tokens
+      } : void 0
+    };
+  }
 };
 function createLLMProvider(provider, config) {
   switch (provider) {
@@ -107,6 +114,8 @@ function createLLMProvider(provider, config) {
       return new PuterProvider(config);
     case "gemini":
       return new GeminiProvider(config);
+    case "openrouter":
+      return new OpenRouterProvider(config);
     default:
       throw new Error(`Unsupported LLM provider: ${provider}`);
   }
@@ -270,13 +279,29 @@ async function generateApp(prompt, llm, onProgress) {
       type: "module",
       scripts: {
         dev: "vite",
-        build: "vite build",
+        build: "tsc -b && vite build",
         preview: "vite preview"
       },
-      dependencies: plan.dependencies.reduce((acc, dep) => {
-        acc[dep] = "latest";
-        return acc;
-      }, {})
+      dependencies: {
+        "react": "^18.3.1",
+        "react-dom": "^18.3.1",
+        ...plan.dependencies.reduce((acc, dep) => {
+          if (dep !== "react" && dep !== "react-dom") {
+            acc[dep] = "latest";
+          }
+          return acc;
+        }, {})
+      },
+      devDependencies: {
+        "@types/react": "^18.3.0",
+        "@types/react-dom": "^18.3.0",
+        "@vitejs/plugin-react": "^4.3.0",
+        "autoprefixer": "^10.4.20",
+        "postcss": "^8.4.45",
+        "tailwindcss": "^3.4.10",
+        "typescript": "~5.5.0",
+        "vite": "^5.4.0"
+      }
     }, null, 2)
   });
   return { plan, files };
@@ -285,22 +310,321 @@ async function generateApp(prompt, llm, onProgress) {
 // src/utils/fs.ts
 import fs from "fs-extra";
 import path from "path";
+import chalk2 from "chalk";
+
+// src/security/code-firewall.ts
+import chalk from "chalk";
+var MALICIOUS_PATTERNS = [
+  // ==================== HARDCODED SECRETS ====================
+  {
+    pattern: /sk-proj-[A-Za-z0-9_-]{20,}/g,
+    category: "secret",
+    description: "OpenAI API key detected",
+    severity: "critical"
+  },
+  {
+    pattern: /AKIA[A-Z0-9]{16}/g,
+    category: "secret",
+    description: "AWS Access Key detected",
+    severity: "critical"
+  },
+  {
+    pattern: /ghp_[A-Za-z0-9]{36}/g,
+    category: "secret",
+    description: "GitHub Personal Access Token detected",
+    severity: "critical"
+  },
+  {
+    pattern: /gho_[A-Za-z0-9]{36}/g,
+    category: "secret",
+    description: "GitHub OAuth Token detected",
+    severity: "critical"
+  },
+  {
+    pattern: /AIza[A-Za-z0-9_-]{35}/g,
+    category: "secret",
+    description: "Google API key detected",
+    severity: "critical"
+  },
+  {
+    pattern: /xox[baprs]-[A-Za-z0-9-]{10,}/g,
+    category: "secret",
+    description: "Slack token detected",
+    severity: "critical"
+  },
+  {
+    pattern: /sk_live_[A-Za-z0-9]{24,}/g,
+    category: "secret",
+    description: "Stripe live key detected",
+    severity: "critical"
+  },
+  {
+    pattern: /-----BEGIN (RSA |EC |DSA |OPENSSH )?PRIVATE KEY-----/g,
+    category: "secret",
+    description: "Private key detected",
+    severity: "critical"
+  },
+  // ==================== DANGEROUS CODE PATTERNS ====================
+  {
+    pattern: /\beval\s*\(/g,
+    category: "dangerous",
+    description: "eval() usage - code injection risk",
+    severity: "high"
+  },
+  {
+    pattern: /new\s+Function\s*\(/g,
+    category: "dangerous",
+    description: "Dynamic function creation - code injection risk",
+    severity: "high"
+  },
+  {
+    pattern: /exec\s*\(\s*['"`][^'"`]*\$\{/g,
+    category: "dangerous",
+    description: "Shell command with variable interpolation",
+    severity: "high"
+  },
+  {
+    pattern: /child_process\s*\.\s*(exec|spawn|execSync)\s*\([^)]*\$\{/g,
+    category: "dangerous",
+    description: "Shell command injection via child_process",
+    severity: "critical"
+  },
+  {
+    pattern: /document\s*\.\s*write\s*\(/g,
+    category: "dangerous",
+    description: "document.write() - XSS risk",
+    severity: "medium"
+  },
+  {
+    pattern: /innerHTML\s*=\s*[^;]*\$\{/g,
+    category: "dangerous",
+    description: "innerHTML with interpolation - XSS risk",
+    severity: "high"
+  },
+  // ==================== ENV/SECRET EXFILTRATION ====================
+  {
+    pattern: /JSON\s*\.\s*stringify\s*\(\s*process\s*\.\s*env\s*\)/g,
+    category: "suspicious",
+    description: "Serializing entire process.env",
+    severity: "critical"
+  },
+  {
+    pattern: /console\s*\.\s*log\s*\(\s*process\s*\.\s*env\s*\)/g,
+    category: "suspicious",
+    description: "Logging process.env to console",
+    severity: "high"
+  },
+  {
+    pattern: /fetch\s*\([^)]*\+\s*process\s*\.\s*env/g,
+    category: "suspicious",
+    description: "Sending env variables via network",
+    severity: "critical"
+  },
+  {
+    pattern: /axios\s*\.\s*(get|post)\s*\([^)]*process\s*\.\s*env/g,
+    category: "suspicious",
+    description: "Sending env variables via axios",
+    severity: "critical"
+  },
+  // ==================== SUSPICIOUS FILE PATHS ====================
+  {
+    pattern: /\/etc\/passwd/g,
+    category: "path",
+    description: "Access to /etc/passwd",
+    severity: "critical"
+  },
+  {
+    pattern: /\/etc\/shadow/g,
+    category: "path",
+    description: "Access to /etc/shadow",
+    severity: "critical"
+  },
+  {
+    pattern: /C:\\Windows\\System32/gi,
+    category: "path",
+    description: "Access to Windows System32",
+    severity: "high"
+  },
+  {
+    pattern: /~\/\.ssh\//g,
+    category: "path",
+    description: "Access to SSH directory",
+    severity: "critical"
+  },
+  {
+    pattern: /~\/\.aws\//g,
+    category: "path",
+    description: "Access to AWS credentials",
+    severity: "critical"
+  },
+  {
+    pattern: /~\/\.gnupg\//g,
+    category: "path",
+    description: "Access to GPG keys",
+    severity: "critical"
+  },
+  // ==================== COMMAND INJECTION ====================
+  {
+    pattern: /\$\([^)]+\)/g,
+    category: "dangerous",
+    description: "Shell command substitution",
+    severity: "medium"
+  },
+  {
+    pattern: /`[^`]*\$\{[^}]+\}[^`]*`/g,
+    category: "dangerous",
+    description: "Template literal with shell commands",
+    severity: "medium"
+  }
+];
+function scanCode(code, filename) {
+  const matches = [];
+  const lines = code.split("\n");
+  for (const patternDef of MALICIOUS_PATTERNS) {
+    let match;
+    const regex = new RegExp(patternDef.pattern.source, patternDef.pattern.flags);
+    while ((match = regex.exec(code)) !== null) {
+      const beforeMatch = code.substring(0, match.index);
+      const lineNumber = (beforeMatch.match(/\n/g) || []).length + 1;
+      matches.push({
+        pattern: patternDef.pattern.source,
+        category: patternDef.category,
+        description: patternDef.description,
+        severity: patternDef.severity,
+        line: lineNumber,
+        match: match[0].substring(0, 50) + (match[0].length > 50 ? "..." : "")
+      });
+    }
+  }
+  return {
+    safe: matches.length === 0,
+    matches
+  };
+}
+function shouldBlockCode(result) {
+  return result.matches.some((m) => m.severity === "critical" || m.severity === "high");
+}
+function displayScanResults(result, filename) {
+  if (result.safe) {
+    console.log(chalk.green("\u2705 No malicious patterns detected"));
+    return;
+  }
+  console.log(chalk.red.bold("\n\u{1F6A8} SECURITY SCAN FAILED"));
+  if (filename) {
+    console.log(chalk.gray(`File: ${filename}`));
+  }
+  console.log("");
+  const criticals = result.matches.filter((m) => m.severity === "critical");
+  const highs = result.matches.filter((m) => m.severity === "high");
+  const others = result.matches.filter((m) => m.severity !== "critical" && m.severity !== "high");
+  if (criticals.length > 0) {
+    console.log(chalk.red("\u{1F534} CRITICAL:"));
+    for (const m of criticals) {
+      console.log(chalk.red(`   Line ${m.line}: ${m.description}`));
+      console.log(chalk.gray(`   Found: ${m.match}`));
+    }
+  }
+  if (highs.length > 0) {
+    console.log(chalk.yellow("\n\u{1F7E0} HIGH:"));
+    for (const m of highs) {
+      console.log(chalk.yellow(`   Line ${m.line}: ${m.description}`));
+      console.log(chalk.gray(`   Found: ${m.match}`));
+    }
+  }
+  if (others.length > 0) {
+    console.log(chalk.cyan("\n\u{1F7E1} WARNINGS:"));
+    for (const m of others) {
+      console.log(chalk.cyan(`   Line ${m.line}: ${m.description}`));
+    }
+  }
+  console.log("");
+}
+function validateCodeBeforeWrite(code, filename) {
+  const result = scanCode(code, filename);
+  if (!result.safe) {
+    displayScanResults(result, filename);
+    if (shouldBlockCode(result)) {
+      console.log(chalk.red.bold("\u{1F6A8} BLOCKED: Code contains critical security issues"));
+      console.log(chalk.gray("The file will NOT be written to disk.\n"));
+      return false;
+    } else {
+      console.log(chalk.yellow("\u26A0\uFE0F  Warning: Code contains potential issues but will be written.\n"));
+    }
+  }
+  return true;
+}
+
+// src/utils/fs.ts
 async function writeProject(project, outputDir) {
   await fs.ensureDir(outputDir);
+  let blockedCount = 0;
+  let writtenCount = 0;
   for (const file of project.files) {
     const filePath = path.join(outputDir, file.path);
+    const isSafe = validateCodeBeforeWrite(file.content, file.path);
+    if (!isSafe) {
+      blockedCount++;
+      console.log(chalk2.red(`\u26D4 BLOCKED: ${file.path}`));
+      continue;
+    }
     await fs.ensureDir(path.dirname(filePath));
     await fs.writeFile(filePath, file.content, "utf-8");
+    writtenCount++;
   }
+  console.log("");
+  if (blockedCount > 0) {
+    console.log(chalk2.yellow(`\u26A0\uFE0F  ${blockedCount} file(s) blocked by security scan`));
+  }
+  console.log(chalk2.green(`\u2705 ${writtenCount} file(s) written successfully`));
 }
 
 // src/utils/config.ts
 import fs2 from "fs-extra";
 import path2 from "path";
 import os from "os";
+import chalk3 from "chalk";
 var CONFIG_DIR = path2.join(os.homedir(), ".agdi");
 var CONFIG_FILE = path2.join(CONFIG_DIR, "config.json");
+var SECURE_FILE_MODE = 384;
+var SECURE_DIR_MODE = 448;
+function checkPermissions() {
+  try {
+    if (!fs2.existsSync(CONFIG_FILE)) {
+      return true;
+    }
+    const stats = fs2.statSync(CONFIG_FILE);
+    const mode = stats.mode & 511;
+    if (os.platform() === "win32") {
+      return true;
+    }
+    const isWorldReadable = (mode & 36) !== 0;
+    if (isWorldReadable) {
+      console.log(chalk3.yellow("\n\u26A0\uFE0F  SECURITY WARNING"));
+      console.log(chalk3.gray("Your config file is readable by other users!"));
+      console.log(chalk3.gray(`File: ${CONFIG_FILE}`));
+      console.log(chalk3.gray("Run the following to fix:"));
+      console.log(chalk3.cyan(`  chmod 600 "${CONFIG_FILE}"
+`));
+      return false;
+    }
+    return true;
+  } catch {
+    return true;
+  }
+}
+function setSecurePermissions() {
+  try {
+    if (os.platform() !== "win32") {
+      fs2.chmodSync(CONFIG_DIR, SECURE_DIR_MODE);
+      if (fs2.existsSync(CONFIG_FILE)) {
+        fs2.chmodSync(CONFIG_FILE, SECURE_FILE_MODE);
+      }
+    }
+  } catch (error) {
+  }
+}
 function loadConfig() {
+  checkPermissions();
   try {
     if (fs2.existsSync(CONFIG_FILE)) {
       return fs2.readJsonSync(CONFIG_FILE);
@@ -313,92 +637,101 @@ function saveConfig(config) {
   try {
     fs2.ensureDirSync(CONFIG_DIR);
     fs2.writeJsonSync(CONFIG_FILE, config, { spaces: 2 });
+    setSecurePermissions();
   } catch (error) {
-    console.error("Failed to save config:", error);
+    console.error(chalk3.red("Failed to save config:"), error);
   }
 }
 
 // src/commands/auth.ts
 import { input, select, password } from "@inquirer/prompts";
-import chalk from "chalk";
+import chalk4 from "chalk";
 async function login() {
-  console.log(chalk.cyan.bold("\n\u{1F510} Agdi Authentication\n"));
-  console.log(chalk.gray("Configure your API key to use Agdi CLI.\n"));
-  const config = loadConfig();
-  const provider = await select({
-    message: "Select your AI provider:",
-    choices: [
-      { name: "\u{1F511} Google Gemini (Recommended)", value: "gemini" },
-      { name: "\u{1F511} OpenAI (GPT-4, GPT-5)", value: "openai" },
-      { name: "\u{1F511} Anthropic (Claude)", value: "anthropic" },
-      { name: "\u{1F511} DeepSeek", value: "deepseek" },
-      { name: "\u{1F511} OpenRouter (Multi-model)", value: "openrouter" },
-      { name: "\u{1F3E0} Local LLM (Ollama)", value: "ollama" }
-    ]
-  });
-  if (provider === "ollama") {
-    const ollamaUrl = await input({
-      message: "Ollama server URL:",
-      default: "http://localhost:11434"
+  console.log(chalk4.cyan.bold("\n\u{1F510} Agdi Authentication\n"));
+  console.log(chalk4.gray("Configure your API key to use Agdi CLI.\n"));
+  try {
+    const config = loadConfig();
+    const provider = await select({
+      message: "Select your AI provider:",
+      choices: [
+        { name: "\u{1F511} Google Gemini (Recommended)", value: "gemini" },
+        { name: "\u{1F511} OpenRouter (100+ models)", value: "openrouter" },
+        { name: "\u{1F511} OpenAI (GPT-4, GPT-5)", value: "openai" },
+        { name: "\u{1F511} Anthropic (Claude)", value: "anthropic" },
+        { name: "\u{1F511} DeepSeek", value: "deepseek" },
+        { name: "\u{1F3E0} Local LLM (Ollama)", value: "ollama" }
+      ]
     });
-    config.ollamaUrl = ollamaUrl;
-    config.defaultProvider = "ollama";
-    saveConfig(config);
-    console.log(chalk.green("\n\u2705 Ollama configured"));
-    console.log(chalk.gray(`Server: ${ollamaUrl}
+    if (provider === "ollama") {
+      const ollamaUrl = await input({
+        message: "Ollama server URL:",
+        default: "http://localhost:11434"
+      });
+      config.ollamaUrl = ollamaUrl;
+      config.defaultProvider = "ollama";
+      saveConfig(config);
+      console.log(chalk4.green("\n\u2705 Ollama configured"));
+      console.log(chalk4.gray(`Server: ${ollamaUrl}
 `));
-    return;
-  }
-  const apiKey = await password({
-    message: `Enter your ${provider} API key:`,
-    mask: "*"
-  });
-  switch (provider) {
-    case "gemini":
-      config.geminiApiKey = apiKey;
-      break;
-    case "openai":
-      config.openaiApiKey = apiKey;
-      break;
-    case "anthropic":
-      config.anthropicApiKey = apiKey;
-      break;
-    case "deepseek":
-      config.deepseekApiKey = apiKey;
-      break;
-    case "openrouter":
-      config.openrouterApiKey = apiKey;
-      break;
-  }
-  config.defaultProvider = provider;
-  saveConfig(config);
-  console.log(chalk.green(`
+      return;
+    }
+    const apiKey = await password({
+      message: `Enter your ${provider} API key:`,
+      mask: "*"
+    });
+    switch (provider) {
+      case "gemini":
+        config.geminiApiKey = apiKey;
+        break;
+      case "openai":
+        config.openaiApiKey = apiKey;
+        break;
+      case "anthropic":
+        config.anthropicApiKey = apiKey;
+        break;
+      case "deepseek":
+        config.deepseekApiKey = apiKey;
+        break;
+      case "openrouter":
+        config.openrouterApiKey = apiKey;
+        break;
+    }
+    config.defaultProvider = provider;
+    saveConfig(config);
+    console.log(chalk4.green(`
 \u2705 ${provider} API key saved securely`));
-  console.log(chalk.gray("Keys stored in ~/.agdi/config.json\n"));
+    console.log(chalk4.gray("Keys stored in ~/.agdi/config.json\n"));
+  } catch (error) {
+    if (error.name === "ExitPromptError") {
+      console.log(chalk4.gray("\n\n\u{1F44B} Cancelled.\n"));
+      process.exit(0);
+    }
+    throw error;
+  }
 }
 async function showStatus() {
   const config = loadConfig();
-  console.log(chalk.cyan.bold("\n\u{1F4CA} Authentication Status\n"));
+  console.log(chalk4.cyan.bold("\n\u{1F4CA} Authentication Status\n"));
   const providers = [
     { name: "Gemini", key: config.geminiApiKey },
+    { name: "OpenRouter", key: config.openrouterApiKey },
     { name: "OpenAI", key: config.openaiApiKey },
     { name: "Anthropic", key: config.anthropicApiKey },
-    { name: "DeepSeek", key: config.deepseekApiKey },
-    { name: "OpenRouter", key: config.openrouterApiKey }
+    { name: "DeepSeek", key: config.deepseekApiKey }
   ];
   for (const p of providers) {
-    const status = p.key ? chalk.green("\u2713 Configured") : chalk.gray("\u2717 Not set");
+    const status = p.key ? chalk4.green("\u2713 Configured") : chalk4.gray("\u2717 Not set");
     console.log(`  ${p.name.padEnd(12)} ${status}`);
   }
-  console.log(chalk.cyan(`
-  Default: ${config.defaultProvider || "puter (FREE)"}
+  console.log(chalk4.cyan(`
+  Default: ${config.defaultProvider || "gemini"}
 `));
-  console.log(chalk.gray('\u{1F4A1} Tip: Use "agdi auth" to reconfigure\n'));
+  console.log(chalk4.gray('\u{1F4A1} Tip: Use "agdi auth" to reconfigure\n'));
 }
 
 // src/commands/chat.ts
 import { input as input2 } from "@inquirer/prompts";
-import chalk2 from "chalk";
+import chalk5 from "chalk";
 import ora from "ora";
 var SYSTEM_PROMPT2 = `You are Agdi, an elite full-stack software architect and senior engineer with deep expertise across the entire web development stack.
 
@@ -553,34 +886,38 @@ When asked to build something:
 
 You build software that works, scales, and follows industry best practices. Every solution is complete, tested, and ready for production deployment.`;
 async function startChat() {
-  console.log(chalk2.cyan.bold("\n\u{1F4AC} Agdi Interactive Mode\n"));
-  console.log(chalk2.gray('Type your coding requests. Type "exit" to quit.\n'));
+  console.log(chalk5.cyan.bold("\n\u{1F4AC} Agdi Interactive Mode\n"));
+  console.log(chalk5.gray('Type your coding requests. Type "exit" to quit.\n'));
   const config = loadConfig();
   let provider;
   let apiKey = "";
   if (config.geminiApiKey) {
     provider = "gemini";
     apiKey = config.geminiApiKey;
+  } else if (config.openrouterApiKey) {
+    provider = "openrouter";
+    apiKey = config.openrouterApiKey;
+    console.log(chalk5.gray("Using OpenRouter (100+ models available)\n"));
   } else if (config.defaultProvider === "puter") {
-    console.log(chalk2.yellow("\u26A0\uFE0F  Puter.com FREE mode requires browser authentication."));
-    console.log(chalk2.gray("For CLI usage, please configure an API key:\n"));
-    console.log(chalk2.cyan("  agdi auth"));
-    console.log(chalk2.gray("\nSupported providers: Gemini, OpenAI, Anthropic, DeepSeek\n"));
+    console.log(chalk5.yellow("\u26A0\uFE0F  Puter.com FREE mode requires browser authentication."));
+    console.log(chalk5.gray("For CLI usage, please configure an API key:\n"));
+    console.log(chalk5.cyan("  agdi auth"));
+    console.log(chalk5.gray("\nSupported providers: Gemini, OpenRouter, OpenAI, Anthropic, DeepSeek\n"));
     return;
   } else {
-    console.log(chalk2.yellow("\u26A0\uFE0F  No API key configured."));
-    console.log(chalk2.gray('Run "agdi auth" to configure your API key.\n'));
+    console.log(chalk5.yellow("\u26A0\uFE0F  No API key configured."));
+    console.log(chalk5.gray('Run "agdi auth" to configure your API key.\n'));
     return;
   }
-  console.log(chalk2.gray(`Using provider: ${chalk2.cyan(provider)}`));
-  console.log(chalk2.gray("\u2500".repeat(50) + "\n"));
+  console.log(chalk5.gray(`Using provider: ${chalk5.cyan(provider)}`));
+  console.log(chalk5.gray("\u2500".repeat(50) + "\n"));
   const pm = new ProjectManager();
   while (true) {
     const userInput = await input2({
-      message: chalk2.cyan("You:")
+      message: chalk5.cyan("You:")
     });
     if (userInput.toLowerCase() === "exit" || userInput.toLowerCase() === "quit") {
-      console.log(chalk2.gray("\n\u{1F44B} Goodbye!\n"));
+      console.log(chalk5.gray("\n\u{1F44B} Goodbye!\n"));
       break;
     }
     if (!userInput.trim()) {
@@ -597,9 +934,9 @@ async function startChat() {
         });
         pm.updateFiles(files);
         spinner.succeed("Application generated!");
-        console.log(chalk2.green("\n\u{1F4C1} Files created:"));
+        console.log(chalk5.green("\n\u{1F4C1} Files created:"));
         for (const file of files) {
-          console.log(chalk2.gray(`   - ${file.path}`));
+          console.log(chalk5.gray(`   - ${file.path}`));
         }
         const shouldWrite = await input2({
           message: "Write files to disk? (y/n):",
@@ -611,212 +948,672 @@ async function startChat() {
             default: "./generated-app"
           });
           await writeProject(pm.get(), dir);
-          console.log(chalk2.green(`
+          console.log(chalk5.green(`
 \u2705 Files written to ${dir}
 `));
         }
       } else {
         const response = await llm.generate(userInput, SYSTEM_PROMPT2);
         spinner.stop();
-        console.log(chalk2.cyan("\nAgdi: ") + response.text + "\n");
+        console.log(chalk5.cyan("\nAgdi: ") + response.text + "\n");
       }
     } catch (error) {
+      if (error.name === "ExitPromptError") {
+        console.log(chalk5.gray("\n\n\u{1F44B} Goodbye!\n"));
+        process.exit(0);
+      }
       spinner.fail("Error");
       const errorMessage = error instanceof Error ? error.message : String(error);
       if (errorMessage.includes("429") || errorMessage.includes("quota") || errorMessage.includes("Resource exhausted") || errorMessage.includes("ResourceExhausted")) {
-        console.log(chalk2.yellow("\n\u26A0\uFE0F  API quota exceeded!"));
-        console.log(chalk2.gray("Your API key has run out of credits."));
-        console.log(chalk2.gray("Try: Use a different API key or wait for quota reset.\n"));
+        console.log(chalk5.yellow("\n\u26A0\uFE0F  API quota exceeded!"));
+        console.log(chalk5.gray("Your API key has run out of credits."));
+        console.log(chalk5.gray("Try: Use a different API key or wait for quota reset.\n"));
       } else if (errorMessage.includes("401") || errorMessage.includes("Unauthorized") || errorMessage.includes("Invalid API key")) {
-        console.log(chalk2.red("\n\u{1F511} Invalid API key"));
-        console.log(chalk2.gray("Please reconfigure your API key:"));
-        console.log(chalk2.cyan("  agdi auth\n"));
+        console.log(chalk5.red("\n\u{1F511} Invalid API key"));
+        console.log(chalk5.gray("Please reconfigure your API key:"));
+        console.log(chalk5.cyan("  agdi auth\n"));
       } else if (errorMessage.includes("403") || errorMessage.includes("Forbidden")) {
-        console.log(chalk2.red("\n\u{1F6AB} Access denied"));
-        console.log(chalk2.gray("Your API key doesn't have permission for this operation.\n"));
+        console.log(chalk5.red("\n\u{1F6AB} Access denied"));
+        console.log(chalk5.gray("Your API key doesn't have permission for this operation.\n"));
       } else if (errorMessage.includes("network") || errorMessage.includes("fetch") || errorMessage.includes("ENOTFOUND")) {
-        console.log(chalk2.red("\n\u{1F310} Network error"));
-        console.log(chalk2.gray("Please check your internet connection.\n"));
+        console.log(chalk5.red("\n\u{1F310} Network error"));
+        console.log(chalk5.gray("Please check your internet connection.\n"));
       } else {
-        console.log(chalk2.red("\n" + errorMessage + "\n"));
+        console.log(chalk5.red("\n" + errorMessage + "\n"));
       }
     }
   }
 }
 
-// src/index.ts
-var BANNER = `
-${chalk3.cyan(`    ___              __ _  `)}
-${chalk3.cyan(`   /   |  ____ _____/ /(_) `)}
-${chalk3.cyan(`  / /| | / __ \`/ __  // /  `)}
-${chalk3.cyan(` / ___ |/ /_/ / /_/ // /   `)}
-${chalk3.cyan(`/_/  |_|\\__, /\\__,_//_/    `)}
-${chalk3.cyan(`       /____/              `)}
-`;
-var program = new Command();
-console.log(BANNER);
-console.log(chalk3.gray("  The Open Source AI Architect"));
-console.log(chalk3.gray("  \u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\n"));
-program.name("agdi").description(chalk3.cyan("\u{1F680} AI-powered app generator - build apps from natural language")).version("1.0.0");
-program.command("auth").description("Login or configure API keys").option("--status", "Show authentication status").action(async (options) => {
-  if (options.status) {
-    await showStatus();
-  } else {
-    await login();
+// src/commands/run.ts
+import { spawn } from "child_process";
+import chalk6 from "chalk";
+import fs3 from "fs-extra";
+import path3 from "path";
+import ora2 from "ora";
+async function runProject(targetDir) {
+  const dir = targetDir || process.cwd();
+  const absoluteDir = path3.resolve(dir);
+  console.log(chalk6.cyan.bold("\n\u{1F680} Agdi Run\n"));
+  if (!fs3.existsSync(absoluteDir)) {
+    console.log(chalk6.red(`\u274C Directory not found: ${absoluteDir}`));
+    console.log(chalk6.gray("Create a project first with: agdi init"));
+    return;
   }
-});
-program.command("chat").description("Start an interactive coding session").action(startChat);
-program.command("init").description("Create a new project interactively").action(async () => {
+  const packageJsonPath = path3.join(absoluteDir, "package.json");
+  if (!fs3.existsSync(packageJsonPath)) {
+    console.log(chalk6.red(`\u274C No package.json found in: ${absoluteDir}`));
+    console.log(chalk6.gray("This doesn't appear to be a Node.js project."));
+    return;
+  }
+  const packageJson = fs3.readJsonSync(packageJsonPath);
+  const scripts = packageJson.scripts || {};
+  let runScript = "dev";
+  if (!scripts.dev && scripts.start) {
+    runScript = "start";
+  } else if (!scripts.dev && !scripts.start) {
+    console.log(chalk6.red('\u274C No "dev" or "start" script found in package.json'));
+    console.log(chalk6.gray('Add a script like: "dev": "vite" or "start": "node index.js"'));
+    return;
+  }
+  const nodeModulesPath = path3.join(absoluteDir, "node_modules");
+  if (!fs3.existsSync(nodeModulesPath)) {
+    console.log(chalk6.yellow("\u{1F4E6} Installing dependencies...\n"));
+    const installSpinner = ora2("Running npm install...").start();
+    await new Promise((resolve, reject) => {
+      const install = spawn("npm", ["install"], {
+        cwd: absoluteDir,
+        stdio: "inherit",
+        shell: true
+      });
+      install.on("close", (code) => {
+        if (code === 0) {
+          installSpinner.succeed("Dependencies installed!");
+          resolve();
+        } else {
+          installSpinner.fail("npm install failed");
+          reject(new Error(`npm install exited with code ${code}`));
+        }
+      });
+      install.on("error", reject);
+    });
+    console.log("");
+  }
+  console.log(chalk6.green(`\u25B6 Running: npm run ${runScript}`));
+  console.log(chalk6.gray(`  Directory: ${absoluteDir}
+`));
+  console.log(chalk6.gray("\u2500".repeat(50)));
+  console.log(chalk6.gray("Press Ctrl+C to stop\n"));
+  const child = spawn("npm", ["run", runScript], {
+    cwd: absoluteDir,
+    stdio: "inherit",
+    shell: true
+  });
+  process.on("SIGINT", () => {
+    child.kill("SIGINT");
+    console.log(chalk6.gray("\n\n\u{1F44B} Server stopped."));
+    process.exit(0);
+  });
+  child.on("close", (code) => {
+    if (code !== 0) {
+      console.log(chalk6.red(`
+\u274C Process exited with code ${code}`));
+    }
+    process.exit(code || 0);
+  });
+}
+
+// src/commands/onboarding.ts
+import { select as select2, password as password2 } from "@inquirer/prompts";
+import chalk7 from "chalk";
+var PROVIDER_MODELS = {
+  gemini: [
+    { name: "\u26A1 Gemini 2.5 Flash (Fast)", value: "gemini-2.5-flash" },
+    { name: "\u{1F680} Gemini 2.5 Pro (Best)", value: "gemini-2.5-pro" },
+    { name: "\u{1F48E} Gemini 2.0 Flash", value: "gemini-2.0-flash" }
+  ],
+  openrouter: [
+    { name: "\u{1F9E0} Claude 3.5 Sonnet", value: "anthropic/claude-3.5-sonnet" },
+    { name: "\u{1F48E} GPT-4o", value: "openai/gpt-4o" },
+    { name: "\u26A1 GPT-4o Mini", value: "openai/gpt-4o-mini" },
+    { name: "\u{1F525} Gemini 2.5 Flash", value: "google/gemini-2.5-flash-preview" },
+    { name: "\u{1F999} Llama 3.3 70B", value: "meta-llama/llama-3.3-70b-instruct" },
+    { name: "\u{1F30A} DeepSeek R1", value: "deepseek/deepseek-r1" },
+    { name: "\u{1F916} Mistral Large", value: "mistral/mistral-large-latest" }
+  ],
+  openai: [
+    { name: "\u{1F48E} GPT-4o", value: "gpt-4o" },
+    { name: "\u26A1 GPT-4o Mini", value: "gpt-4o-mini" },
+    { name: "\u{1F9E0} o1", value: "o1" },
+    { name: "\u{1F680} o1-mini", value: "o1-mini" }
+  ],
+  anthropic: [
+    { name: "\u{1F9E0} Claude 3.5 Sonnet", value: "claude-3-5-sonnet-20241022" },
+    { name: "\u{1F48E} Claude 3.5 Haiku", value: "claude-3-5-haiku-20241022" },
+    { name: "\u{1F680} Claude 3 Opus", value: "claude-3-opus-20240229" }
+  ],
+  deepseek: [
+    { name: "\u{1F30A} DeepSeek V3", value: "deepseek-chat" },
+    { name: "\u{1F9E0} DeepSeek R1 (Reasoning)", value: "deepseek-reasoner" }
+  ]
+};
+function needsOnboarding() {
   const config = loadConfig();
+  return !(config.geminiApiKey || config.openrouterApiKey || config.openaiApiKey || config.anthropicApiKey || config.deepseekApiKey);
+}
+function getActiveProvider() {
+  const config = loadConfig();
+  const provider = config.defaultProvider;
+  const keyMap = {
+    gemini: config.geminiApiKey,
+    openrouter: config.openrouterApiKey,
+    openai: config.openaiApiKey,
+    anthropic: config.anthropicApiKey,
+    deepseek: config.deepseekApiKey
+  };
+  const apiKey = keyMap[provider];
+  if (apiKey) {
+    return {
+      provider,
+      apiKey,
+      model: config.defaultModel || PROVIDER_MODELS[provider]?.[0]?.value || "gemini-2.5-flash"
+    };
+  }
+  for (const [p, key] of Object.entries(keyMap)) {
+    if (key) {
+      return {
+        provider: p,
+        apiKey: key,
+        model: config.defaultModel || PROVIDER_MODELS[p]?.[0]?.value || "gemini-2.5-flash"
+      };
+    }
+  }
+  return null;
+}
+async function runOnboarding() {
+  console.log(chalk7.cyan.bold("\n\u{1F680} Welcome to Agdi!\n"));
+  console.log(chalk7.gray("Let's set up your AI provider in 3 quick steps.\n"));
+  const config = loadConfig();
+  console.log(chalk7.white.bold("Step 1/3: Select your AI provider\n"));
   const provider = await select2({
-    message: "Select AI provider:",
+    message: "Which AI provider would you like to use?",
     choices: [
-      { name: "\u{1F193} Agdi Cloud (FREE - No API key!)", value: "puter" },
-      { name: "\u{1F511} Gemini (Requires API key)", value: "gemini" }
+      { name: "\u{1F525} Google Gemini (Recommended - Free tier)", value: "gemini" },
+      { name: "\u{1F310} OpenRouter (100+ models, pay-per-use)", value: "openrouter" },
+      { name: "\u{1F9E0} OpenAI (GPT-4o)", value: "openai" },
+      { name: "\u{1F49C} Anthropic (Claude)", value: "anthropic" },
+      { name: "\u{1F30A} DeepSeek", value: "deepseek" }
     ]
   });
-  if (provider === "gemini" && !config.geminiApiKey) {
-    console.log(chalk3.yellow("\n\u26A0\uFE0F  No Gemini API key configured\n"));
-    const apiKey = await input3({
-      message: "Enter your Gemini API key:",
-      validate: (v) => v.trim().length > 0 || "API key is required"
-    });
-    config.geminiApiKey = apiKey.trim();
-    saveConfig(config);
-    console.log(chalk3.green("\u2705 API key saved\n"));
+  console.log(chalk7.white.bold("\nStep 2/3: Enter your API key\n"));
+  const keyUrls = {
+    gemini: "https://aistudio.google.com/apikey",
+    openrouter: "https://openrouter.ai/keys",
+    openai: "https://platform.openai.com/api-keys",
+    anthropic: "https://console.anthropic.com/",
+    deepseek: "https://platform.deepseek.com/"
+  };
+  console.log(chalk7.gray(`Get your key at: ${chalk7.cyan(keyUrls[provider])}
+`));
+  const apiKey = await password2({
+    message: `Enter your ${provider} API key:`,
+    mask: "*"
+  });
+  switch (provider) {
+    case "gemini":
+      config.geminiApiKey = apiKey;
+      break;
+    case "openrouter":
+      config.openrouterApiKey = apiKey;
+      break;
+    case "openai":
+      config.openaiApiKey = apiKey;
+      break;
+    case "anthropic":
+      config.anthropicApiKey = apiKey;
+      break;
+    case "deepseek":
+      config.deepseekApiKey = apiKey;
+      break;
   }
-  const prompt = await input3({
-    message: "What would you like to build?",
-    default: "A modern todo app with categories, dark mode, and local storage"
+  config.defaultProvider = provider;
+  console.log(chalk7.white.bold("\nStep 3/3: Choose your default model\n"));
+  const models = PROVIDER_MODELS[provider] || PROVIDER_MODELS.gemini;
+  const model = await select2({
+    message: "Select your default model:",
+    choices: models
   });
-  let model;
-  if (provider === "puter") {
-    model = await select2({
-      message: "Select AI model (400+ available):",
-      choices: [
-        { name: "\u26A1 GPT-4.1 Nano (Fast)", value: "gpt-4.1-nano" },
-        { name: "\u{1F680} Claude Sonnet 4 (Best)", value: "claude-sonnet-4" },
-        { name: "\u{1F9E0} Claude 3.5 Sonnet", value: "claude-3-5-sonnet" },
-        { name: "\u{1F48E} GPT-4o", value: "gpt-4o" },
-        { name: "\u{1F525} Gemini 2.5 Flash", value: "google/gemini-2.5-flash" },
-        { name: "\u{1F999} Llama 3.3 70B", value: "meta/llama-3.3-70b" },
-        { name: "\u{1F30A} DeepSeek R1", value: "deepseek/deepseek-r1" },
-        { name: "\u{1F916} Mistral Large", value: "mistral/mistral-large" },
-        { name: "\u{1F47D} Grok 2", value: "x-ai/grok-2" }
-      ]
-    });
-  } else {
-    model = await select2({
-      message: "Select AI model:",
+  config.defaultModel = model;
+  saveConfig(config);
+  console.log(chalk7.green("\n\u2705 Setup complete!"));
+  console.log(chalk7.gray(`Provider: ${chalk7.cyan(provider)}`));
+  console.log(chalk7.gray(`Model: ${chalk7.cyan(model)}
+`));
+  return { provider, apiKey, model };
+}
+async function selectModel() {
+  const config = loadConfig();
+  const provider = config.defaultProvider || "gemini";
+  console.log(chalk7.cyan.bold("\n\u{1F504} Change Model\n"));
+  console.log(chalk7.gray(`Current provider: ${chalk7.cyan(provider)}`));
+  console.log(chalk7.gray(`Current model: ${chalk7.cyan(config.defaultModel || "not set")}
+`));
+  const changeProvider = await select2({
+    message: "What would you like to do?",
+    choices: [
+      { name: "\u{1F4DD} Change model (same provider)", value: "model" },
+      { name: "\u{1F504} Change provider & model", value: "provider" },
+      { name: "\u274C Cancel", value: "cancel" }
+    ]
+  });
+  if (changeProvider === "cancel") {
+    console.log(chalk7.gray("\nCancelled.\n"));
+    return;
+  }
+  let selectedProvider = provider;
+  if (changeProvider === "provider") {
+    selectedProvider = await select2({
+      message: "Select provider:",
       choices: [
-        { name: "Gemini 2.5 Flash (Fast)", value: "gemini-2.5-flash" },
-        { name: "Gemini 2.5 Pro (Best quality)", value: "gemini-2.5-pro" }
+        { name: "\u{1F525} Gemini", value: "gemini" },
+        { name: "\u{1F310} OpenRouter", value: "openrouter" },
+        { name: "\u{1F9E0} OpenAI", value: "openai" },
+        { name: "\u{1F49C} Anthropic", value: "anthropic" },
+        { name: "\u{1F30A} DeepSeek", value: "deepseek" }
       ]
     });
+    const keyMap = {
+      gemini: config.geminiApiKey,
+      openrouter: config.openrouterApiKey,
+      openai: config.openaiApiKey,
+      anthropic: config.anthropicApiKey,
+      deepseek: config.deepseekApiKey
+    };
+    if (!keyMap[selectedProvider]) {
+      console.log(chalk7.yellow(`
+\u26A0\uFE0F  No API key configured for ${selectedProvider}
+`));
+      const apiKey = await password2({
+        message: `Enter your ${selectedProvider} API key:`,
+        mask: "*"
+      });
+      switch (selectedProvider) {
+        case "gemini":
+          config.geminiApiKey = apiKey;
+          break;
+        case "openrouter":
+          config.openrouterApiKey = apiKey;
+          break;
+        case "openai":
+          config.openaiApiKey = apiKey;
+          break;
+        case "anthropic":
+          config.anthropicApiKey = apiKey;
+          break;
+        case "deepseek":
+          config.deepseekApiKey = apiKey;
+          break;
+      }
+    }
+    config.defaultProvider = selectedProvider;
   }
-  const defaultDir = `./${prompt.split(" ").slice(0, 3).join("-").toLowerCase().replace(/[^a-z0-9-]/g, "")}`;
-  const outputDir = await input3({
-    message: "Output directory:",
-    default: defaultDir
-  });
-  const shouldProceed = await confirm2({
-    message: `Generate app in ${chalk3.cyan(outputDir)} using ${chalk3.yellow(model)}?`,
-    default: true
+  const models = PROVIDER_MODELS[selectedProvider] || PROVIDER_MODELS.gemini;
+  const model = await select2({
+    message: "Select model:",
+    choices: models
   });
-  if (!shouldProceed) {
-    console.log(chalk3.yellow("\nCancelled."));
+  config.defaultModel = model;
+  saveConfig(config);
+  console.log(chalk7.green("\n\u2705 Model changed!"));
+  console.log(chalk7.gray(`Provider: ${chalk7.cyan(selectedProvider)}`));
+  console.log(chalk7.gray(`Model: ${chalk7.cyan(model)}
+`));
+}
+
+// src/commands/codex.ts
+import { input as input4 } from "@inquirer/prompts";
+import chalk8 from "chalk";
+import ora3 from "ora";
+var SYSTEM_PROMPT3 = `You are Agdi dev, an elite AI coding assistant. You help developers write code, debug issues, and build applications.
+
+## Your Capabilities
+- Write complete, production-ready code
+- Debug and fix code issues  
+- Explain code and architecture
+- Generate full applications from descriptions
+- Run shell commands (when requested)
+
+## Response Style
+- Be concise and direct
+- Show code in proper markdown blocks
+- Explain complex decisions briefly
+- Ask clarifying questions when needed
+
+## Code Quality
+- Use TypeScript by default
+- Follow modern best practices
+- Include proper error handling
+- Write self-documenting code
+
+When generating applications, create complete file structures with all necessary code.`;
+async function startCodingMode() {
+  const activeConfig = getActiveProvider();
+  if (!activeConfig) {
+    console.log(chalk8.red("\u274C No API key configured. Run: agdi"));
     return;
   }
-  console.log("");
-  const spinner = ora2("Initializing AI architect...").start();
+  const { provider, apiKey, model } = activeConfig;
+  const config = loadConfig();
+  console.log(chalk8.cyan.bold("\n\u26A1 Agdi dev\n"));
+  console.log(chalk8.gray(`Model: ${chalk8.cyan(model)}`));
+  console.log(chalk8.gray("Commands: /model, /chat, /build, /help, /exit\n"));
+  console.log(chalk8.gray("\u2500".repeat(50) + "\n"));
+  const pm = new ProjectManager();
+  let llm = createLLMProvider(provider, { apiKey, model });
+  while (true) {
+    try {
+      const userInput = await input4({
+        message: chalk8.green("\u2192")
+      });
+      const trimmed = userInput.trim().toLowerCase();
+      if (trimmed === "/exit" || trimmed === "exit" || trimmed === "quit") {
+        console.log(chalk8.gray("\n\u{1F44B} Goodbye!\n"));
+        break;
+      }
+      if (trimmed === "/help") {
+        showHelp();
+        continue;
+      }
+      if (trimmed === "/model" || trimmed === "/models") {
+        await selectModel();
+        const newConfig = getActiveProvider();
+        if (newConfig) {
+          llm = createLLMProvider(newConfig.provider, {
+            apiKey: newConfig.apiKey,
+            model: newConfig.model
+          });
+          console.log(chalk8.gray(`Now using: ${chalk8.cyan(newConfig.model)}
+`));
+        }
+        continue;
+      }
+      if (trimmed === "/chat") {
+        console.log(chalk8.gray("\nSwitching to chat mode. Type /code to return.\n"));
+        await chatMode(llm);
+        continue;
+      }
+      if (trimmed.startsWith("/build ") || trimmed.startsWith("build ")) {
+        const prompt = userInput.replace(/^\/?build\s+/i, "").trim();
+        if (prompt) {
+          await buildApp(prompt, llm, pm);
+        } else {
+          console.log(chalk8.yellow("\nUsage: /build <description>\n"));
+        }
+        continue;
+      }
+      if (!userInput.trim()) {
+        continue;
+      }
+      const isGenerationRequest = /^(create|build|make|generate|design|implement)\s+(me\s+)?(a\s+|an\s+)?/i.test(userInput.trim());
+      if (isGenerationRequest) {
+        await buildApp(userInput, llm, pm);
+        continue;
+      }
+      const spinner = ora3("Thinking...").start();
+      try {
+        const response = await llm.generate(userInput, SYSTEM_PROMPT3);
+        spinner.stop();
+        console.log("\n" + formatResponse(response.text) + "\n");
+      } catch (error) {
+        spinner.fail("Error");
+        handleError(error);
+      }
+    } catch (error) {
+      if (error.name === "ExitPromptError") {
+        console.log(chalk8.gray("\n\n\u{1F44B} Goodbye!\n"));
+        process.exit(0);
+      }
+      throw error;
+    }
+  }
+}
+async function buildApp(prompt, llm, pm) {
+  const spinner = ora3("Generating application...").start();
   try {
-    const llm = createLLMProvider(provider, {
-      apiKey: provider === "gemini" ? config.geminiApiKey : "",
-      model
-    });
-    const pm = new ProjectManager();
-    pm.create(outputDir.replace("./", ""), prompt);
+    pm.create("generated-app", prompt);
     const { plan, files } = await generateApp(prompt, llm, (step, file) => {
-      spinner.text = file ? `${step} ${chalk3.gray(file)}` : step;
+      spinner.text = file ? `${step} ${chalk8.gray(file)}` : step;
     });
     pm.updateFiles(files);
-    pm.updateDependencies(plan.dependencies);
-    spinner.text = "Writing files to disk...";
-    await writeProject(pm.get(), outputDir);
-    spinner.succeed(chalk3.green("App generated successfully!"));
-    console.log(chalk3.gray("\n\u{1F4C1} Project created at:"), chalk3.cyan(outputDir));
-    console.log(chalk3.gray(`\u{1F4C4} ${files.length} files generated
+    spinner.succeed(chalk8.green("Application generated!"));
+    console.log(chalk8.gray("\n\u{1F4C1} Files:"));
+    for (const file of files.slice(0, 10)) {
+      console.log(chalk8.gray(`   ${file.path}`));
+    }
+    if (files.length > 10) {
+      console.log(chalk8.gray(`   ... and ${files.length - 10} more`));
+    }
+    const shouldWrite = await input4({
+      message: "Write to disk? (y/n):",
+      default: "y"
+    });
+    if (shouldWrite.toLowerCase() === "y") {
+      const dir = await input4({
+        message: "Output directory:",
+        default: "./generated-app"
+      });
+      await writeProject(pm.get(), dir);
+      console.log(chalk8.green(`
+\u2705 Written to ${dir}
 `));
-    console.log(chalk3.white("Next steps:\n"));
-    console.log(chalk3.gray(`  cd ${outputDir}`));
-    console.log(chalk3.gray("  npm install"));
-    console.log(chalk3.gray("  npm run dev\n"));
+      console.log(chalk8.gray("Next: cd " + dir + " && npm install && npm run dev\n"));
+    }
   } catch (error) {
-    spinner.fail(chalk3.red("Generation failed"));
-    console.error(chalk3.red("\n" + (error instanceof Error ? error.message : String(error))));
-    process.exit(1);
+    spinner.fail("Generation failed");
+    handleError(error);
   }
-});
-program.command("generate <prompt>").alias("g").description("Generate an app from a prompt").option("-p, --provider <provider>", "AI provider (gemini, openai, anthropic)", "gemini").option("-m, --model <model>", "AI model to use", "gemini-2.5-flash").option("-o, --output <dir>", "Output directory", "./generated-app").action(async (prompt, options) => {
-  const config = loadConfig();
-  const provider = options.provider;
-  if (!config.geminiApiKey && provider === "gemini") {
-    console.error(chalk3.red("\u274C No Gemini API key configured."));
-    console.error(chalk3.yellow("\u{1F4A1} Run: agdi auth"));
-    process.exit(1);
+}
+async function chatMode(llm) {
+  while (true) {
+    try {
+      const userInput = await input4({
+        message: chalk8.blue("\u{1F4AC}")
+      });
+      if (userInput.toLowerCase() === "/code" || userInput.toLowerCase() === "/exit") {
+        console.log(chalk8.gray("\nBack to Agdi dev mode.\n"));
+        return;
+      }
+      if (!userInput.trim()) continue;
+      const spinner = ora3("...").start();
+      const response = await llm.generate(userInput, "You are a helpful assistant. Be friendly and concise.");
+      spinner.stop();
+      console.log("\n" + response.text + "\n");
+    } catch (error) {
+      if (error.name === "ExitPromptError") {
+        return;
+      }
+      handleError(error);
+    }
   }
-  const spinner = ora2(`Generating app with ${chalk3.cyan(options.model)}...`).start();
+}
+function formatResponse(text) {
+  return text.replace(/```(\w+)?\n([\s\S]*?)```/g, (_, lang, code) => {
+    const header = lang ? chalk8.gray(`\u2500\u2500 ${lang} \u2500\u2500`) : chalk8.gray("\u2500\u2500 code \u2500\u2500");
+    return `
+${header}
+${chalk8.white(code.trim())}
+${chalk8.gray("\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500")}
+`;
+  });
+}
+function showHelp() {
+  console.log(chalk8.cyan.bold("\n\u{1F4D6} Commands\n"));
+  console.log(chalk8.gray("  /model     ") + "Change AI model");
+  console.log(chalk8.gray("  /build     ") + "Generate a full application");
+  console.log(chalk8.gray("  /chat      ") + "Switch to chat mode");
+  console.log(chalk8.gray("  /help      ") + "Show this help");
+  console.log(chalk8.gray("  /exit      ") + "Exit Agdi");
+  console.log(chalk8.gray("\n  Or just type your coding question!\n"));
+}
+function handleError(error) {
+  const msg = error instanceof Error ? error.message : String(error);
+  if (msg.includes("429") || msg.includes("quota")) {
+    console.log(chalk8.yellow("\n\u26A0\uFE0F  Quota exceeded. Run /model to switch.\n"));
+  } else if (msg.includes("401") || msg.includes("403")) {
+    console.log(chalk8.red("\n\u{1F511} Invalid API key. Run: agdi auth\n"));
+  } else {
+    console.log(chalk8.red("\n" + msg + "\n"));
+  }
+}
+
+// src/index.ts
+var BANNER = `
+${chalk9.cyan(`    ___              __ _  `)}
+${chalk9.cyan(`   /   |  ____ _____/ /(_) `)}
+${chalk9.cyan(`  / /| | / __ \`/ __  // /  `)}
+${chalk9.cyan(` / ___ |/ /_/ / /_/ // /   `)}
+${chalk9.cyan(`/_/  |_|\\_, /\\__,_//_/    `)}
+${chalk9.cyan(`       /____/              `)}
+`;
+var program = new Command();
+program.name("agdi").description(chalk9.cyan("\u{1F680} AI-powered coding assistant")).version("2.1.0").configureHelp({
+  // Show banner only when help is requested
+  formatHelp: (cmd, helper) => {
+    return BANNER + "\n" + chalk9.gray("  The Open Source AI Architect") + "\n" + chalk9.gray("  \u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\n") + "\n" + helper.formatHelp(cmd, helper);
+  }
+});
+program.action(async () => {
   try {
-    const llm = createLLMProvider(provider, {
-      apiKey: provider === "gemini" ? config.geminiApiKey : "",
-      model: options.model
-    });
-    const pm = new ProjectManager();
-    pm.create(options.output.replace("./", ""), prompt);
-    const { plan, files } = await generateApp(prompt, llm, (step) => {
-      spinner.text = step;
-    });
-    pm.updateFiles(files);
-    pm.updateDependencies(plan.dependencies);
-    await writeProject(pm.get(), options.output);
-    spinner.succeed(`App generated in ${chalk3.cyan(options.output)}`);
+    if (needsOnboarding()) {
+      await runOnboarding();
+    }
+    await startCodingMode();
   } catch (error) {
-    spinner.fail("Generation failed");
-    const errorMessage = error instanceof Error ? error.message : String(error);
-    if (errorMessage.includes("429") || errorMessage.includes("quota") || errorMessage.includes("Resource exhausted")) {
-      console.log(chalk3.yellow("\n\u26A0\uFE0F  API quota exceeded!"));
-      console.log(chalk3.gray("Your API key has run out of credits.\n"));
-    } else if (errorMessage.includes("401") || errorMessage.includes("Unauthorized")) {
-      console.log(chalk3.red("\n\u{1F511} Invalid API key. Run: agdi auth\n"));
+    if (error.name === "ExitPromptError") {
+      console.log(chalk9.gray("\n\n\u{1F44B} Goodbye!\n"));
+      process.exit(0);
+    }
+    throw error;
+  }
+});
+program.command("auth").description("Configure API keys").option("--status", "Show authentication status").action(async (options) => {
+  try {
+    if (options.status) {
+      await showStatus();
     } else {
-      console.error(chalk3.red(errorMessage));
+      await login();
+    }
+  } catch (error) {
+    if (error.name === "ExitPromptError") {
+      console.log(chalk9.gray("\n\n\u{1F44B} Cancelled.\n"));
+      process.exit(0);
+    }
+    throw error;
+  }
+});
+program.command("model").alias("models").description("Change AI model").action(async () => {
+  try {
+    await selectModel();
+  } catch (error) {
+    if (error.name === "ExitPromptError") {
+      console.log(chalk9.gray("\n\n\u{1F44B} Cancelled.\n"));
+      process.exit(0);
     }
-    process.exit(1);
+    throw error;
   }
 });
-program.command("config").description("Show or modify configuration").option("--show", "Show current configuration").action(async (options) => {
-  await showStatus();
+program.command("chat").description("Start a chat session").action(async () => {
+  try {
+    if (needsOnboarding()) {
+      await runOnboarding();
+    }
+    await startChat();
+  } catch (error) {
+    if (error.name === "ExitPromptError") {
+      console.log(chalk9.gray("\n\n\u{1F44B} Goodbye!\n"));
+      process.exit(0);
+    }
+    throw error;
+  }
 });
-program.command("models").description("List available AI models").action(() => {
-  console.log(chalk3.cyan.bold("\n\u{1F916} Available Puter.com Models (FREE - No API key!)\n"));
-  const categories = {
-    "OpenAI": ["gpt-4.1-nano", "gpt-4.1-mini", "gpt-4o", "gpt-4-turbo", "o1", "o1-mini"],
-    "Anthropic": ["claude-sonnet-4", "claude-3-5-sonnet", "claude-3-opus"],
-    "Google": ["google/gemini-2.5-flash", "google/gemini-2.5-pro"],
-    "Open Source": ["meta/llama-3.3-70b", "mistral/mistral-large", "deepseek/deepseek-r1", "x-ai/grok-2"]
-  };
-  for (const [category, models] of Object.entries(categories)) {
-    console.log(chalk3.yellow(`
-  ${category}:`));
-    for (const model of models) {
-      const name = PUTER_MODELS[model] || model;
-      console.log(chalk3.gray(`    - ${model}`) + chalk3.white(` (${name})`));
+program.command("run [directory]").description("Run a generated project").action(async (directory) => {
+  try {
+    await runProject(directory);
+  } catch (error) {
+    if (error.name === "ExitPromptError") {
+      console.log(chalk9.gray("\n\n\u{1F44B} Cancelled.\n"));
+      process.exit(0);
+    }
+    throw error;
+  }
+});
+program.command("build <prompt>").alias("b").description("Generate an app from a prompt").option("-o, --output <dir>", "Output directory", "./generated-app").action(async (prompt, options) => {
+  try {
+    if (needsOnboarding()) {
+      await runOnboarding();
+    }
+    const activeConfig = getActiveProvider();
+    if (!activeConfig) {
+      console.log(chalk9.red("\u274C No API key configured. Run: agdi auth"));
+      return;
+    }
+    const spinner = ora4("Generating application...").start();
+    try {
+      const llm = createLLMProvider(activeConfig.provider, {
+        apiKey: activeConfig.apiKey,
+        model: activeConfig.model
+      });
+      const pm = new ProjectManager();
+      pm.create(options.output.replace("./", ""), prompt);
+      const { plan, files } = await generateApp(prompt, llm, (step, file) => {
+        spinner.text = file ? `${step} ${chalk9.gray(file)}` : step;
+      });
+      pm.updateFiles(files);
+      pm.updateDependencies(plan.dependencies);
+      await writeProject(pm.get(), options.output);
+      spinner.succeed(chalk9.green("App generated!"));
+      console.log(chalk9.gray(`
+\u{1F4C1} Created ${files.length} files in ${chalk9.cyan(options.output)}`));
+      console.log(chalk9.gray("\nNext: cd " + options.output + " && npm install && npm run dev\n"));
+    } catch (error) {
+      spinner.fail("Generation failed");
+      const msg = error instanceof Error ? error.message : String(error);
+      if (msg.includes("429") || msg.includes("quota")) {
+        console.log(chalk9.yellow("\n\u26A0\uFE0F  Quota exceeded. Run: agdi model\n"));
+      } else if (msg.includes("401") || msg.includes("403")) {
+        console.log(chalk9.red("\n\u{1F511} Invalid API key. Run: agdi auth\n"));
+      } else {
+        console.error(chalk9.red("\n" + msg + "\n"));
+      }
+      process.exit(1);
+    }
+  } catch (error) {
+    if (error.name === "ExitPromptError") {
+      console.log(chalk9.gray("\n\n\u{1F44B} Cancelled.\n"));
+      process.exit(0);
     }
+    throw error;
   }
-  console.log(chalk3.gray("\n  ... and 400+ more models available!\n"));
-  console.log(chalk3.white('Usage: agdi generate "prompt" -p puter -m claude-sonnet-4\n'));
 });
-program.action(() => {
-  program.help();
+program.command("config").description("Show configuration").action(async () => {
+  const config = loadConfig();
+  const active = getActiveProvider();
+  console.log(chalk9.cyan.bold("\n\u2699\uFE0F  Configuration\n"));
+  console.log(chalk9.gray("  Provider: ") + chalk9.cyan(config.defaultProvider || "not set"));
+  console.log(chalk9.gray("  Model:    ") + chalk9.cyan(config.defaultModel || "not set"));
+  console.log(chalk9.gray("  Config:   ") + chalk9.gray("~/.agdi/config.json"));
+  console.log(chalk9.cyan.bold("\n\u{1F510} API Keys\n"));
+  const keys = [
+    ["Gemini", config.geminiApiKey],
+    ["OpenRouter", config.openrouterApiKey],
+    ["OpenAI", config.openaiApiKey],
+    ["Anthropic", config.anthropicApiKey],
+    ["DeepSeek", config.deepseekApiKey]
+  ];
+  for (const [name, key] of keys) {
+    const status = key ? chalk9.green("\u2713") : chalk9.gray("\u2717");
+    console.log(`  ${status} ${name}`);
+  }
+  console.log("");
 });
 program.parse();