claude-mycelium 2.0.0 → 2.2.0

package/src/cli/grow.ts

@@ -0,0 +1,416 @@
+/**
+ * Grow CLI Command - Interactive Mycelium Growth Interface
+ *
+ * Interactive terminal for spawning agents to improve your codebase
+ * Usage: npx claude-mycelium grow
+ */
+
+import { Command } from 'commander';
+import prompts from 'prompts';
+import chalk from 'chalk';
+import ora from 'ora';
+import { executeAgent } from '../core/agent-executor.js';
+import { calculateGradient } from '../core/gradient.js';
+import { planTask, executeTask } from '../task/index.js';
+import { storeTask } from '../task/storage.js';
+import type { Mode, Task } from '../types/index.js';
+import { randomUUID } from 'crypto';
+
+interface ParsedTask {
+  type: 'spawn' | 'analyze' | 'task' | 'help' | 'exit';
+  mode?: Mode;
+  file?: string;
+  description?: string;
+}
+
+/**
+ * Parse natural language task into action
+ */
+function parseTask(input: string): ParsedTask {
+  const lower = input.toLowerCase().trim();
+
+  if (lower === 'help' || lower === '?') {
+    return { type: 'help' };
+  }
+
+  if (lower === 'exit' || lower === 'quit' || lower === 'q') {
+    return { type: 'exit' };
+  }
+
+  if (lower.startsWith('analyze ') || lower.startsWith('check ')) {
+    const file = lower.split(/\s+/).slice(1).join(' ');
+    return { type: 'analyze', file };
+  }
+
+  // Check if input has a file path - if so, use quick spawn commands
+  const file = extractFilePath(input);
+
+  if (file) {
+    // File-specific quick commands
+    if (lower.includes('fix') || lower.includes('bug') || lower.includes('error')) {
+      return { type: 'spawn', mode: 'error_reducer', file };
+    }
+
+    if (lower.includes('complex') || lower.includes('simplify') || lower.includes('reduce')) {
+      return { type: 'spawn', mode: 'complexity_reducer', file };
+    }
+
+    if (lower.includes('clean') || lower.includes('debt') || lower.includes('lint')) {
+      return { type: 'spawn', mode: 'debt_payer', file };
+    }
+
+    if (lower.includes('stabil') || lower.includes('churn')) {
+      return { type: 'spawn', mode: 'stabilizer', file };
+    }
+
+    // Has file but no recognized keywords - analyze it
+    return { type: 'analyze', file };
+  }
+
+  // No file path - treat as general task (like "implement MCP", "add health check", etc.)
+  // Keywords that indicate a general task
+  if (lower.includes('implement') ||
+      lower.includes('create') ||
+      lower.includes('add') ||
+      lower.includes('build') ||
+      lower.includes('make') ||
+      lower.includes('develop') ||
+      lower.includes('write') ||
+      lower.startsWith('let\'s')) {
+    return { type: 'task', description: input };
+  }
+
+  return { type: 'help' };
+}
+
+/**
+ * Extract file path from natural language
+ */
+function extractFilePath(input: string): string | undefined {
+  const words = input.split(/\s+/);
+  const fileWord = words.find(
+    (w) => w.includes('/') || w.endsWith('.ts') || w.endsWith('.js') || w.endsWith('.tsx') || w.endsWith('.jsx')
+  );
+  return fileWord;
+}
+
+/**
+ * Show help message
+ */
+function showHelp() {
+  console.log('');
+  console.log(chalk.bold.green('🍄 Claude Mycelium - Interactive Growth'));
+  console.log('');
+  console.log(chalk.bold('General Tasks (Multi-Step):'));
+  console.log('');
+  console.log(chalk.cyan('  "implement MCP server"') + '         - Plan and execute multi-step task');
+  console.log(chalk.cyan('  "add health check endpoint"') + '    - Create feature with tests');
+  console.log(chalk.cyan('  "create authentication system"') + ' - Build complete feature');
+  console.log('');
+  console.log(chalk.bold('File-Specific Commands (Quick):'));
+  console.log('');
+  console.log(chalk.cyan('  "fix bugs in src/api.ts"') + '       - Spawn error_reducer agent');
+  console.log(chalk.cyan('  "reduce complexity in src/utils.ts"') + ' - Spawn complexity_reducer agent');
+  console.log(chalk.cyan('  "clean up src/legacy.ts"') + '       - Spawn debt_payer agent');
+  console.log(chalk.cyan('  "stabilize src/volatile.ts"') + '    - Spawn stabilizer agent');
+  console.log(chalk.cyan('  "analyze src/app.ts"') + '           - Show gradient analysis');
+  console.log('');
+  console.log(chalk.dim('  Type "exit" to quit'));
+  console.log('');
+}
+
+/**
+ * Start interactive grow session
+ */
+export async function startGrowSession() {
+  console.clear();
+  console.log(chalk.bold.green('🍄 Mycelium Network Active'));
+  console.log(chalk.dim('Growing intelligence through autonomous agents'));
+  console.log('');
+
+  showHelp();
+
+  let running = true;
+
+  while (running) {
+    try {
+      const response = await prompts({
+        type: 'text',
+        name: 'task',
+        message: chalk.green('🌱 What would you like to grow?'),
+        validate: (value) => value.length > 0 || 'Please enter a task',
+      });
+
+      if (!response.task) {
+        // User cancelled with Ctrl+C
+        running = false;
+        break;
+      }
+
+      const task = parseTask(response.task);
+
+      if (task.type === 'help') {
+        showHelp();
+        continue;
+      }
+
+      if (task.type === 'exit') {
+        running = false;
+        break;
+      }
+
+      if (task.type === 'analyze') {
+        if (!task.file) {
+          console.log(chalk.yellow('⚠️  Please specify a file to analyze'));
+          continue;
+        }
+
+        const spinner = ora(`Analyzing ${task.file}...`).start();
+        try {
+          const gradient = await calculateGradient(task.file);
+          spinner.succeed(chalk.green(`Analysis complete for ${task.file}`));
+
+          console.log('');
+          console.log(chalk.bold('📊 Gradient Analysis:'));
+          console.log(chalk.dim('─'.repeat(50)));
+          console.log(`${chalk.bold('Overall Score:')}  ${gradient.score.toFixed(3)}`);
+          console.log(`${chalk.bold('Dominant Signal:')} ${gradient.dominantSignal.name}`);
+          console.log('');
+          console.log(chalk.dim('Signal Breakdown:'));
+          console.log(`  Complexity:  ${gradient.signals.complexity.toFixed(3)}`);
+          console.log(`  Churn:       ${gradient.signals.churn.toFixed(3)}`);
+          console.log(`  Debt:        ${gradient.signals.debt.toFixed(3)}`);
+          console.log(`  Error Rate:  ${gradient.signals.error_rate.toFixed(3)}`);
+          console.log(`  Centrality:  ${gradient.signals.centrality.toFixed(3)}`);
+          console.log('');
+        } catch (error) {
+          spinner.fail(chalk.red('Analysis failed'));
+          console.error(chalk.red(`Error: ${error instanceof Error ? error.message : 'Unknown error'}`));
+        }
+        continue;
+      }
+
+      if (task.type === 'task') {
+        if (!task.description) {
+          console.log(chalk.yellow('⚠️  Could not determine task description'));
+          continue;
+        }
+
+        const spinner = ora('Planning task...').start();
+        try {
+          // Create task object
+          const newTask: Task = {
+            id: randomUUID(),
+            description: task.description,
+            status: 'planning',
+            created_at: new Date().toISOString(),
+            acceptance_criteria: [],
+            steps_completed: 0,
+            steps_total: 0,
+            files_created: [],
+            files_modified: [],
+            traces: [],
+          };
+
+          spinner.text = 'Generating task plan...';
+          const plan = await planTask(newTask);
+
+          newTask.plan = plan;
+          newTask.steps_total = plan.steps.length;
+          newTask.status = 'in_progress';
+
+          await storeTask(newTask);
+
+          spinner.succeed(chalk.green('Task plan generated'));
+          console.log('');
+          console.log(chalk.bold('📋 Task Plan:'));
+          console.log(chalk.dim('─'.repeat(50)));
+          console.log(`${chalk.bold('Summary:')} ${plan.summary}`);
+          console.log(`${chalk.bold('Steps:')}   ${plan.steps.length}`);
+          console.log(`${chalk.bold('Complexity:')} ${plan.estimated_complexity}`);
+          if (plan.risks.length > 0) {
+            console.log(`${chalk.bold('Risks:')}`);
+            plan.risks.forEach(risk => console.log(chalk.yellow(`  ⚠️  ${risk}`)));
+          }
+          console.log('');
+
+          // Show steps
+          console.log(chalk.bold('Steps:'));
+          plan.steps.forEach(step => {
+            console.log(`  ${step.order}. ${step.description}`);
+            console.log(`     ${chalk.dim(`File: ${step.target_file}, Mode: ${step.mode}`)}`);
+          });
+          console.log('');
+
+          const executeSpinner = ora('Executing task...').start();
+          const executedTask = await executeTask(newTask);
+
+          if (executedTask.status === 'completed') {
+            executeSpinner.succeed(chalk.green('Task completed successfully'));
+            console.log('');
+            console.log(chalk.bold('✅ Results:'));
+            console.log(chalk.dim('─'.repeat(50)));
+            console.log(`${chalk.bold('Task ID:')}       ${executedTask.id}`);
+            console.log(`${chalk.bold('Steps:')}         ${executedTask.steps_completed}/${executedTask.steps_total}`);
+            console.log(`${chalk.bold('Files Created:')} ${executedTask.files_created.length}`);
+            console.log(`${chalk.bold('Files Modified:')} ${executedTask.files_modified.length}`);
+            console.log('');
+
+            if (executedTask.files_created.length > 0) {
+              console.log(chalk.bold('Created:'));
+              executedTask.files_created.forEach(f => console.log(`  ${chalk.green('+')} ${f}`));
+            }
+            if (executedTask.files_modified.length > 0) {
+              console.log(chalk.bold('Modified:'));
+              executedTask.files_modified.forEach(f => console.log(`  ${chalk.yellow('~')} ${f}`));
+            }
+            console.log('');
+            console.log(chalk.green('💡 Task completed. Run tests to verify.'));
+          } else {
+            executeSpinner.fail(chalk.red('Task execution failed'));
+            console.error(chalk.red(`Error: ${executedTask.error || 'Unknown error'}`));
+          }
+
+          await storeTask(executedTask);
+          console.log('');
+        } catch (error) {
+          spinner.fail(chalk.red('Task execution failed'));
+          console.error(chalk.red(`Error: ${error instanceof Error ? error.message : 'Unknown error'}`));
+          console.log('');
+        }
+        continue;
+      }
+
+      if (task.type === 'spawn') {
+        if (!task.file || !task.mode) {
+          console.log(chalk.yellow('⚠️  Could not determine file and mode from task'));
+          continue;
+        }
+
+        const spinner = ora(`Spawning ${task.mode} agent for ${task.file}...`).start();
+        try {
+          const result = await executeAgent(task.file, task.mode, { dryRun: false });
+
+          spinner.succeed(chalk.green(`Agent completed successfully`));
+          console.log('');
+          console.log(chalk.bold('✅ Results:'));
+          console.log(chalk.dim('─'.repeat(50)));
+          console.log(`${chalk.bold('File:')}       ${task.file}`);
+          console.log(`${chalk.bold('Mode:')}       ${task.mode}`);
+          console.log(`${chalk.bold('Changes:')}    ${result.changes} modifications`);
+          console.log(`${chalk.bold('Cost:')}       $${result.cost.toFixed(4)}`);
+          console.log(`${chalk.bold('Efficiency:')} ${result.trace?.efficiency.toFixed(3) || 'N/A'}`);
+          console.log('');
+
+          if (result.changes && result.changes.length > 0) {
+            console.log(chalk.green('💡 Changes have been applied. Run tests to verify.'));
+          } else {
+            console.log(chalk.yellow('ℹ️  No changes were needed.'));
+          }
+          console.log('');
+        } catch (error) {
+          spinner.fail(chalk.red('Agent execution failed'));
+          console.error(chalk.red(`Error: ${error instanceof Error ? error.message : 'Unknown error'}`));
+          console.log('');
+        }
+        continue;
+      }
+    } catch (error) {
+      if (error instanceof Error && error.message.includes('User force closed')) {
+        running = false;
+        break;
+      }
+      console.error(chalk.red(`Error: ${error instanceof Error ? error.message : 'Unknown error'}`));
+    }
+  }
+
+  console.log('');
+  console.log(chalk.green('🍄 Mycelium network dormant. Growth complete.'));
+  console.log('');
+}
+
+/**
+ * Commander.js command definition
+ */
+const command = new Command()
+  .name('grow')
+  .description('Start interactive mycelium growth interface')
+  .option('--task <description>', 'Run a single task and exit')
+  .action(async (options: { task?: string }) => {
+    if (options.task) {
+      // Non-interactive mode - single task
+      const task = parseTask(options.task);
+
+      if (task.type === 'task' && task.description) {
+        const spinner = ora('Planning task...').start();
+        try {
+          // Create and execute task
+          const newTask: Task = {
+            id: randomUUID(),
+            description: task.description,
+            status: 'planning',
+            created_at: new Date().toISOString(),
+            acceptance_criteria: [],
+            steps_completed: 0,
+            steps_total: 0,
+            files_created: [],
+            files_modified: [],
+            traces: [],
+          };
+
+          const plan = await planTask(newTask);
+          newTask.plan = plan;
+          newTask.steps_total = plan.steps.length;
+          newTask.status = 'in_progress';
+          await storeTask(newTask);
+
+          spinner.text = 'Executing task...';
+          const executedTask = await executeTask(newTask);
+          await storeTask(executedTask);
+
+          if (executedTask.status === 'completed') {
+            spinner.succeed(chalk.green('Task completed'));
+            console.log(`Steps: ${executedTask.steps_completed}/${executedTask.steps_total}, Created: ${executedTask.files_created.length}, Modified: ${executedTask.files_modified.length}`);
+          } else {
+            spinner.fail(chalk.red('Task failed'));
+            console.error(chalk.red(`Error: ${executedTask.error || 'Unknown error'}`));
+            process.exit(1);
+          }
+        } catch (error) {
+          spinner.fail(chalk.red('Task failed'));
+          console.error(chalk.red(`Error: ${error instanceof Error ? error.message : 'Unknown error'}`));
+          process.exit(1);
+        }
+      } else if (task.type === 'spawn' && task.file && task.mode) {
+        const spinner = ora(`Spawning ${task.mode} agent...`).start();
+        try {
+          const result = await executeAgent(task.file, task.mode, { dryRun: false });
+          spinner.succeed(chalk.green('Agent completed'));
+          console.log(`Changes: ${result.changes}, Cost: $${result.cost.toFixed(4)}, Efficiency: ${result.trace?.efficiency.toFixed(3) || 'N/A'}`);
+        } catch (error) {
+          spinner.fail(chalk.red('Agent failed'));
+          console.error(chalk.red(`Error: ${error instanceof Error ? error.message : 'Unknown error'}`));
+          process.exit(1);
+        }
+      } else if (task.type === 'analyze' && task.file) {
+        const spinner = ora(`Analyzing ${task.file}...`).start();
+        try {
+          const gradient = await calculateGradient(task.file);
+          spinner.succeed(chalk.green('Analysis complete'));
+          console.log(`Score: ${gradient.score.toFixed(3)}, Dominant: ${gradient.dominantSignal.name}`);
+        } catch (error) {
+          spinner.fail(chalk.red('Analysis failed'));
+          console.error(chalk.red(`Error: ${error instanceof Error ? error.message : 'Unknown error'}`));
+          process.exit(1);
+        }
+      } else {
+        console.log(chalk.yellow('Could not parse task. Use interactive mode for help.'));
+        process.exit(1);
+      }
+    } else {
+      // Interactive TUI mode
+      await startGrowSession();
+    }
+  });
+
+export default command;

