ruvector 0.1.46 → 0.1.48

package/bin/cli.js

@@ -2311,7 +2311,9 @@ hooksCmd.command('init')
   .option('--no-gitignore', 'Skip .gitignore update')
   .option('--no-mcp', 'Skip MCP server configuration')
   .option('--no-statusline', 'Skip statusLine configuration')
-  .action((opts) => {
+  .option('--pretrain', 'Run pretrain after init to bootstrap intelligence')
+  .option('--build-agents [focus]', 'Generate optimized agents (quality|speed|security|testing|fullstack)')
+  .action(async (opts) => {
   const settingsPath = path.join(process.cwd(), '.claude', 'settings.json');
   const settingsDir = path.dirname(settingsPath);
   if (!fs.existsSync(settingsDir)) fs.mkdirSync(settingsDir, { recursive: true });
@@ -2353,7 +2355,8 @@ hooksCmd.command('init')
       'Bash(rm -rf /)',
       'Bash(sudo rm:*)',
       'Bash(chmod 777:*)',
-      'Bash(:(){ :|:& };:)'
+      'Bash(mkfs:*)',
+      'Bash(dd if=/dev/zero:*)'
     ];
     console.log(chalk.blue('  ✓ Permissions configured (project-specific)'));
   }
@@ -2572,7 +2575,35 @@ npx ruvector hooks init --force      # Overwrite existing
   }
 
   console.log(chalk.green('\n✅ RuVector hooks initialization complete!'));
-  console.log(chalk.dim('   Run `npx ruvector hooks verify` to test the setup'));
+
+  // Run pretrain if requested
+  if (opts.pretrain) {
+    console.log(chalk.yellow('\n📚 Running pretrain to bootstrap intelligence...\n'));
+    const { execSync } = require('child_process');
+    try {
+      execSync('npx ruvector hooks pretrain', { stdio: 'inherit' });
+    } catch (e) {
+      console.log(chalk.yellow('⚠️  Pretrain completed with warnings'));
+    }
+  }
+
+  // Build agents if requested
+  if (opts.buildAgents) {
+    const focus = typeof opts.buildAgents === 'string' ? opts.buildAgents : 'quality';
+    console.log(chalk.yellow(`\n🏗️  Building optimized agents (focus: ${focus})...\n`));
+    const { execSync } = require('child_process');
+    try {
+      execSync(`npx ruvector hooks build-agents --focus ${focus} --include-prompts`, { stdio: 'inherit' });
+    } catch (e) {
+      console.log(chalk.yellow('⚠️  Agent build completed with warnings'));
+    }
+  }
+
+  if (!opts.pretrain && !opts.buildAgents) {
+    console.log(chalk.dim('   Run `npx ruvector hooks verify` to test the setup'));
+    console.log(chalk.dim('   Run `npx ruvector hooks pretrain` to bootstrap intelligence'));
+    console.log(chalk.dim('   Run `npx ruvector hooks build-agents` to generate optimized agents'));
+  }
 });
 
 hooksCmd.command('stats').description('Show intelligence statistics').action(() => {
@@ -2996,4 +3027,585 @@ hooksCmd.command('import')
     }
   });
 
