flowmind 1.0.1 → 1.2.2

package/bin/flowmind.js

@@ -11,7 +11,26 @@ const ora = require('ora');
 const inquirer = require('inquirer');
 const fs = require('fs-extra');
 const path = require('path');
+const { execSync } = require('child_process');
 const FlowMind = require('../core');
+const HonorEngine = require('../core/honor-engine');
+
+// Global error handlers to prevent silent CLI crashes
+process.on('uncaughtException', (err) => {
+  console.error(chalk.red('\nUncaught Exception:'), err.message);
+  if (process.stdin.isTTY && process.stdin.isRaw) {
+    process.stdin.setRawMode(false);
+  }
+  process.exit(1);
+});
+
+process.on('unhandledRejection', (reason) => {
+  console.error(chalk.red('\nUnhandled Rejection:'), reason?.message || reason);
+  if (process.stdin.isTTY && process.stdin.isRaw) {
+    process.stdin.setRawMode(false);
+  }
+  process.exit(1);
+});
 
 // Package info
 const packageJson = require('../package.json');
@@ -42,6 +61,274 @@ function showBanner() {
   `));
 }
 
+/**
+ * Dragon Totem ASCII Art by level - Chinese Dragon (中国龙)
+ */
+function getDragonArt(level) {
+  const arts = {
+    0: [
+      '        ╭─────╮        ',
+      '       ╱  ╭─╮  ╲       ',
+      '      │  │   │  │      ',
+      '      │  │ ◎ │  │      ',
+      '      │   ╰─╯   │      ',
+      '       ╲       ╱       ',
+      '        ╰─────╯        ',
+      '      龙 蛋 (Egg)      '
+    ],
+    1: [
+      '           ╭──╮            ',
+      '      ╭────╯  ╰───╮        ',
+      '     ╱  ◎    ╰─╯   ╲      ',
+      '    ╱    ▽           ╲     ',
+      '    ╲    ╱╲   ╱╲     ╱     ',
+      '     ╲╱╱  ╲╱╱  ╲╱╲╱       ',
+      '       幼 龙 (Hatchling)   '
+    ],
+    2: [
+      '        ╭─╮  ╭─╮             ',
+      '   ╭────╯ ╰──╯ ╰───╮         ',
+      '  ╱  ◎      ╰──╯     ╲       ',
+      ' ╱      ╭────────╮     ╲     ',
+      ' ╲     ╱ ╱╱╱╱╱╱╱╱ ╲    ╱     ',
+      '  ╲───╯ ╱╱╱╱╱╱╱╱╱╱ ╰──╱      ',
+      '   ╲   ╱╱╱╱╱╱╱╱╱╱╱╱  ╱       ',
+      '    ╰─╯            ╰─╯       ',
+      '    少 年 龙 (Juvenile)       '
+    ],
+    3: [
+      '      ╭───╮  ╭───╮               ',
+      '  ╭───╯   ╰──╯   ╰───╮           ',
+      ' ╱  ◎        ╰───╯     ╲         ',
+      '│     ╭──────────╮      │        ',
+      '│    ╱ ╱╱╱╱╱╱╱╱╱╱ ╲     │        ',
+      ' ╲──╯ ╱╱╱╱╱╱╱╱╱╱╱╱ ╰───╯        ',
+      '  ╲  ╱╱╱╱╱╱╱╱╱╱╱╱╱╱╱  ╱         ',
+      '   ╲╱╱╱╱╱╱╱╱╱╱╱╱╱╱╱╱╱╱          ',
+      '    ╰───╯       ╰───╯            ',
+      '    成 年 龙 (Adult)              '
+    ],
+    4: [
+      '    ╭───╮      ╭───╮                 ',
+      '╭───╯   ╰──────╯   ╰───╮             ',
+      '│  ◎           ╰───╯     │           ',
+      '│      ╭────────────╮    │           ',
+      '│     ╱ ╱╱╱╱╱╱╱╱╱╱╱╱ ╲   │           ',
+      ' ╲───╯ ╱╱╱╱╱╱╱╱╱╱╱╱╱╱ ╰──╯          ',
+      '  ╲   ╱╱╱╱╱╱╱╱╱╱╱╱╱╱╱╱╱  ╲          ',
+      '   ╲─╯╱╱╱╱╱╱╱╱╱╱╱╱╱╱╱╱╱╰─╲         ',
+      '    ╲╱╱╱╱╱╱╱╱╱╱╱╱╱╱╱╱╱╱╱╱╱╱         ',
+      '     ╰───╯         ╰───╯             ',
+      '     长 老 龙 (Elder)                 '
+    ],
+    5: [
+      '  ★  ╭───╮          ╭───╮  ★           ',
+      '╭─╯   ╰──╯          ╰──╯   ╰─╮         ',
+      '│  ◎            ╰───╯         │         ',
+      '│       ╭──────────────╮      │         ',
+      '│      ╱ ★╱╱╱╱╱╱╱╱╱╱★╱╱ ╲     │         ',
+      ' ╲────╯ ╱╱╱╱╱╱╱╱╱╱╱╱╱╱╱╱ ╰───╯         ',
+      '  ╲    ╱╱╱╱★╱╱╱╱╱╱╱╱★╱╱╱╱╱  ╲          ',
+      '   ╲──╯╱╱╱╱╱╱╱╱╱╱╱╱╱╱╱╱╱╱╰──╲         ',
+      '    ╲─╯╱╱╱★╱╱╱╱╱╱╱╱★╱╱╱╱╱╰──╲         ',
+      '  ★  ╲╱╱╱╱╱╱╱╱╱╱╱╱╱╱╱╱╱╱╱╱╱╱  ★       ',
+      '       ╰───╯           ╰───╯            ',
+      '       升 龙 (Ascended)                 '
+    ]
+  };
+  return arts[level] || arts[0];
+}
+
+/**
+ * Get dragon color function for a level
+ */
+function getDragonColor(level) {
+  const colors = {
+    0: (text) => chalk.gray(text),
+    1: (text) => chalk.cyan(text),
+    2: (text) => chalk.cyan.bold(text),
+    3: (text) => chalk.cyanBright(text),
+    4: (text) => chalk.cyanBright.bold(text),
+    5: (text) => chalk.cyanBright.bold(text)
+  };
+  return colors[level] || colors[0];
+}
+
+/**
+ * Get highlight color for Ascended level
+ */
+function getHighlightColor(level) {
+  if (level >= 5) {
+    return (text) => chalk.whiteBright(text);
+  }
+  return (text) => text;
+}
+
+/**
+ * Render dragon totem with honor data
+ */
+function renderDragonTotem(honorData) {
+  const info = getLevelInfo(honorData.points);
+  const dragonColor = getDragonColor(info.level);
+  const highlightColor = getHighlightColor(info.level);
+  const art = getDragonArt(info.level);
+
+  // Calculate max art line width for proper padding
+  const maxArtWidth = Math.max(...art.map(l => l.length));
+  const boxWidth = Math.max(maxArtWidth + 8, 55);
+
+  const border = '─'.repeat(boxWidth - 2);
+  const padRight = (text, width) => {
+    const padding = Math.max(0, width - text.length);
+    return ' '.repeat(padding);
+  };
+
+  console.log('');
+  console.log(chalk.cyan('  ┌' + border + '┐'));
+  console.log(chalk.cyan('  │') + '  🐉 Dragon Totem of Honor  ' + padRight('  🐉 Dragon Totem of Honor  ', boxWidth - 2) + chalk.cyan('│'));
+  console.log(chalk.cyan('  ├' + border + '┤'));
+
+  for (const line of art) {
+    const padded = '  ' + line + padRight('  ' + line, boxWidth - 2);
+    console.log(chalk.cyan('  │') + dragonColor(padded) + chalk.cyan('│'));
+  }
+
+  console.log(chalk.cyan('  ├' + border + '┤'));
+
+  const levelLine = `  Level: ${info.level} - ${info.name}`;
+  const pointsLine = `  Points: ${honorData.points}`;
+  const stateLine = `  State: ${info.state}`;
+
+  console.log(chalk.cyan('  │') + highlightColor(levelLine + padRight(levelLine, boxWidth - 2)) + chalk.cyan('│'));
+  console.log(chalk.cyan('  │') + highlightColor(pointsLine + padRight(pointsLine, boxWidth - 2)) + chalk.cyan('│'));
+  console.log(chalk.cyan('  │') + highlightColor(stateLine + padRight(stateLine, boxWidth - 2)) + chalk.cyan('│'));
+
+  if (info.nextLevel) {
+    const nextLine = `  Next: ${info.pointsToNext} points to ${info.nextLevelName}`;
+    console.log(chalk.cyan('  │') + chalk.gray(nextLine + padRight(nextLine, boxWidth - 2)) + chalk.cyan('│'));
+  } else {
+    const maxLine = '  Maximum level reached!';
+    console.log(chalk.cyan('  │') + chalk.yellow(maxLine + padRight(maxLine, boxWidth - 2)) + chalk.cyan('│'));
+  }
+
+  console.log(chalk.cyan('  ├' + border + '┤'));
+
+  const statsTitle = '  Stats:';
+  console.log(chalk.cyan('  │') + chalk.white(statsTitle + padRight(statsTitle, boxWidth - 2)) + chalk.cyan('│'));
+
+  const stats1 = `    Skills Used: ${honorData.stats.skillUseCount}`;
+  const stats2 = `    New Skills: ${honorData.stats.newSkillCount}`;
+  const stats3 = `    Learnings: ${honorData.stats.learningCount}`;
+
+  console.log(chalk.cyan('  │') + chalk.gray(stats1 + padRight(stats1, boxWidth - 2)) + chalk.cyan('│'));
+  console.log(chalk.cyan('  │') + chalk.gray(stats2 + padRight(stats2, boxWidth - 2)) + chalk.cyan('│'));
+  console.log(chalk.cyan('  │') + chalk.gray(stats3 + padRight(stats3, boxWidth - 2)) + chalk.cyan('│'));
+
+  console.log(chalk.cyan('  └' + border + '┘'));
+  console.log('');
+}
+
+/**
+ * Get level info for points
+ */
+function getLevelInfo(points) {
+  const levels = [
+    { level: 0, minPoints: 0,   name: 'Egg',       state: 'dormant' },
+    { level: 1, minPoints: 1,   name: 'Hatchling',  state: 'awakening' },
+    { level: 2, minPoints: 10,  name: 'Juvenile',   state: 'growing' },
+    { level: 3, minPoints: 30,  name: 'Adult',       state: 'soaring' },
+    { level: 4, minPoints: 60,  name: 'Elder',       state: 'wise' },
+    { level: 5, minPoints: 100, name: 'Ascended',   state: 'transcendent' }
+  ];
+
+  let current = levels[0];
+  let next = levels[1];
+
+  for (const tier of levels) {
+    if (points >= tier.minPoints) {
+      current = tier;
+      next = levels[tier.level + 1] || null;
+    }
+  }
+
+  return {
+    level: current.level,
+    name: current.name,
+    state: current.state,
+    nextLevel: next ? next.level : null,
+    nextLevelName: next ? next.name : null,
+    pointsToNext: next ? next.minPoints - points : 0
+  };
+}
+
+/**
+ * Get hint for next level
+ */
+function getNextLevelHint(points) {
+  const info = getLevelInfo(points);
+  if (info.nextLevel) {
+    return `Earn ${info.pointsToNext} more points to reach ${info.nextLevelName} (Level ${info.nextLevel})`;
+  }
+  return 'You have reached the maximum dragon level!';
+}
+
+/**
+ * Publish honor data
+ */
+async function publishHonor(options) {
+  const configDir = path.join(process.env.HOME || process.env.USERPROFILE, '.flowmind');
+  const honorPath = path.join(configDir, 'honor.json');
+
+  if (!await fs.pathExists(honorPath)) {
+    console.error(chalk.red('No honor data found. Run flowmind init first.'));
+    return;
+  }
+
+  const honorData = await fs.readJson(honorPath);
+  const info = getLevelInfo(honorData.points);
+
+  const exportData = {
+    version: honorData.version,
+    points: honorData.points,
+    level: info.level,
+    levelName: info.name,
+    state: info.state,
+    stats: honorData.stats,
+    knownSkillsCount: honorData.knownSkills ? honorData.knownSkills.length : 0,
+    recentHistory: (honorData.history || []).slice(-20),
+    exportedAt: new Date().toISOString()
+  };
+
+  // Export to local JSON file
+  const outputPath = options.output || 'flowmind-honor.json';
+  await fs.writeJson(outputPath, exportData, { spaces: 2 });
+  console.log(chalk.green(`✓ Honor data exported to: ${outputPath}`));
+
+  // Create GitHub Gist if requested
+  if (options.gist) {
+    try {
+      // Check if gh CLI is available
+      try {
+        execSync('gh --version', { stdio: 'ignore' });
+      } catch {
+        console.error(chalk.red('GitHub CLI (gh) is not installed. Install it from https://cli.github.com/'));
+        return;
+      }
+
+      const gistContent = JSON.stringify(exportData, null, 2);
+      const gistDescription = `FlowMind Honor: Level ${info.level} (${info.name}) - ${honorData.points} points`;
+
+      // Create gist using gh CLI
+      const gistCommand = `gh gist create --public --desc "${gistDescription}" --filename "flowmind-honor.json" - <<< '${gistContent.replace(/'/g, "'\\''")}'`;
+
+      const gistUrl = execSync(gistCommand, { encoding: 'utf-8' }).trim();
+      console.log(chalk.green(`✓ GitHub Gist created: ${gistUrl}`));
+    } catch (error) {
+      console.error(chalk.red(`Failed to create Gist: ${error.message}`));
+    }
+  }
+}
+
 // CLI Commands
 program
   .name('flowmind')
