flowmind 1.0.0 → 1.1.0

package/bin/flowmind.js

@@ -52,7 +52,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 +69,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 +90,89 @@ 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'));
+      }
+
     } catch (error) {
       spinner.fail('Failed to initialize FlowMind');
       console.error(chalk.red(error.message));
@@ -215,15 +288,145 @@ program
     }
   });
 
-// Skills command
+// Skills command (enhanced)
 program
   .command('skills')
   .description('List available skills')
-  .action(async () => {
+  .option('-j, --json', 'Output as JSON (for tool integration)')
+  .option('-v, --verbose', 'Show detailed information')
+  .option('-c, --category <category>', 'Filter by category')
+  .action(async (options) => {
     try {
       const fm = await initFlowMind();
       const skills = fm.skills.list();
-      displaySkills(skills);
+
+      // Filter by category if specified
+      const filtered = options.category
+        ? skills.filter(s => s.category === options.category)
+        : skills;
+
+      if (options.json) {
+        // JSON output for codex/claude integration
+        console.log(JSON.stringify({ skills: filtered }, null, 2));
+      } else {
+        displaySkills(filtered, options.verbose);
+      }
+    } catch (error) {
+      console.error(chalk.red('Error:'), error.message);
+    }
+  });
+
+// Skill command (view/modify single skill)
+program
+  .command('skill <name>')
+  .description('View or modify skill configuration')
+  .option('-i, --info', 'Show skill info (default)')
+  .option('-c, --config', 'Show/edit skill configuration')
+  .option('-s, --set <key> <value>', 'Set config value')
+  .option('-r, --read', 'Read SKILL.md content')
+  .option('-e, --edit', 'Open SKILL.md in editor')
+  .option('-j, --json', 'Output as JSON (for tool integration)')
+  .action(async (name, options) => {
+    try {
+      const fm = await initFlowMind();
+      const skill = fm.skills.get(name);
+
+      if (!skill) {
+        console.error(chalk.red(`Skill not found: ${name}`));
+        console.log(chalk.cyan('\nAvailable skills:'));
+        fm.skills.list().forEach(s => console.log(`  - ${s.name}`));
+        return;
+      }
+
+      // Default to info if no option specified
+      if (!options.config && !options.read && !options.edit && !options.set) {
+        options.info = true;
+      }
+
+      if (options.info) {
+        await showSkillInfo(skill, options.json);
+      } else if (options.read) {
+        await readSkillMd(skill);
+      } else if (options.edit) {
+        await editSkillMd(skill);
+      } else if (options.config) {
+        await showSkillConfig(skill, fm, options.json);
+      } else if (options.set) {
+        // options.set is the key, need value from next arg
+        const value = options.set;
+        const key = options.set;
+        // Get key and value from command line
+        const args = process.argv.slice(3);
+        if (args.length >= 2) {
+          await setSkillConfig(skill, fm, args[0], args[1]);
+        } else {
+          console.error(chalk.red('Usage: flowmind skill <name> --set <key> <value>'));
+        }
+      }
+    } catch (error) {
+      console.error(chalk.red('Error:'), error.message);
+    }
+  });
+
+// Resource command (local resource files)
+program
+  .command('resource')
+  .alias('res')
+  .description('Manage local resource files')
+  .option('-l, --list [dir]', 'List resource directory')
+  .option('-s, --show <file>', 'Show file content')
+  .option('-e, --edit <file>', 'Edit file')
+  .option('-c, --config', 'Show resource configuration')
+  .option('-j, --json', 'Output as JSON (for tool integration)')
+  .action(async (options) => {
+    try {
+      const fm = await initFlowMind();
+      const resourceConfig = fm.config.get('resources', {});
+      const configDir = path.join(process.env.HOME || process.env.USERPROFILE, '.flowmind');
+
+      if (options.config) {
+        // Show resource configuration
+        if (options.json) {
+          console.log(JSON.stringify({ resources: resourceConfig }, null, 2));
+        } else {
+          displayResourceConfig(resourceConfig);
+        }
+      } else if (options.show) {
+        // Show file content
+        const filePath = resolveResourcePath(options.show, configDir);
+        if (await fs.pathExists(filePath)) {
+          const content = await fs.readFile(filePath, 'utf-8');
+          if (options.json) {
+            console.log(JSON.stringify({ file: options.show, content }, null, 2));
+          } else {
+            console.log(chalk.cyan(`\n📄 ${options.show}`));
+            console.log(chalk.gray('─'.repeat(50)));
+            console.log(content);
+          }
+        } else {
+          console.error(chalk.red(`File not found: ${options.show}`));
+        }
+      } else if (options.edit) {
+        // Edit file
+        const filePath = resolveResourcePath(options.edit, configDir);
+        await openInEditor(filePath);
+      } else {
+        // List directory (default)
+        const targetDir = options.list && typeof options.list === 'string'
+          ? resolveResourcePath(options.list, configDir)
+          : configDir;
+
+        if (await fs.pathExists(targetDir)) {
+          const files = await listResourceFiles(targetDir, configDir);
+          if (options.json) {
+            console.log(JSON.stringify({ directory: targetDir, files }, null, 2));
+          } else {
+            displayResourceFiles(files, targetDir);
+          }
+        } else {
+          console.error(chalk.red(`Directory not found: ${targetDir}`));
+        }
+      }
     } catch (error) {
       console.error(chalk.red('Error:'), error.message);
     }
@@ -274,6 +477,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();
@@ -432,22 +711,309 @@ function displayScenes(scenes) {
   console.log(chalk.cyan('└─────────────────────────────────────────────────────┘'));
 }
 
-function displaySkills(skills) {
+function displaySkills(skills, verbose = false) {
   console.log(chalk.cyan('\n┌─────────────────────────────────────────────────────┐'));
   console.log(chalk.cyan('│ Available Skills                                    │'));
   console.log(chalk.cyan('├─────────────────────────────────────────────────────┤'));
 
   for (const skill of skills) {
-    console.log(chalk.cyan(`│ ${skill.name}`));
+    console.log(chalk.cyan(`│ ${chalk.bold(skill.name)}`));
     if (skill.description) {
-      console.log(chalk.cyan(`│   ${skill.description.substring(0, 50)}...`));
+      const desc = verbose ? skill.description : skill.description.substring(0, 50) + '...';
+      console.log(chalk.cyan(`│   ${desc}`));
+    }
+    if (verbose && skill.category) {
+      console.log(chalk.cyan(`│   Category: ${skill.category}`));
+    }
+    console.log(chalk.cyan('├─────────────────────────────────────────────────────┤'));
+  }
+
+  console.log(chalk.cyan('└─────────────────────────────────────────────────────┘'));
+}
+
+// Skill info display
+async function showSkillInfo(skill, asJson = false) {
+  const info = {
+    name: skill.name,
+    path: skill.path,
+    description: skill.definition?.description || 'No description',
+    version: skill.definition?.version || skill.definition?.metadata?.version || '1.0.0',
+    author: skill.definition?.author || skill.definition?.metadata?.author || 'unknown',
+    category: skill.definition?.category || skill.definition?.metadata?.category || 'general',
+    componentDependencies: skill.definition?.componentDependencies || [],
+    triggers: skill.definition?.triggers || []
+  };
+
+  if (asJson) {
+    console.log(JSON.stringify(info, null, 2));
+  } else {
+    console.log(chalk.cyan('\n┌─────────────────────────────────────────────────────┐'));
+    console.log(chalk.cyan(`│ ${chalk.bold(info.name)}`));
+    console.log(chalk.cyan('├─────────────────────────────────────────────────────┤'));
+    console.log(chalk.cyan(`│ Description: ${info.description}`));
+    console.log(chalk.cyan(`│ Version:     ${info.version}`));
+    console.log(chalk.cyan(`│ Author:      ${info.author}`));
+    console.log(chalk.cyan(`│ Category:    ${info.category}`));
+    console.log(chalk.cyan(`│ Path:        ${info.path}`));
+
+    if (info.componentDependencies.length > 0) {
+      console.log(chalk.cyan('├─────────────────────────────────────────────────────┤'));
+      console.log(chalk.cyan('│ Component Dependencies:'));
+      for (const dep of info.componentDependencies) {
+        console.log(chalk.cyan(`│   - ${dep}`));
+      }
+    }
+
+    if (info.triggers.length > 0) {
+      console.log(chalk.cyan('├─────────────────────────────────────────────────────┤'));
+      console.log(chalk.cyan('│ Trigger Patterns:'));
+      for (const trigger of info.triggers.slice(0, 10)) {
+        console.log(chalk.cyan(`│   - ${trigger}`));
+      }
+      if (info.triggers.length > 10) {
+        console.log(chalk.cyan(`│   ... and ${info.triggers.length - 10} more`));
+      }
     }
+
+    console.log(chalk.cyan('└─────────────────────────────────────────────────────┘'));
+  }
+}
+
+// Read SKILL.md content
+async function readSkillMd(skill) {
+  const skillMdPath = path.join(skill.path, 'SKILL.md');
+  if (await fs.pathExists(skillMdPath)) {
+    const content = await fs.readFile(skillMdPath, 'utf-8');
+    console.log(chalk.cyan(`\n📄 ${skill.name}/SKILL.md`));
+    console.log(chalk.gray('─'.repeat(50)));
+    console.log(content);
+  } else {
+    console.error(chalk.red('SKILL.md not found'));
+  }
+}
+
+// Edit SKILL.md
+async function editSkillMd(skill) {
+  const skillMdPath = path.join(skill.path, 'SKILL.md');
+  await openInEditor(skillMdPath);
+}
+
+// Show skill configuration
+async function showSkillConfig(skill, fm, asJson = false) {
+  const configKey = skill.name;
+  const config = fm.config.get(configKey, {});
+
+  if (asJson) {
+    console.log(JSON.stringify({ skill: skill.name, config }, null, 2));
+  } else {
+    console.log(chalk.cyan(`\n┌─────────────────────────────────────────────────────┐`));
+    console.log(chalk.cyan(`│ ${skill.name} Configuration`));
     console.log(chalk.cyan('├─────────────────────────────────────────────────────┤'));
+
+    if (Object.keys(config).length === 0) {
+      console.log(chalk.cyan('│ No configuration set'));
+      console.log(chalk.cyan('│'));
+      console.log(chalk.cyan('│ Default configuration from SKILL.md:'));
+
+      // Extract default config from SKILL.md
+      const skillMdPath = path.join(skill.path, 'SKILL.md');
+      if (await fs.pathExists(skillMdPath)) {
+        const content = await fs.readFile(skillMdPath, 'utf-8');
+        const configMatch = content.match(/## Configuration\n([\s\S]*?)(?=\n##|$)/);
+        if (configMatch) {
+          const configSection = configMatch[1].trim();
+          const lines = configSection.split('\n').slice(0, 15);
+          for (const line of lines) {
+            console.log(chalk.cyan(`│ ${line}`));
+          }
+        }
+      }
+    } else {
+      const configJson = JSON.stringify(config, null, 2);
+      configJson.split('\n').forEach(line => {
+        console.log(chalk.cyan(`│ ${line}`));
+      });
+    }
+
+    console.log(chalk.cyan('└─────────────────────────────────────────────────────┘'));
+  }
+}
+
+// Set skill configuration
+async function setSkillConfig(skill, fm, key, value) {
+  const configKey = skill.name;
+  const config = fm.config.get(configKey, {});
+
+  // Support nested keys like "security.enabled"
+  const keys = key.split('.');
+  let current = config;
+  for (let i = 0; i < keys.length - 1; i++) {
+    if (!current[keys[i]]) current[keys[i]] = {};
+    current = current[keys[i]];
+  }
+
+  // Try to parse value as JSON, fallback to string
+  let parsedValue;
+  try {
+    parsedValue = JSON.parse(value);
+  } catch {
+    parsedValue = value;
+  }
+
+  current[keys[keys.length - 1]] = parsedValue;
+  fm.config.set(configKey, config);
+  await fm.config.save();
+
+  console.log(chalk.green(`✓ Set ${skill.name}.${key} = ${value}`));
+}
+
+// Resource file helpers
+function resolveResourcePath(filePath, configDir) {
+  // If absolute path, use as-is
+  if (path.isAbsolute(filePath)) {
+    return filePath;
+  }
+  // Otherwise resolve relative to config dir
+  return path.join(configDir, filePath);
+}
+
+async function listResourceFiles(dir, configDir) {
+  const files = [];
+  const entries = await fs.readdir(dir);
+
+  for (const entry of entries) {
+    const fullPath = path.join(dir, entry);
+    const stat = await fs.stat(fullPath);
+    const relativePath = path.relative(configDir, fullPath);
+
+    if (stat.isDirectory()) {
+      files.push({
+        name: entry,
+        path: relativePath,
+        type: 'directory',
+        size: 0
+      });
+    } else {
+      files.push({
+        name: entry,
+        path: relativePath,
+        type: 'file',
+        size: stat.size,
+        modified: stat.mtime
+      });
+    }
+  }
+
+  return files.sort((a, b) => {
+    if (a.type === b.type) return a.name.localeCompare(b.name);
+    return a.type === 'directory' ? -1 : 1;
+  });
+}
+
+function displayResourceFiles(files, dir) {
+  console.log(chalk.cyan(`\n📁 ${dir}`));
+  console.log(chalk.gray('─'.repeat(50)));
+
+  if (files.length === 0) {
+    console.log(chalk.cyan('  (empty)'));
+    return;
+  }
+
+  for (const file of files) {
+    if (file.type === 'directory') {
+      console.log(chalk.blue(`  📁 ${file.name}/`));
+    } else {
+      const size = formatFileSize(file.size);
+      console.log(chalk.white(`  📄 ${file.name}`) + chalk.gray(` (${size})`));
+    }
+  }
+}
+
+function displayResourceConfig(config) {
+  console.log(chalk.cyan('\n┌─────────────────────────────────────────────────────┐'));
+  console.log(chalk.cyan('│ Resource Configuration                              │'));
+  console.log(chalk.cyan('├─────────────────────────────────────────────────────┤'));
+
+  const entries = Object.entries(config);
+  if (entries.length === 0) {
+    console.log(chalk.cyan('│ No resources configured'));
+  } else {
+    for (const [key, value] of entries) {
+      const enabled = value.enabled !== false;
+      const status = enabled ? chalk.green('✓') : chalk.red('✗');
+      console.log(chalk.cyan(`│ ${status} ${key}`));
+      if (value.path) {
+        console.log(chalk.cyan(`│   Path: ${value.path}`));
+      }
+    }
+  }
+
+  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;
+  const sizes = ['B', 'KB', 'MB', 'GB'];
+  const i = Math.floor(Math.log(bytes) / Math.log(k));
+  return parseFloat((bytes / Math.pow(k, i)).toFixed(1)) + ' ' + sizes[i];
+}
+
+async function openInEditor(filePath) {
+  const { spawn } = require('child_process');
+  const editor = process.env.EDITOR || process.env.VISUAL || 'vi';
+
+  console.log(chalk.cyan(`Opening ${filePath} in ${editor}...`));
+
+  return new Promise((resolve, reject) => {
+    const child = spawn(editor, [filePath], {
+      stdio: 'inherit',
+      shell: true
+    });
+
+    child.on('close', (code) => {
+      if (code === 0) {
+        resolve();
+      } else {
+        reject(new Error(`Editor exited with code ${code}`));
+      }
+    });
+  });
+}
+
 // Parse arguments
 program.parse(process.argv);