+// Pretrain - analyze repo and bootstrap learning with agent swarm
+hooksCmd.command('pretrain')
+  .description('Pretrain intelligence by analyzing the repository with agent swarm')
+  .option('--depth <n>', 'Git history depth to analyze', '100')
+  .option('--workers <n>', 'Number of parallel analysis workers', '4')
+  .option('--skip-git', 'Skip git history analysis')
+  .option('--skip-files', 'Skip file structure analysis')
+  .option('--verbose', 'Show detailed progress')
+  .action(async (opts) => {
+    const { execSync, spawn } = require('child_process');
+    console.log(chalk.bold.cyan('\n🧠 RuVector Pretrain - Repository Intelligence Bootstrap\n'));
+
+    const intel = new Intelligence();
+    const startTime = Date.now();
+    const stats = { files: 0, patterns: 0, memories: 0, coedits: 0 };
+
+    // Agent types for different file patterns
+    const agentMapping = {
+      // Rust
+      '.rs': 'rust-developer',
+      'Cargo.toml': 'rust-developer',
+      'Cargo.lock': 'rust-developer',
+      // JavaScript/TypeScript
+      '.js': 'javascript-developer',
+      '.jsx': 'react-developer',
+      '.ts': 'typescript-developer',
+      '.tsx': 'react-developer',
+      '.mjs': 'javascript-developer',
+      '.cjs': 'javascript-developer',
+      'package.json': 'node-developer',
+      // Python
+      '.py': 'python-developer',
+      'requirements.txt': 'python-developer',
+      'pyproject.toml': 'python-developer',
+      'setup.py': 'python-developer',
+      // Go
+      '.go': 'go-developer',
+      'go.mod': 'go-developer',
+      // Web
+      '.html': 'frontend-developer',
+      '.css': 'frontend-developer',
+      '.scss': 'frontend-developer',
+      '.vue': 'vue-developer',
+      '.svelte': 'svelte-developer',
+      // Config
+      '.json': 'config-specialist',
+      '.yaml': 'config-specialist',
+      '.yml': 'config-specialist',
+      '.toml': 'config-specialist',
+      // Docs
+      '.md': 'documentation-specialist',
+      '.mdx': 'documentation-specialist',
+      // Tests
+      '.test.js': 'test-engineer',
+      '.test.ts': 'test-engineer',
+      '.spec.js': 'test-engineer',
+      '.spec.ts': 'test-engineer',
+      '_test.go': 'test-engineer',
+      '_test.rs': 'test-engineer',
+      // DevOps
+      'Dockerfile': 'devops-engineer',
+      'docker-compose.yml': 'devops-engineer',
+      '.github/workflows': 'cicd-engineer',
+      'Makefile': 'devops-engineer',
+      // SQL
+      '.sql': 'database-specialist',
+    };
+
+    // Phase 1: Analyze file structure
+    if (!opts.skipFiles) {
+      console.log(chalk.yellow('📁 Phase 1: Analyzing file structure...\n'));
+
+      try {
+        // Get all files in repo
+        const files = execSync('git ls-files 2>/dev/null || find . -type f -not -path "./.git/*" -not -path "./node_modules/*" -not -path "./target/*"',
+          { encoding: 'utf-8', maxBuffer: 50 * 1024 * 1024 }).trim().split('\n').filter(f => f);
+
+        const filesByType = {};
+        const dirPatterns = {};
+
+        files.forEach(file => {
+          stats.files++;
+          const ext = path.extname(file);
+          const basename = path.basename(file);
+          const dir = path.dirname(file);
+
+          // Determine agent for this file
+          let agent = 'coder'; // default
+          if (agentMapping[basename]) {
+            agent = agentMapping[basename];
+          } else if (agentMapping[ext]) {
+            agent = agentMapping[ext];
+          } else if (file.includes('.test.') || file.includes('.spec.') || file.includes('_test.')) {
+            agent = 'test-engineer';
+          } else if (file.includes('.github/workflows')) {
+            agent = 'cicd-engineer';
+          }
+
+          // Track file types
+          filesByType[ext] = (filesByType[ext] || 0) + 1;
+
+          // Track directory patterns
+          const parts = dir.split('/');
+          if (parts[0]) {
+            dirPatterns[parts[0]] = dirPatterns[parts[0]] || { count: 0, agents: {} };
+            dirPatterns[parts[0]].count++;
+            dirPatterns[parts[0]].agents[agent] = (dirPatterns[parts[0]].agents[agent] || 0) + 1;
+          }
+
+          // Create Q-learning pattern for this file type
+          const state = `edit:${ext || 'unknown'}`;
+          if (!intel.data.patterns[state]) {
+            intel.data.patterns[state] = {};
+          }
+          intel.data.patterns[state][agent] = (intel.data.patterns[state][agent] || 0) + 0.5;
+          stats.patterns++;
+        });
+
+        // Log summary
+        if (opts.verbose) {
+          console.log(chalk.dim('  File types found:'));
+          Object.entries(filesByType).sort((a, b) => b[1] - a[1]).slice(0, 10).forEach(([ext, count]) => {
+            console.log(chalk.dim(`    ${ext || '(no ext)'}: ${count} files`));
+          });
+        }
+        console.log(chalk.green(`  ✓ Analyzed ${stats.files} files`));
+        console.log(chalk.green(`  ✓ Created ${Object.keys(intel.data.patterns).length} routing patterns`));
+
+      } catch (e) {
+        console.log(chalk.yellow(`  ⚠ File analysis skipped: ${e.message}`));
+      }
+    }
+
+    // Phase 2: Analyze git history for co-edit patterns
+    if (!opts.skipGit) {
+      console.log(chalk.yellow('\n📜 Phase 2: Analyzing git history for co-edit patterns...\n'));
+
+      try {
+        // Get commits with files changed
+        const gitLog = execSync(
+          `git log --name-only --pretty=format:"COMMIT:%H" -n ${opts.depth} 2>/dev/null`,
+          { encoding: 'utf-8', maxBuffer: 50 * 1024 * 1024 }
+        );
+
+        const commits = gitLog.split('COMMIT:').filter(c => c.trim());
+        const coEditMap = {};
+
+        commits.forEach(commit => {
+          const lines = commit.trim().split('\n').filter(l => l && !l.startsWith('COMMIT:'));
+          const files = lines.slice(1).filter(f => f.trim()); // Skip the hash
+
+          // Track which files are edited together
+          files.forEach(file1 => {
+            files.forEach(file2 => {
+              if (file1 !== file2) {
+                const key = [file1, file2].sort().join('|');
+                coEditMap[key] = (coEditMap[key] || 0) + 1;
+              }
+            });
+          });
+        });
+
+        // Find strong co-edit patterns (files edited together 3+ times)
+        const strongPatterns = Object.entries(coEditMap)
+          .filter(([, count]) => count >= 3)
+          .sort((a, b) => b[1] - a[1]);
+
+        // Store as sequence patterns
+        strongPatterns.slice(0, 100).forEach(([key, count]) => {
+          const [file1, file2] = key.split('|');
+          if (!intel.data.sequences) intel.data.sequences = {};
+          if (!intel.data.sequences[file1]) intel.data.sequences[file1] = [];
+
+          const existing = intel.data.sequences[file1].find(s => s.file === file2);
+          if (existing) {
+            existing.score += count;
+          } else {
+            intel.data.sequences[file1].push({ file: file2, score: count });
+          }
+          stats.coedits++;
+        });
+
+        console.log(chalk.green(`  ✓ Analyzed ${commits.length} commits`));
+        console.log(chalk.green(`  ✓ Found ${strongPatterns.length} co-edit patterns`));
+
+        if (opts.verbose && strongPatterns.length > 0) {
+          console.log(chalk.dim('  Top co-edit patterns:'));
+          strongPatterns.slice(0, 5).forEach(([key, count]) => {
+            const [f1, f2] = key.split('|');
+            console.log(chalk.dim(`    ${path.basename(f1)} ↔ ${path.basename(f2)}: ${count} times`));
+          });
+        }
+
+      } catch (e) {
+        console.log(chalk.yellow(`  ⚠ Git analysis skipped: ${e.message}`));
+      }
+    }
+
+    // Phase 3: Create vector memories from important files
+    console.log(chalk.yellow('\n💾 Phase 3: Creating vector memories from key files...\n'));
+
+    try {
+      const importantFiles = [
+        'README.md', 'CLAUDE.md', 'package.json', 'Cargo.toml',
+        'pyproject.toml', 'go.mod', '.claude/settings.json'
+      ];
+
+      for (const filename of importantFiles) {
+        const filePath = path.join(process.cwd(), filename);
+        if (fs.existsSync(filePath)) {
+          try {
+            const content = fs.readFileSync(filePath, 'utf-8').slice(0, 2000); // First 2KB
+            intel.data.memories = intel.data.memories || [];
+            intel.data.memories.push({
+              content: `[${filename}] ${content.replace(/\n/g, ' ').slice(0, 500)}`,
+              type: 'project',
+              created: new Date().toISOString(),
+              embedding: intel.simpleEmbed ? intel.simpleEmbed(content) : null
+            });
+            stats.memories++;
+            if (opts.verbose) console.log(chalk.dim(`    ✓ ${filename}`));
+          } catch (e) { /* skip unreadable files */ }
+        }
+      }
+
+      console.log(chalk.green(`  ✓ Created ${stats.memories} memory entries`));
+
+    } catch (e) {
+      console.log(chalk.yellow(`  ⚠ Memory creation skipped: ${e.message}`));
+    }
+
+    // Phase 4: Analyze directory structure for agent recommendations
+    console.log(chalk.yellow('\n🗂️  Phase 4: Building directory-agent mappings...\n'));
+
+    try {
+      const dirs = execSync('find . -type d -maxdepth 2 -not -path "./.git*" -not -path "./node_modules*" -not -path "./target*" 2>/dev/null || echo "."',
+        { encoding: 'utf-8' }).trim().split('\n');
+
+      const dirAgentMap = {};
+      dirs.forEach(dir => {
+        const name = path.basename(dir);
+        // Infer agent from directory name
+        if (['src', 'lib', 'core'].includes(name)) dirAgentMap[dir] = 'coder';
+        else if (['test', 'tests', '__tests__', 'spec'].includes(name)) dirAgentMap[dir] = 'test-engineer';
+        else if (['docs', 'documentation'].includes(name)) dirAgentMap[dir] = 'documentation-specialist';
+        else if (['scripts', 'bin'].includes(name)) dirAgentMap[dir] = 'devops-engineer';
+        else if (['components', 'views', 'pages'].includes(name)) dirAgentMap[dir] = 'frontend-developer';
+        else if (['api', 'routes', 'handlers'].includes(name)) dirAgentMap[dir] = 'backend-developer';
+        else if (['models', 'entities', 'schemas'].includes(name)) dirAgentMap[dir] = 'database-specialist';
+        else if (['.github', '.gitlab', 'ci'].includes(name)) dirAgentMap[dir] = 'cicd-engineer';
+      });
+
+      // Store directory patterns
+      intel.data.dirPatterns = dirAgentMap;
+      console.log(chalk.green(`  ✓ Mapped ${Object.keys(dirAgentMap).length} directories to agents`));
+
+    } catch (e) {
+      console.log(chalk.yellow(`  ⚠ Directory analysis skipped: ${e.message}`));
+    }
+
+    // Save all learning data
+    intel.data.pretrained = {
+      date: new Date().toISOString(),
+      stats: stats
+    };
+    intel.save();
+
+    const elapsed = ((Date.now() - startTime) / 1000).toFixed(1);
+    console.log(chalk.bold.green(`\n✅ Pretrain complete in ${elapsed}s!\n`));
+    console.log(chalk.cyan('Summary:'));
+    console.log(`  📁 ${stats.files} files analyzed`);
+    console.log(`  🧠 ${stats.patterns} agent routing patterns`);
+    console.log(`  🔗 ${stats.coedits} co-edit patterns`);
+    console.log(`  💾 ${stats.memories} memory entries`);
+    console.log(chalk.dim('\nThe intelligence layer will now provide better recommendations.'));
+  });
+
+// Agent Builder - generate optimized agent configs based on pretrain
+hooksCmd.command('build-agents')
+  .description('Generate optimized agent configurations based on repository analysis')
+  .option('--focus <type>', 'Focus type: quality, speed, security, testing, fullstack', 'quality')
+  .option('--output <dir>', 'Output directory', '.claude/agents')
+  .option('--format <fmt>', 'Format: yaml, json, md', 'yaml')
+  .option('--include-prompts', 'Include detailed system prompts')
+  .action((opts) => {
+    console.log(chalk.bold.cyan('\n🏗️  RuVector Agent Builder\n'));
+
+    const intel = new Intelligence();
+    const outputDir = path.join(process.cwd(), opts.output);
+
+    // Check if pretrained
+    if (!intel.data.pretrained && Object.keys(intel.data.patterns || {}).length === 0) {
+      console.log(chalk.yellow('⚠️  No pretrain data found. Running quick analysis...\n'));
+      // Quick file analysis
+      try {
+        const { execSync } = require('child_process');
+        const files = execSync('git ls-files 2>/dev/null', { encoding: 'utf-8' }).trim().split('\n');
+        files.forEach(f => {
+          const ext = path.extname(f);
+          intel.data.patterns = intel.data.patterns || {};
+          intel.data.patterns[`edit:${ext}`] = intel.data.patterns[`edit:${ext}`] || {};
+        });
+      } catch (e) { /* continue without git */ }
+    }
+
+    // Analyze patterns to determine relevant agents
+    const patterns = intel.data.patterns || {};
+    const detectedLangs = new Set();
+    const detectedFrameworks = new Set();
+
+    Object.keys(patterns).forEach(state => {
+      if (state.includes('.rs')) detectedLangs.add('rust');
+      if (state.includes('.ts') || state.includes('.js')) detectedLangs.add('typescript');
+      if (state.includes('.tsx') || state.includes('.jsx')) detectedFrameworks.add('react');
+      if (state.includes('.py')) detectedLangs.add('python');
+      if (state.includes('.go')) detectedLangs.add('go');
+      if (state.includes('.vue')) detectedFrameworks.add('vue');
+      if (state.includes('.sql')) detectedFrameworks.add('database');
+    });
+
+    // Detect project type from files
+    const projectTypes = detectProjectType();
+
+    console.log(chalk.blue(`  Detected languages: ${[...detectedLangs].join(', ') || 'generic'}`));
+    console.log(chalk.blue(`  Detected frameworks: ${[...detectedFrameworks].join(', ') || 'none'}`));
+    console.log(chalk.blue(`  Focus mode: ${opts.focus}\n`));
+
+    // Focus configurations
+    const focusConfigs = {
+      quality: {
+        description: 'Emphasizes code quality, best practices, and maintainability',
+        priorities: ['code-review', 'refactoring', 'documentation', 'testing'],
+        temperature: 0.3
+      },
+      speed: {
+        description: 'Optimized for rapid development and iteration',
+        priorities: ['implementation', 'prototyping', 'quick-fixes'],
+        temperature: 0.7
+      },
+      security: {
+        description: 'Security-first development with vulnerability awareness',
+        priorities: ['security-audit', 'input-validation', 'authentication', 'encryption'],
+        temperature: 0.2
+      },
+      testing: {
+        description: 'Test-driven development with comprehensive coverage',
+        priorities: ['unit-tests', 'integration-tests', 'e2e-tests', 'mocking'],
+        temperature: 0.4
+      },
+      fullstack: {
+        description: 'Balanced full-stack development capabilities',
+        priorities: ['frontend', 'backend', 'database', 'api-design'],
+        temperature: 0.5
+      }
+    };
+
+    const focus = focusConfigs[opts.focus] || focusConfigs.quality;
+
+    // Agent templates based on detected stack
+    const agents = [];
+
+    // Core agents based on detected languages
+    if (detectedLangs.has('rust')) {
+      agents.push({
+        name: 'rust-specialist',
+        type: 'rust-developer',
+        description: 'Rust development specialist for this codebase',
+        capabilities: ['cargo', 'unsafe-rust', 'async-rust', 'wasm', 'error-handling'],
+        focus: focus.priorities,
+        systemPrompt: opts.includePrompts ? `You are a Rust specialist for this project.
+Focus on: memory safety, zero-cost abstractions, idiomatic Rust patterns.
+Use cargo conventions, prefer Result over panic, leverage the type system.
+${focus.description}` : null
+      });
+    }
+
+    if (detectedLangs.has('typescript')) {
+      agents.push({
+        name: 'typescript-specialist',
+        type: 'typescript-developer',
+        description: 'TypeScript development specialist',
+        capabilities: ['types', 'generics', 'decorators', 'async-await', 'modules'],
+        focus: focus.priorities,
+        systemPrompt: opts.includePrompts ? `You are a TypeScript specialist for this project.
+Focus on: strict typing, type inference, generic patterns, module organization.
+Prefer type safety over any, use discriminated unions, leverage utility types.
+${focus.description}` : null
+      });
+    }
+
+    if (detectedLangs.has('python')) {
+      agents.push({
+        name: 'python-specialist',
+        type: 'python-developer',
+        description: 'Python development specialist',
+        capabilities: ['typing', 'async', 'testing', 'packaging', 'data-science'],
+        focus: focus.priorities,
+        systemPrompt: opts.includePrompts ? `You are a Python specialist for this project.
+Focus on: type hints, PEP standards, pythonic idioms, virtual environments.
+Use dataclasses, prefer pathlib, leverage context managers.
+${focus.description}` : null
+      });
+    }
+
+    if (detectedLangs.has('go')) {
+      agents.push({
+        name: 'go-specialist',
+        type: 'go-developer',
+        description: 'Go development specialist',
+        capabilities: ['goroutines', 'channels', 'interfaces', 'testing', 'modules'],
+        focus: focus.priorities,
+        systemPrompt: opts.includePrompts ? `You are a Go specialist for this project.
+Focus on: simplicity, explicit error handling, goroutines, interface composition.
+Follow Go conventions, use go fmt, prefer composition over inheritance.
+${focus.description}` : null
+      });
+    }
+
+    // Framework-specific agents
+    if (detectedFrameworks.has('react')) {
+      agents.push({
+        name: 'react-specialist',
+        type: 'react-developer',
+        description: 'React/Next.js development specialist',
+        capabilities: ['hooks', 'state-management', 'components', 'ssr', 'testing'],
+        focus: focus.priorities,
+        systemPrompt: opts.includePrompts ? `You are a React specialist for this project.
+Focus on: functional components, hooks, state management, performance optimization.
+Prefer composition, use memo wisely, follow React best practices.
+${focus.description}` : null
+      });
+    }
+
+    if (detectedFrameworks.has('database')) {
+      agents.push({
+        name: 'database-specialist',
+        type: 'database-specialist',
+        description: 'Database design and optimization specialist',
+        capabilities: ['schema-design', 'queries', 'indexing', 'migrations', 'orm'],
+        focus: focus.priorities,
+        systemPrompt: opts.includePrompts ? `You are a database specialist for this project.
+Focus on: normalized schemas, efficient queries, proper indexing, data integrity.
+Consider performance implications, use transactions appropriately.
+${focus.description}` : null
+      });
+    }
+
+    // Focus-specific agents
+    if (opts.focus === 'testing' || opts.focus === 'quality') {
+      agents.push({
+        name: 'test-architect',
+        type: 'test-engineer',
+        description: 'Testing and quality assurance specialist',
+        capabilities: ['unit-tests', 'integration-tests', 'mocking', 'coverage', 'tdd'],
+        focus: ['testing', 'quality', 'reliability'],
+        systemPrompt: opts.includePrompts ? `You are a testing specialist for this project.
+Focus on: comprehensive test coverage, meaningful assertions, test isolation.
+Write tests first when possible, mock external dependencies, aim for >80% coverage.
+${focus.description}` : null
+      });
+    }
+
+    if (opts.focus === 'security') {
+      agents.push({
+        name: 'security-auditor',
+        type: 'security-specialist',
+        description: 'Security audit and hardening specialist',
+        capabilities: ['vulnerability-scan', 'auth', 'encryption', 'input-validation', 'owasp'],
+        focus: ['security', 'compliance', 'hardening'],
+        systemPrompt: opts.includePrompts ? `You are a security specialist for this project.
+Focus on: OWASP top 10, input validation, authentication, authorization, encryption.
+Never trust user input, use parameterized queries, implement defense in depth.
+${focus.description}` : null
+      });
+    }
+
+    // Add coordinator agent
+    agents.push({
+      name: 'project-coordinator',
+      type: 'coordinator',
+      description: 'Coordinates multi-agent workflows for this project',
+      capabilities: ['task-decomposition', 'agent-routing', 'context-management'],
+      focus: focus.priorities,
+      routes: agents.filter(a => a.name !== 'project-coordinator').map(a => ({
+        pattern: a.capabilities[0],
+        agent: a.name
+      }))
+    });
+
+    // Create output directory
+    if (!fs.existsSync(outputDir)) {
+      fs.mkdirSync(outputDir, { recursive: true });
+    }
+
+    // Generate agent files
+    agents.forEach(agent => {
+      let content;
+      const filename = `${agent.name}.${opts.format}`;
+      const filepath = path.join(outputDir, filename);
+
+      if (opts.format === 'yaml') {
+        const yaml = [
+          `# Auto-generated by RuVector Agent Builder`,
+          `# Focus: ${opts.focus}`,
+          `# Generated: ${new Date().toISOString()}`,
+          ``,
+          `name: ${agent.name}`,
+          `type: ${agent.type}`,
+          `description: ${agent.description}`,
+          ``,
+          `capabilities:`,
+          ...agent.capabilities.map(c => `  - ${c}`),
+          ``,
+          `focus:`,
+          ...agent.focus.map(f => `  - ${f}`),
+        ];
+        if (agent.systemPrompt) {
+          yaml.push(``, `system_prompt: |`);
+          agent.systemPrompt.split('\n').forEach(line => yaml.push(`  ${line}`));
+        }
+        if (agent.routes) {
+          yaml.push(``, `routes:`);
+          agent.routes.forEach(r => yaml.push(`  - pattern: "${r.pattern}"`, `    agent: ${r.agent}`));
+        }
+        content = yaml.join('\n');
+      } else if (opts.format === 'json') {
+        content = JSON.stringify(agent, null, 2);
+      } else {
+        // Markdown format
+        content = [
+          `# ${agent.name}`,
+          ``,
+          `**Type:** ${agent.type}`,
+          `**Description:** ${agent.description}`,
+          ``,
+          `## Capabilities`,
+          ...agent.capabilities.map(c => `- ${c}`),
+          ``,
+          `## Focus Areas`,
+          ...agent.focus.map(f => `- ${f}`),
+        ].join('\n');
+        if (agent.systemPrompt) {
+          content += `\n\n## System Prompt\n\n\`\`\`\n${agent.systemPrompt}\n\`\`\``;
+        }
+      }
+
+      fs.writeFileSync(filepath, content);
+      console.log(chalk.green(`  ✓ Created ${filename}`));
+    });
+
+    // Create index file
+    const indexContent = opts.format === 'yaml'
+      ? `# RuVector Agent Configuration\n# Focus: ${opts.focus}\n\nagents:\n${agents.map(a => `  - ${a.name}`).join('\n')}`
+      : JSON.stringify({ focus: opts.focus, agents: agents.map(a => a.name) }, null, 2);
+
+    fs.writeFileSync(path.join(outputDir, `index.${opts.format === 'md' ? 'json' : opts.format}`), indexContent);
+
+    // Update settings to reference agents
+    const settingsPath = path.join(process.cwd(), '.claude', 'settings.json');
+    if (fs.existsSync(settingsPath)) {
+      try {
+        const settings = JSON.parse(fs.readFileSync(settingsPath, 'utf-8'));
+        settings.agentConfig = {
+          directory: opts.output,
+          focus: opts.focus,
+          agents: agents.map(a => a.name),
+          generated: new Date().toISOString()
+        };
+        fs.writeFileSync(settingsPath, JSON.stringify(settings, null, 2));
+        console.log(chalk.blue('\n  ✓ Updated .claude/settings.json with agent config'));
+      } catch (e) { /* ignore settings errors */ }
+    }
+
+    console.log(chalk.bold.green(`\n✅ Generated ${agents.length} optimized agents in ${opts.output}/\n`));
+    console.log(chalk.cyan('Agents created:'));
+    agents.forEach(a => {
+      console.log(`  🤖 ${chalk.bold(a.name)}: ${a.description}`);
+    });
+    console.log(chalk.dim(`\nFocus mode "${opts.focus}": ${focus.description}`));
+  });
+
 program.parse();

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "ruvector",
-  "version": "0.1.46",
+  "version": "0.1.48",
   "description": "High-performance vector database for Node.js with automatic native/WASM fallback",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",