package/src/cli/index.ts

@@ -0,0 +1,81 @@
+/**
+ * Claude Mycelium CLI
+ *
+ * Main CLI entry point using Commander.js
+ * Coordinates all CLI subcommands
+ */
+
+import { Command } from 'commander';
+import { readFileSync } from 'fs';
+import { resolve } from 'path';
+import { fileURLToPath } from 'url';
+import { dirname } from 'path';
+
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = dirname(__filename);
+
+// Read package.json for version
+let version = '2.0.0';
+try {
+  const pkgPath = resolve(__dirname, '../../package.json');
+  const pkg = JSON.parse(readFileSync(pkgPath, 'utf-8')) as { version?: string };
+  if (pkg.version) {
+    version = pkg.version;
+  }
+} catch {
+  // Fallback to default version
+}
+
+export const program = new Command();
+
+program
+  .name('claude-mycelium')
+  .description('Intelligent automated code improvement system')
+  .version(version)
+  .option('-v, --verbose', 'Enable verbose logging')
+  .option('--config <path>', 'Path to config file')
+  .hook('preAction', (thisCommand) => {
+    // Handle global options
+    if (thisCommand.optsWithGlobals().verbose) {
+      process.env.DEBUG = '1';
+    }
+    if (thisCommand.optsWithGlobals().config) {
+      process.env.MYCELIUM_CONFIG = thisCommand.optsWithGlobals().config;
+    }
+  });
+
+/**
+ * Import and register subcommands
+ */
+export async function registerCommands() {
+  // Dynamically import subcommands
+  const { default: gradients } = await import('./gradients.js');
+  const { default: cost } = await import('./cost.js');
+  const { default: status } = await import('./status.js');
+  const { default: init } = await import('./init.js');
+  const { default: gc } = await import('./gc.js');
+  const { default: grow } = await import('./grow.js');
+
+  program.addCommand(gradients);
+  program.addCommand(cost);
+  program.addCommand(status);
+  program.addCommand(init);
+  program.addCommand(gc);
+  program.addCommand(grow);
+}
+
+/**
+ * Parse and execute CLI
+ */
+export async function execute(argv?: string[]) {
+  await registerCommands();
+  return program.parseAsync(argv || process.argv);
+}
+
+// Auto-execute when run as script
+if (import.meta.url === `file://${process.argv[1]}`) {
+  execute().catch((error) => {
+    console.error('CLI Error:', error);
+    process.exit(1);
+  });
+}