@@ -52,7 +339,8 @@ program
 program
   .command('init')
   .description('Initialize FlowMind in current directory')
-  .action(async () => {
+  .option('--ai <provider>', 'Initialize with AI provider (openai/anthropic/glm/mimo/qwen/ernie/deepseek/ollama)')
+  .action(async (options) => {
     showBanner();
 
     const spinner = ora('Initializing FlowMind...').start();
@@ -68,7 +356,7 @@ program
       const configPath = path.join(configDir, 'config.json');
       if (!await fs.pathExists(configPath)) {
         const defaultConfig = {
-          version: '1.0.0',
+          version: '1.1.0',
           learning: {
             enabled: true,
             autoApply: true,
@@ -89,17 +377,100 @@ program
         await fs.writeJson(configPath, defaultConfig, { spaces: 2 });
       }
 
+      // Initialize AI if requested
+      if (options.ai) {
+        spinner.text = 'Configuring AI provider...';
+        const aiConfigPath = path.join(configDir, 'ai-config.json');
+
+        let aiConfig = {};
+        if (await fs.pathExists(aiConfigPath)) {
+          aiConfig = await fs.readJson(aiConfigPath);
+        }
+
+        // Set default provider
+        aiConfig.ai = aiConfig.ai || {};
+        aiConfig.ai.defaultProvider = options.ai;
+        aiConfig.ai.enabled = true;
+
+        // Prompt for API key based on provider
+        const apiKeyProviders = {
+          'openai': { key: 'apiKey', message: 'Enter OpenAI API key:', env: 'OPENAI_API_KEY' },
+          'anthropic': { key: 'apiKey', message: 'Enter Anthropic API key:', env: 'ANTHROPIC_API_KEY' },
+          'glm': { key: 'apiKey', message: 'Enter Zhipu AI API key:', env: 'ZHIPU_API_KEY' },
+          'mimo': { key: 'apiKey', message: 'Enter MiMo API key:', env: 'MIMO_API_KEY' },
+          'qwen': { key: 'apiKey', message: 'Enter DashScope API key:', env: 'DASHSCOPE_API_KEY' },
+          'ernie': { key: 'apiKey', message: 'Enter Baidu API key:', env: 'BAIDU_API_KEY' },
+          'deepseek': { key: 'apiKey', message: 'Enter DeepSeek API key:', env: 'DEEPSEEK_API_KEY' }
+        };
+
+        const providerConfig = apiKeyProviders[options.ai];
+        if (providerConfig) {
+          const { apiKey } = await inquirer.prompt([
+            {
+              type: 'password',
+              name: 'apiKey',
+              message: providerConfig.message,
+              mask: '*'
+            }
+          ]);
+
+          aiConfig.ai.providers = aiConfig.ai.providers || {};
+          aiConfig.ai.providers[options.ai] = {
+            ...aiConfig.ai.providers[options.ai],
+            apiKey: apiKey,
+            enabled: true
+          };
+
+          // For ERNIE, also prompt for secret key
+          if (options.ai === 'ernie') {
+            const { secretKey } = await inquirer.prompt([
+              {
+                type: 'password',
+                name: 'secretKey',
+                message: 'Enter Baidu Secret key:',
+                mask: '*'
+              }
+            ]);
+            aiConfig.ai.providers[options.ai].secretKey = secretKey;
+          }
+        }
+
+        await fs.writeJson(aiConfigPath, aiConfig, { spaces: 2 });
+        console.log(chalk.green(`\n✓ AI provider configured: ${options.ai}`));
+      }
+
       spinner.succeed('FlowMind initialized successfully!');
 
       console.log(chalk.green('\n✓ Configuration created at:'), configDir);
       console.log(chalk.green('✓ Learning system ready'));
       console.log(chalk.green('✓ Scene mapping ready'));
 
+      if (options.ai) {
+        console.log(chalk.green(`✓ AI provider configured: ${options.ai}`));
+      }
+
       console.log(chalk.cyan('\nNext steps:'));
       console.log('  1. Run', chalk.yellow('flowmind'), 'to start interactive mode');
       console.log('  2. Or use', chalk.yellow('flowmind "your request"'), 'for single commands');
       console.log('  3. FlowMind will learn from your corrections automatically');
 
+      if (!options.ai) {
+        console.log(chalk.cyan('\nTo enable AI features:'));
+        console.log('  Run', chalk.yellow('flowmind init --ai openai'), 'or', chalk.yellow('flowmind init --ai anthropic'));
+        console.log('  Or configure manually:', chalk.yellow('~/.flowmind/ai-config.json'));
+      }
+
+      // Award honor point for init
+      try {
+        const honorEngine = new HonorEngine({ get: (key, def) => def });
+        honorEngine.honorPath = path.join(configDir, 'honor.json');
+        await honorEngine.init();
+        await honorEngine.award('init', 'FlowMind initialized');
+        console.log(chalk.green('\n✓ Honor system activated (+1 point)'));
+      } catch (honorError) {
+        // Non-blocking
+      }
+
     } catch (error) {
       spinner.fail('Failed to initialize FlowMind');
       console.error(chalk.red(error.message));
@@ -373,6 +744,32 @@ program
     }
   });
 
+// Honor command
+program
+  .command('honor')
+  .description('Show honor points and dragon totem')
+  .option('-j, --json', 'Output as JSON')
+  .option('-p, --publish', 'Export honor data to JSON file')
+  .option('-g, --gist', 'Create GitHub Gist (with --publish)')
+  .option('-o, --output <file>', 'Output file path (default: flowmind-honor.json)')
+  .action(async (options) => {
+    try {
+      const fm = await initFlowMind();
+      const honorData = fm.getHonorData();
+
+      if (options.json) {
+        console.log(JSON.stringify(honorData, null, 2));
+      } else if (options.publish) {
+        await publishHonor({ output: options.output, gist: options.gist });
+      } else {
+        renderDragonTotem(honorData);
+        console.log(chalk.gray(`  ${getNextLevelHint(honorData.points)}`));
+      }
+    } catch (error) {
+      console.error(chalk.red('Error:'), error.message);
+    }
+  });
+
 // Config command
 program
   .command('config')
@@ -404,6 +801,82 @@ program
     }
   });
 
