vibe-weaver 1.0.0

package/src/index.ts

@@ -0,0 +1,797 @@
+/**
+ * Vibe-Weaver CLI - Main Entry Point
+ * A production-ready terminal agent that beats Claude Code
+ */
+
+import { Command } from 'commander';
+import chalk from 'chalk';
+import { login, logout, whoami, loginGithub, isLoggedIn } from './auth/index.js';
+import { generateCode, getCreditCost } from './lib/vibe-api.js';
+import { writeCodeBlocks } from './lib/code-parser.js';
+import { readFile, writeFile, listDir, grep } from './tools/files.js';
+import { runShell, getInstallCommand, getBuildCommand } from './tools/shell.js';
+import { 
+  getStatus, getBranch, commit, commitAll, push, pull, 
+  getDiff, isRepo, fullPRWorkflow 
+} from './tools/git.js';
+import inquirer from 'inquirer';
+import path from 'path';
+
+const program = new Command();
+
+program
+  .name('vibe-weaver')
+  .description('Vibe-Weaver CLI - Production-ready terminal agent that beats Claude Code')
+  .version('1.0.0');
+
+// ============================================
+// Auth Commands
+// ============================================
+
+program
+  .command('login')
+  .description('Log in with your Vibe-Weaver API key')
+  .option('-k, --api-key <key>', 'API key (vw_...)')
+  .option('-o, --open', 'Open browser to create API key')
+  .option('-g, --github', 'Also configure GitHub token')
+  .action(async (options) => {
+    try {
+      await login({ apiKey: options.apiKey, openBrowser: options.open });
+      
+      if (options.github) {
+        await loginGithub();
+      }
+    } catch (error) {
+      console.error(chalk.red('Login failed:'), error instanceof Error ? error.message : error);
+      process.exit(1);
+    }
+  });
+
+program
+  .command('logout')
+  .description('Log out and clear stored credentials')
+  .action(async () => {
+    try {
+      await logout();
+    } catch (error) {
+      console.error(chalk.red('Logout failed:'), error instanceof Error ? error.message : error);
+      process.exit(1);
+    }
+  });
+
+program
+  .command('whoami')
+  .description('Show current user info and credits')
+  .action(async () => {
+    try {
+      await whoami();
+    } catch (error) {
+      console.error(chalk.red('Error:'), error instanceof Error ? error.message : error);
+      process.exit(1);
+    }
+  });
+
+// ============================================
+// Generate Commands
+// ============================================
+
+program
+  .command('generate')
+  .description('Generate code using Vibe-Weaver AI')
+  .option('-g, --goal <text>', 'Goal/prompt for code generation')
+  .option('-p, --platform <type>', 'Platform: web, roblox, mobile, desktop, api', 'web')
+  .option('-l, --language <lang>', 'Language: typescript, javascript, python, lua, rust', 'typescript')
+  .option('-m, --mode <mode>', 'Model: fast, balanced, deep_reasoning, refactor', 'balanced')
+  .option('-o, --out <dir>', 'Output directory', '.')
+  .option('-y, --yes', 'Auto-approve file writes')
+  .option('-d, --dry-run', 'Show what would be generated without writing')
+  .action(async (options) => {
+    if (!options.goal) {
+      console.error(chalk.red('Error: --goal is required'));
+      process.exit(1);
+    }
+    
+    try {
+      const loggedIn = await isLoggedIn();
+      if (!loggedIn) {
+        console.error(chalk.red('Not logged in. Run "vibe-weaver login" first.'));
+        process.exit(1);
+      }
+      
+      console.log(chalk.cyan('\n🎨 Vibe-Weaver Code Generation'));
+      console.log(chalk.gray(`Mode: ${options.mode} | Platform: ${options.platform} | Language: ${options.language}`));
+      console.log(chalk.gray(`Cost: ~${getCreditCost(options.mode)} credits\n`));
+      
+      const result = await generateCode({
+        goal: options.goal,
+        platform: options.platform,
+        language: options.language,
+        modelId: options.mode
+      });
+      
+      console.log(chalk.gray('Explanation:'));
+      console.log(result.explanation);
+      
+      console.log(chalk.gray('\nQuality Score:'), `${result.quality.score}/100`);
+      
+      if (result.parsed.blocks.length > 0) {
+        console.log(chalk.gray('\nGenerated Files:'));
+        for (const block of result.parsed.blocks) {
+          console.log(`  - ${chalk.green(block.path)} (${block.language})`);
+        }
+        
+        if (!options.dryRun) {
+          const writeResult = await writeCodeBlocks(result.parsed.blocks, path.resolve(options.out));
+          
+          console.log(chalk.gray('\nWritten:'));
+          for (const file of writeResult.success) {
+            console.log(`  ✓ ${file}`);
+          }
+          
+          if (writeResult.failed.length > 0) {
+            console.log(chalk.red('\nFailed:'));
+            for (const file of writeResult.failed) {
+              console.log(`  ✗ ${file.path}: ${file.error}`);
+            }
+          }
+        } else {
+          console.log(chalk.yellow('\n[DRY-RUN] Files not written'));
+        }
+      }
+      
+      console.log(chalk.green('\n✓ Generation complete'));
+    } catch (error) {
+      console.error(chalk.red('Error:'), error instanceof Error ? error.message : error);
+      process.exit(1);
+    }
+  });
+
+// ============================================
+// Agent Commands
+// ============================================
+
+program
+  .command('run')
+  .description('Run the interactive agent loop (REPL)')
+  .option('-c, --cwd <dir>', 'Working directory', process.cwd())
+  .option('-y, --yes', 'Auto-approve all operations')
+  .option('-d, --dry-run', 'Preview changes without applying')
+  .action(async (options) => {
+    const loggedIn = await isLoggedIn();
+    if (!loggedIn) {
+      console.error(chalk.red('Not logged in. Run "vibe-weaver login" first.'));
+      process.exit(1);
+    }
+    
+    console.log(chalk.cyan('🎯 Vibe-Weaver Interactive Agent'));
+    console.log(chalk.gray('Type your goal or task. Press Ctrl+C to exit.\n'));
+    
+    // Interactive REPL
+    const readline = await import('readline');
+    const rl = readline.createInterface({
+      input: process.stdin,
+      output: process.stdout
+    });
+    
+    const askQuestion = () => {
+      rl.question(chalk.green('\n> '), async (input) => {
+        if (!input.trim()) {
+          askQuestion();
+          return;
+        }
+        
+        if (input.toLowerCase() === 'exit' || input.toLowerCase() === 'quit') {
+          rl.close();
+          return;
+        }
+        
+        try {
+          console.log(chalk.gray('\nGenerating code...'));
+          const result = await generateCode({ goal: input });
+          
+          if (result.parsed.blocks.length > 0) {
+            const writeResult = await writeCodeBlocks(result.parsed.blocks, options.cwd);
+            
+            console.log(chalk.green('\n✓ Generated files:'));
+            for (const file of writeResult.success) {
+              console.log(`  ✓ ${file}`);
+            }
+            
+            if (writeResult.failed.length > 0) {
+              console.log(chalk.red('\n✗ Failed:'));
+              for (const file of writeResult.failed) {
+                console.log(`  ✗ ${file.path}: ${file.error}`);
+              }
+            }
+          }
+        } catch (error) {
+          console.error(chalk.red('Error:'), error instanceof Error ? error.message : error);
+        }
+        
+        askQuestion();
+      });
+    };
+    
+    askQuestion();
+  });
+
+// ============================================
+// File Commands
+// ============================================
+
+program
+  .command('read')
+  .description('Read a file')
+  .argument('<file>', 'File path to read')
+  .option('-c, --cwd <dir>', 'Working directory', process.cwd())
+  .action(async (file, options) => {
+    try {
+      const result = await readFile(file, options.cwd);
+      if (result.success && result.content) {
+        console.log(result.content);
+      } else {
+        console.error(chalk.red(`Error: ${result.error}`));
+        process.exit(1);
+      }
+    } catch (error) {
+      console.error(chalk.red('Error:'), error instanceof Error ? error.message : error);
+      process.exit(1);
+    }
+  });
+
+program
+  .command('write')
+  .description('Write content to a file')
+  .argument('<file>', 'File path to write')
+  .argument('<content>', 'Content to write')
+  .option('-c, --cwd <dir>', 'Working directory', process.cwd())
+  .option('-d, --dry-run', 'Preview without writing')
+  .action(async (file, content, options) => {
+    try {
+      const result = await writeFile(file, content, options.cwd, { dryRun: options.dryRun });
+      if (result.success) {
+        console.log(chalk.green(`✓ Written to ${file}`));
+      } else {
+        console.error(chalk.red(`Error: ${result.error}`));
+        process.exit(1);
+      }
+    } catch (error) {
+      console.error(chalk.red('Error:'), error instanceof Error ? error.message : error);
+      process.exit(1);
+    }
+  });
+
+program
+  .command('ls')
+  .description('List files in a directory')
+  .argument('[dir]', 'Directory to list', '.')
+  .option('-c, --cwd <dir>', 'Working directory', process.cwd())
+  .action(async (dir, options) => {
+    try {
+      const entries = await listDir(dir, options.cwd);
+      for (const entry of entries) {
+        const prefix = entry.isDirectory ? chalk.blue('📁') : chalk.gray('📄');
+        console.log(`${prefix} ${entry.path}`);
+      }
+    } catch (error) {
+      console.error(chalk.red('Error:'), error instanceof Error ? error.message : error);
+      process.exit(1);
+    }
+  });
+
+program
+  .command('grep')
+  .description('Search for a pattern in files')
+  .argument('<pattern>', 'Pattern to search for')
+  .option('-c, --cwd <dir>', 'Working directory', process.cwd())
+  .option('-r, --recursive', 'Search recursively', true)
+  .action(async (pattern, options) => {
+    try {
+      const results = await grep(pattern, options.cwd, { recursive: options.recursive });
+      if (results.length === 0) {
+        console.log(chalk.yellow('No matches found'));
+        return;
+      }
+      
+      for (const result of results) {
+        console.log(`${chalk.gray(`${result.file}:${result.line}`)} ${result.content}`);
+      }
+    } catch (error) {
+      console.error(chalk.red('Error:'), error instanceof Error ? error.message : error);
+      process.exit(1);
+    }
+  });
+
+// ============================================
+// Shell Commands
+// ============================================
+
+program
+  .command('exec')
+  .description('Execute a shell command')
+  .argument('<command>', 'Command to execute')
+  .option('-c, --cwd <dir>', 'Working directory', process.cwd())
+  .option('-d, --dry-run', 'Preview without executing')
+  .action(async (command, options) => {
+    try {
+      if (options.dryRun) {
+        console.log(chalk.yellow(`[DRY-RUN] Would execute: ${command}`));
+        return;
+      }
+      
+      console.log(chalk.gray(`$ ${command}`));
+      const result = await runShell(command, { cwd: options.cwd });
+      
+      if (result.stdout) console.log(result.stdout);
+      if (result.stderr) console.error(chalk.red(result.stderr));
+      
+      process.exit(result.exitCode);
+    } catch (error) {
+      console.error(chalk.red('Error:'), error instanceof Error ? error.message : error);
+      process.exit(1);
+    }
+  });
+
+// ============================================
+// Git Commands
+// ============================================
+
+program
+  .command('status')
+  .description('Show git status')
+  .option('-c, --cwd <dir>', 'Working directory', process.cwd())
+  .action(async (options) => {
+    try {
+      const status = await getStatus(options.cwd);
+      
+      console.log(chalk.gray(`Branch: ${status.current || '(none)'}`));
+      if (status.tracking) {
+        console.log(chalk.gray(`Tracking: ${status.tracking}`));
+      }
+      
+      if (status.staged.length > 0) {
+        console.log(chalk.green('\nStaged:'));
+        for (const file of status.staged) {
+          console.log(`  ${chalk.green('+')} ${file}`);
+        }
+      }
+      
+      if (status.modified.length > 0) {
+        console.log(chalk.yellow('\nModified:'));
+        for (const file of status.modified) {
+          console.log(`  ${chalk.yellow('M')} ${file}`);
+        }
+      }
+      
+      if (status.untracked.length > 0) {
+        console.log(chalk.gray('\nUntracked:'));
+        for (const file of status.untracked) {
+          console.log(`  ${chalk.gray('?')} ${file}`);
+        }
+      }
+    } catch (error) {
+      console.error(chalk.red('Error:'), error instanceof Error ? error.message : error);
+      process.exit(1);
+    }
+  });
+
+program
+  .command('commit')
+  .description('Commit changes with a message')
+  .argument('<message>', 'Commit message')
+  .option('-c, --cwd <dir>', 'Working directory', process.cwd())
+  .option('-a, --all', 'Stage all changes', false)
+  .action(async (message, options) => {
+    try {
+      if (options.all) {
+        const result = await commitAll(message, options.cwd);
+        if (result.success) {
+          console.log(chalk.green(`✓ Committed: ${result.message}`));
+        } else {
+          console.error(chalk.red(`Error: ${result.error}`));
+          process.exit(1);
+        }
+      } else {
+        const result = await commit(message, options.cwd);
+        if (result.success) {
+          console.log(chalk.green(`✓ Committed: ${result.message}`));
+        } else {
+          console.error(chalk.red(`Error: ${result.error}`));
+          process.exit(1);
+        }
+      }
+    } catch (error) {
+      console.error(chalk.red('Error:'), error instanceof Error ? error.message : error);
+      process.exit(1);
+    }
+  });
+
+program
+  .command('push')
+  .description('Push to remote')
+  .option('-c, --cwd <dir>', 'Working directory', process.cwd())
+  .option('-f, --force', 'Force push', false)
+  .action(async (options) => {
+    try {
+      const result = await push({ force: options.force }, options.cwd);
+      if (result.success) {
+        console.log(chalk.green('✓ Pushed successfully'));
+      } else {
+        console.error(chalk.red(`Error: ${result.error}`));
+        process.exit(1);
+      }
+    } catch (error) {
+      console.error(chalk.red('Error:'), error instanceof Error ? error.message : error);
+      process.exit(1);
+    }
+  });
+
+program
+  .command('pull')
+  .description('Pull from remote')
+  .option('-c, --cwd <dir>', 'Working directory', process.cwd())
+  .action(async (options) => {
+    try {
+      const result = await pull({}, options.cwd);
+      if (result.success) {
+        console.log(chalk.green('✓ Pulled successfully'));
+      } else {
+        console.error(chalk.red(`Error: ${result.error}`));
+        process.exit(1);
+      }
+    } catch (error) {
+      console.error(chalk.red('Error:'), error instanceof Error ? error.message : error);
+      process.exit(1);
+    }
+  });
+
+// ============================================
+// PR Commands
+// ============================================
+
+program
+  .command('pr')
+  .description('Create a pull request with AI-generated summary')
+  .option('-t, --title <title>', 'PR title')
+  .option('-b, --body <body>', 'PR body')
+  .option('-o, --owner <owner>', 'Repository owner')
+  .option('-r, --repo <repo>', 'Repository name')
+  .option('-B, --base <branch>', 'Base branch', 'main')
+  .option('-c, --cwd <dir>', 'Working directory', process.cwd())
+  .action(async (options) => {
+    try {
+      const isGitRepo = await isRepo(options.cwd);
+      if (!isGitRepo) {
+        console.error(chalk.red('Not a git repository'));
+        process.exit(1);
+      }
+      
+      // Get current branch
+      const currentBranch = await getBranch(options.cwd);
+      
+      // If no title/body provided, generate with AI
+      let prTitle = options.title;
+      let prBody = options.body;
+      
+      if (!prTitle || !prBody) {
+        console.log(chalk.gray('Generating PR description with AI...'));
+        const result = await generateCode({
+          goal: `Create a descriptive pull request title and body for the changes in branch ${currentBranch}. Focus on what changed and why.`,
+          modelId: 'balanced'
+        });
+        
+        // Parse the result
+        const lines = result.explanation.split('\n').filter(l => l.trim());
+        if (!prTitle) prTitle = lines[0] || `Update ${currentBranch}`;
+        if (!prBody) prBody = lines.slice(1).join('\n') || result.explanation;
+      }
+      
+      // Prompt for required options if not provided
+      if (!options.owner || !options.repo) {
+        const remote = await import('./tools/git.js').then(m => m.getRemote(options.cwd));
+        if (remote) {
+          // Parse owner/repo from remote URL
+          const match = remote.match(/github\.com[/:]([^/]+)\/([^/.]+)/);
+          if (match) {
+            options.owner = options.owner || match[1];
+            options.repo = options.repo || match[2];
+          }
+        }
+      }
+      
+      if (!options.owner || !options.repo) {
+        const answers = await inquirer.prompt([
+          { type: 'input', name: 'owner', message: 'Repository owner:', when: !options.owner },
+          { type: 'input', name: 'repo', message: 'Repository name:', when: !options.repo }
+        ]);
+        options.owner = options.owner || answers.owner;
+        options.repo = options.repo || answers.repo;
+      }
+      
+      // Get diff for PR
+      const diff = await getDiff({ from: options.base, to: currentBranch }, options.cwd);
+      console.log(chalk.gray(`Diff: ${diff.length} characters`));
+      
+      const result = await fullPRWorkflow({
+        owner: options.owner,
+        repo: options.repo,
+        branchName: currentBranch,
+        baseBranch: options.base,
+        files: [], // Would need to parse diff into files
+        commitMessage: prTitle,
+        prTitle,
+        prBody
+      });
+      
+      if (result.success) {
+        console.log(chalk.green(`\n✓ PR created: ${result.prUrl}`));
+      } else {
+        console.error(chalk.red(`Error: ${result.error}`));
+        process.exit(1);
+      }
+    } catch (error) {
+      console.error(chalk.red('Error:'), error instanceof Error ? error.message : error);
+      process.exit(1);
+    }
+  });
+
+// ============================================
+// Build Commands
+// ============================================
+
+program
+  .command('build')
+  .description('Run build command')
+  .option('-c, --cwd <dir>', 'Working directory', process.cwd())
+  .option('-d, --dry-run', 'Preview without executing')
+  .action(async (options) => {
+    try {
+      const buildCmd = getBuildCommand(options.cwd);
+      
+      if (options.dryRun) {
+        console.log(chalk.yellow(`[DRY-RUN] Would execute: ${buildCmd}`));
+        return;
+      }
+      
+      console.log(chalk.gray(`$ ${buildCmd}`));
+      const result = await runShell(buildCmd, { cwd: options.cwd });
+      
+      if (result.stdout) console.log(result.stdout);
+      if (result.stderr) console.error(chalk.red(result.stderr));
+      
+      if (result.success) {
+        console.log(chalk.green('\n✓ Build successful'));
+      } else {
+        console.log(chalk.red(`\n✗ Build failed (exit code ${result.exitCode})`));
+        process.exit(result.exitCode);
+      }
+    } catch (error) {
+      console.error(chalk.red('Error:'), error instanceof Error ? error.message : error);
+      process.exit(1);
+    }
+  });
+
+program
+  .command('install')
+  .description('Run install command')
+  .option('-c, --cwd <dir>', 'Working directory', process.cwd())
+  .option('-d, --dry-run', 'Preview without executing')
+  .action(async (options) => {
+    try {
+      const installCmd = getInstallCommand(options.cwd);
+      
+      if (options.dryRun) {
+        console.log(chalk.yellow(`[DRY-RUN] Would execute: ${installCmd}`));
+        return;
+      }
+      
+      console.log(chalk.gray(`$ ${installCmd}`));
+      const result = await runShell(installCmd, { cwd: options.cwd, timeout: 300000 });
+      
+      if (result.stdout) console.log(result.stdout);
+      if (result.stderr) console.error(chalk.red(result.stderr));
+      
+      if (result.success) {
+        console.log(chalk.green('\n✓ Install successful'));
+      } else {
+        console.log(chalk.red(`\n✗ Install failed (exit code ${result.exitCode})`));
+        process.exit(result.exitCode);
+      }
+    } catch (error) {
+      console.error(chalk.red('Error:'), error instanceof Error ? error.message : error);
+      process.exit(1);
+    }
+  });
+
+// ============================================
+// MCP Commands
+// ============================================
+
+program
+  .command('mcp')
+  .description('Manage MCP server connections')
+  .option('-l, --list', 'List available MCP servers')
+  .option('-c, --connect', 'Connect to all enabled MCP servers')
+  .option('-s, --status', 'Show MCP server status')
+  .action(async (options) => {
+    const { MCPManager, getDefaultMCPServers } = await import('./mcp/index.js');
+    
+    if (options.list) {
+      const servers = getDefaultMCPServers();
+      console.log(chalk.cyan('\n📡 Available MCP Servers\n'));
+      for (const server of servers) {
+        const status = server.enabled ? chalk.green('enabled') : chalk.gray('disabled');
+        console.log(`  ${server.name.padEnd(20)} ${status}`);
+      }
+      return;
+    }
+    
+    if (options.connect) {
+      const manager = new MCPManager();
+      console.log(chalk.cyan('\n🔌 Connecting to MCP servers...\n'));
+      const result = await manager.initializeAll();
+      console.log(chalk.green(`\n✓ Connected to ${result.success.length} servers`));
+      if (result.failed.length > 0) {
+        console.log(chalk.red(`✗ Failed to connect to ${result.failed.length} servers`));
+      }
+      return;
+    }
+    
+    if (options.status) {
+      const manager = new MCPManager();
+      await manager.initializeAll();
+      const status = manager.getStatus();
+      console.log(chalk.cyan('\n📡 MCP Server Status\n'));
+      for (const s of status) {
+        const icon = s.connected ? chalk.green('✓') : chalk.red('✗');
+        console.log(`  ${icon} ${s.name}`);
+      }
+      return;
+    }
+    
+    console.log(chalk.gray('Use --list, --connect, or --status'));
+  });
+
+// ============================================
+// Swarm Commands
+// ============================================
+
+program
+  .command('swarm')
+  .description('Run multiple agents in parallel for complex tasks')
+  .option('-g, --goal <text>', 'Goal for the swarm')
+  .option('-p, --parallel <num>', 'Max parallel agents', '3')
+  .option('-c, --cwd <dir>', 'Working directory', process.cwd())
+  .action(async (options) => {
+    if (!options.goal) {
+      console.error(chalk.red('Error: --goal is required'));
+      process.exit(1);
+    }
+    
+    const loggedIn = await isLoggedIn();
+    if (!loggedIn) {
+      console.error(chalk.red('Not logged in. Run "vibe-weaver login" first.'));
+      process.exit(1);
+    }
+    
+    const { runSwarm } = await import('./agent/swarm.js');
+    await runSwarm(options.goal, {
+      maxParallel: parseInt(options.parallel),
+      baseDir: options.cwd
+    });
+  });
+
+// ============================================
+// Task Commands
+// ============================================
+
+const taskCmd = program
+  .command('task')
+  .description('Manage background tasks');
+
+taskCmd
+  .command('submit')
+  .description('Submit a background task')
+  .option('-g, --goal <text>', 'Task goal')
+  .option('-p, --platform <type>', 'Platform', 'web')
+  .option('-m, --mode <mode>', 'Model mode', 'balanced')
+  .action(async (options) => {
+    if (!options.goal) {
+      console.error(chalk.red('Error: --goal is required'));
+      process.exit(1);
+    }
+    
+    const { submitTask } = await import('./agent/tasks.js');
+    await submitTask({
+      goal: options.goal,
+      platform: options.platform,
+      modelId: options.mode
+    });
+  });
+
+taskCmd
+  .command('status')
+  .description('Check task status')
+  .argument('<id>', 'Task ID')
+  .action(async (taskId) => {
+    const { getTaskStatus, displayTaskStatus } = await import('./agent/tasks.js');
+    const status = await getTaskStatus(taskId);
+    displayTaskStatus(status);
+  });
+
+taskCmd
+  .command('logs')
+  .description('Stream task logs')
+  .argument('<id>', 'Task ID')
+  .action(async (taskId) => {
+    const { streamTaskLogs } = await import('./agent/tasks.js');
+    console.log(chalk.gray(`Streaming logs for task ${taskId}...\n`));
+    
+    for await (const log of streamTaskLogs(taskId)) {
+      process.stdout.write(log);
+    }
+  });
+
+taskCmd
+  .command('wait')
+  .description('Wait for task to complete')
+  .argument('<id>', 'Task ID')
+  .option('-t, --timeout <seconds>', 'Timeout in seconds', '300')
+  .action(async (taskId, options) => {
+    const { waitForTask, displayTaskStatus } = await import('./agent/tasks.js');
+    
+    try {
+      const status = await waitForTask(taskId, {
+        pollInterval: 5000,
+        onProgress: (s) => {
+          process.stdout.write(chalk.gray(`\rStatus: ${s.status}`));
+        }
+      });
+      console.log();
+      displayTaskStatus(status);
+    } catch (error) {
+      console.error(chalk.red('Error:'), error instanceof Error ? error.message : error);
+      process.exit(1);
+    }
+  });
+
+// ============================================
+// Deploy Commands
+// ============================================
+
+program
+  .command('deploy')
+  .description('Deploy project and verify')
+  .option('-i, --project-id <id>', 'Project ID')
+  .option('-t, --platform <type>', 'Platform', 'web')
+  .option('-v, --verify', 'Verify deployment', true)
+  .option('--no-verify', 'Skip verification')
+  .option('-c, --cwd <dir>', 'Working directory', process.cwd())
+  .action(async (options) => {
+    const loggedIn = await isLoggedIn();
+    if (!loggedIn) {
+      console.error(chalk.red('Not logged in. Run "vibe-weaver login" first.'));
+      process.exit(1);
+    }
+    
+    const { deploy } = await import('./agent/deploy.js');
+    const result = await deploy({
+      projectId: options.projectId,
+      platform: options.platform,
+      verify: options.verify,
+      cwd: options.cwd
+    });
+    
+    if (result.success) {
+      console.log(chalk.green(`\n✓ Deployed to ${result.url}`));
+    } else {
+      console.error(chalk.red(`\n✗ Deployment failed: ${result.error}`));
+      process.exit(1);
+    }
+  });
+
+// ============================================
+// Main entry point
+// ============================================
+
+program.parse();