package/src/cli/init.ts

@@ -0,0 +1,139 @@
+/**
+ * Init CLI Command
+ *
+ * Initialize .agent-meta/ directory structure
+ * Create default configuration files
+ * Per Phase 7 specification §15
+ */
+
+import { Command } from 'commander';
+import chalk from 'chalk';
+import * as fs from 'fs/promises';
+import * as path from 'path';
+import { fileExists } from '../utils/file-utils.js';
+
+const command = new Command()
+  .name('init')
+  .description('Initialize .agent-meta/ in current directory')
+  .option('--force', 'Reinitialize even if exists')
+  .action(async (options: any) => {
+    try {
+      await initCommand(options.force);
+    } catch (error) {
+      const message = error instanceof Error ? error.message : 'Unknown error';
+      console.error(chalk.red(`Error: ${message}`));
+      process.exit(1);
+    }
+  });
+
+/**
+ * Initialize .agent-meta/ directory and configuration
+ */
+async function initCommand(force: boolean = false): Promise<void> {
+  const metaDir = '.agent-meta';
+
+  // Check if already initialized
+  if (fileExists(metaDir) && !force) {
+    console.log(
+      chalk.yellow('Already initialized. Use --force to reinitialize.')
+    );
+    return;
+  }
+
+  // Create directory structure
+  await fs.mkdir(metaDir, { recursive: true });
+  await fs.mkdir(path.join(metaDir, 'traces'), { recursive: true });
+  await fs.mkdir(path.join(metaDir, 'tasks'), { recursive: true });
+  await fs.mkdir(path.join(metaDir, 'locks'), { recursive: true });
+
+  // Create initial config file
+  await fs.writeFile(
+    path.join(metaDir, 'config.json'),
+    JSON.stringify(
+      {
+        version: '2.0.0',
+        created_at: new Date().toISOString(),
+        error_provider: 'file',
+        error_file: '.agent-meta/_errors.json',
+        ci_command: 'npm test && npm run lint',
+        spawn_count: 0,
+        last_gc_at_spawn: 0,
+      },
+      null,
+      2
+    ) + '\n'
+  );
+
+  // Create quarantine file
+  await fs.writeFile(
+    path.join(metaDir, '_quarantine.json'),
+    JSON.stringify(
+      {
+        updated_at: new Date().toISOString(),
+        entries: [],
+      },
+      null,
+      2
+    ) + '\n'
+  );
+
+  // Create inhibitors file
+  await fs.writeFile(path.join(metaDir, '_inhibitors.ndjson'), '');
+
+  // Create errors file
+  await fs.writeFile(
+    path.join(metaDir, '_errors.json'),
+    JSON.stringify(
+      {
+        updated_at: new Date().toISOString(),
+        errors: [],
+      },
+      null,
+      2
+    ) + '\n'
+  );
+
+  // Create GC log file
+  await fs.writeFile(path.join(metaDir, '_gc.log'), '');
+
+  // Add to .gitignore if needed
+  const gitignorePath = '.gitignore';
+  const lockPattern = '.agent-meta/locks/';
+
+  try {
+    const gitignore = await fs.readFile(gitignorePath, 'utf-8');
+    if (!gitignore.includes(lockPattern)) {
+      await fs.appendFile(
+        gitignorePath,
+        `\n# Claude Mycelium locks (ephemeral)\n${lockPattern}\n`
+      );
+    }
+  } catch {
+    // No .gitignore, create one
+    await fs.writeFile(
+      gitignorePath,
+      `# Claude Mycelium locks (ephemeral)\n${lockPattern}\n`
+    );
+  }
+
+  // Success message
+  console.log('');
+  console.log(chalk.green('✓ Initialized .agent-meta/'));
+  console.log(
+    chalk.dim('  - Created directory structure (traces, tasks, locks)')
+  );
+  console.log(chalk.dim('  - Created config.json'));
+  console.log(chalk.dim('  - Created _quarantine.json'));
+  console.log(chalk.dim('  - Created _inhibitors.ndjson'));
+  console.log(chalk.dim('  - Created _errors.json'));
+  console.log(chalk.dim('  - Created _gc.log'));
+  console.log(chalk.dim('  - Updated .gitignore'));
+  console.log('');
+  console.log(chalk.bold('Next steps:'));
+  console.log('  1. Set ANTHROPIC_API_KEY environment variable');
+  console.log('  2. Run: npx claude-mycelium gradients ./src');
+  console.log('  3. Check system status: npx claude-mycelium status');
+  console.log('');
+}
+
+export default command;