+// AI command
+program
+  .command('ai')
+  .description('Manage AI model configuration')
+  .option('-s, --status', 'Show AI model status')
+  .option('-l, --list', 'List available providers')
+  .option('-c, --config', 'Show AI configuration')
+  .option('-t, --test [provider]', 'Test AI provider connection')
+  .option('-j, --json', 'Output as JSON')
+  .action(async (options) => {
+    try {
+      const fm = await initFlowMind();
+
+      if (options.status) {
+        const status = fm.getAIStatus();
+        if (options.json) {
+          console.log(JSON.stringify(status, null, 2));
+        } else {
+          displayAIStatus(status);
+        }
+      } else if (options.list) {
+        const status = fm.getAIStatus();
+        const providers = Object.entries(status.providers).map(([name, info]) => ({
+          name,
+          ...info
+        }));
+        if (options.json) {
+          console.log(JSON.stringify({ providers }, null, 2));
+        } else {
+          console.log(chalk.cyan('\nAI Providers:'));
+          for (const provider of providers) {
+            const status = provider.initialized ? chalk.green('✓') : chalk.red('✗');
+            console.log(`  ${status} ${provider.name}`);
+            if (provider.info?.model) {
+              console.log(`    Model: ${provider.info.model}`);
+            }
+          }
+        }
+      } else if (options.config) {
+        const config = fm.config.get('ai', {});
+        if (options.json) {
+          console.log(JSON.stringify({ ai: config }, null, 2));
+        } else {
+          console.log(chalk.cyan('\nAI Configuration:'));
+          console.log(JSON.stringify(config, null, 2));
+        }
+      } else if (options.test !== undefined) {
+        const providerName = options.test || fm.ai.defaultProvider;
+        const provider = fm.ai.getProvider(providerName);
+        if (!provider) {
+          console.error(chalk.red(`Provider not found: ${providerName}`));
+          return;
+        }
+        console.log(chalk.cyan(`\nTesting ${providerName}...`));
+        try {
+          const result = await provider.complete('Hello, this is a test.', { maxTokens: 50 });
+          console.log(chalk.green('✓ Connection successful'));
+          console.log(chalk.white('Response:'), result.substring(0, 100) + '...');
+        } catch (error) {
+          console.log(chalk.red('✗ Connection failed'));
+          console.error(chalk.red(error.message));
+        }
+      } else {
+        // Default to status
+        const status = fm.getAIStatus();
+        if (options.json) {
+          console.log(JSON.stringify(status, null, 2));
+        } else {
+          displayAIStatus(status);
+        }
+      }
+    } catch (error) {
+      console.error(chalk.red('Error:'), error.message);
+    }
+  });
+
 // Interactive mode
 async function runInteractiveMode(fm) {
   showBanner();
@@ -802,6 +1275,39 @@ function displayResourceConfig(config) {
   console.log(chalk.cyan('└─────────────────────────────────────────────────────┘'));
 }
 
+function displayAIStatus(status) {
+  console.log(chalk.cyan('\n┌─────────────────────────────────────────────────────┐'));
+  console.log(chalk.cyan('│ AI Model Status                                     │'));
+  console.log(chalk.cyan('├─────────────────────────────────────────────────────┤'));
+
+  const initialized = status.initialized ? chalk.green('✓') : chalk.red('✗');
+  console.log(chalk.cyan(`│ Initialized: ${initialized}`));
+  console.log(chalk.cyan(`│ Default Provider: ${status.defaultProvider || 'None'}`));
+
+  console.log(chalk.cyan('├─────────────────────────────────────────────────────┤'));
+  console.log(chalk.cyan('│ Features:'));
+
+  const features = status.features || {};
+  for (const [feature, enabled] of Object.entries(features)) {
+    const statusIcon = enabled ? chalk.green('✓') : chalk.red('✗');
+    console.log(chalk.cyan(`│   ${statusIcon} ${feature}`));
+  }
+
+  console.log(chalk.cyan('├─────────────────────────────────────────────────────┤'));
+  console.log(chalk.cyan('│ Providers:'));
+
+  const providers = status.providers || {};
+  for (const [name, info] of Object.entries(providers)) {
+    const statusIcon = info.initialized ? chalk.green('✓') : chalk.red('✗');
+    console.log(chalk.cyan(`│   ${statusIcon} ${name}`));
+    if (info.info?.model) {
+      console.log(chalk.cyan(`│     Model: ${info.info.model}`));
+    }
+  }
+
+  console.log(chalk.cyan('└─────────────────────────────────────────────────────┘'));
+}
+
 function formatFileSize(bytes) {
   if (bytes === 0) return '0 B';
   const k = 1024;
@@ -832,6 +1338,136 @@ async function openInEditor(filePath) {
   });
 }
 
+// TUI command - Rich terminal interface using Ink
+program
+  .command('tui')
+  .description('Launch enhanced TUI with split panels, skill browser, and dragon display')
+  .action(async () => {
+    try {
+      // Register .jsx extension for CJS
+      require('module')._extensions['.jsx'] = require('module')._extensions['.js'];
+
+      const React = require('react');
+      const { render } = require('ink');
+      const App = require('../tui/app.jsx');
+
+      const fm = await initFlowMind();
+
+      const { unmount, waitUntilExit } = render(React.createElement(App, { flowmind: fm }));
+      await waitUntilExit();
+      unmount();
+    } catch (error) {
+      console.error(chalk.red('TUI Error:'), error.message);
+      if (error.message.includes('Cannot find module')) {
+        console.log(chalk.yellow('Try running: npm install ink@3 react ink-text-input ink-spinner'));
+      }
+    }
+  });
+
+// Dashboard command - Hybrid monitoring dashboard
+program
+  .command('dashboard')
+  .description('Launch real-time monitoring dashboard for MCP activity and events')
+  .action(async () => {
+    try {
+      // Register .jsx extension for CJS
+      require('module')._extensions['.jsx'] = require('module')._extensions['.js'];
+
+      const React = require('react');
+      const { render } = require('ink');
+      const DashboardApp = require('../dashboard/app.jsx');
+      const eventBus = require('../core/event-bus');
+
+      const fm = await initFlowMind();
+
+      const { unmount, waitUntilExit } = render(
+        React.createElement(DashboardApp, { flowmind: fm, eventBus })
+      );
+      await waitUntilExit();
+      unmount();
+    } catch (error) {
+      console.error(chalk.red('Dashboard Error:'), error.message);
+      if (error.message.includes('Cannot find module')) {
+        console.log(chalk.yellow('Try running: npm install ink@3 react'));
+      }
+    }
+  });
+
+// Update command - Auto-update flowmind
+program
+  .command('update')
+  .description('Update FlowMind to the latest version')
+  .option('--check', 'Only check for updates, do not install')
+  .action(async (options) => {
+    const { execSync } = require('child_process');
+    const currentVersion = packageJson.version;
+
+    console.log(chalk.cyan(`\nCurrent version: ${currentVersion}`));
+
+    try {
+      // Check latest version on npm
+      const latestVersion = execSync('npm view flowmind version', { encoding: 'utf-8' }).trim();
+      console.log(chalk.cyan(`Latest version:  ${latestVersion}`));
+
+      if (currentVersion === latestVersion) {
+        console.log(chalk.green('\n✓ You are already on the latest version!'));
+        return;
+      }
+
+      // Compare versions
+      const parse = (v) => v.split('.').map(Number);
+      const curr = parse(currentVersion);
+      const latest = parse(latestVersion);
+      const isNewer = latest[0] > curr[0] || (latest[0] === curr[0] && latest[1] > curr[1]) || (latest[0] === curr[0] && latest[1] === curr[1] && latest[2] > curr[2]);
+
+      if (!isNewer) {
+        console.log(chalk.green('\n✓ You are on a newer version than npm latest.'));
+        return;
+      }
+
+      console.log(chalk.yellow(`\n⬆ Update available: ${currentVersion} → ${latestVersion}`));
+
+      if (options.check) {
+        console.log(chalk.cyan('\nRun `flowmind update` to install.'));
+        return;
+      }
+
+      // Detect install method
+      const isGlobal = (() => {
+        try {
+          const globalRoot = execSync('npm root -g', { encoding: 'utf-8' }).trim();
+          const localPath = require.resolve('../package.json');
+          return localPath.startsWith(globalRoot);
+        } catch { return false; }
+      })();
+
+      const installCmd = isGlobal
+        ? `npm install -g flowmind@${latestVersion}`
+        : `npm install flowmind@${latestVersion}`;
+
+      console.log(chalk.cyan(`\nInstalling: ${installCmd}`));
+      const spinner = ora('Updating FlowMind...').start();
+
+      try {
+        execSync(installCmd, { encoding: 'utf-8', stdio: 'pipe' });
+        spinner.succeed(`FlowMind updated to ${latestVersion}!`);
+
+        console.log(chalk.green('\n✓ Update complete!'));
+        console.log(chalk.gray('  Run `flowmind --version` to verify.'));
+      } catch (installError) {
+        spinner.fail('Update failed');
+        console.error(chalk.red('\nInstall error:'), installError.message);
+        console.log(chalk.yellow('\nTry manually:'));
+        console.log(chalk.white(`  ${installCmd}`));
+      }
+
+    } catch (error) {
+      console.error(chalk.red('Failed to check for updates:'), error.message);
+      console.log(chalk.yellow('\nYou can manually update with:'));
+      console.log(chalk.white('  npm install -g flowmind@latest'));
+    }
+  });
+
 // Parse arguments
 program.parse(process.argv);