claude-mycelium 2.1.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

@@ -54,12 +54,14 @@ export async function registerCommands() {
   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);
 }
 
 /**

package/src/core/agent-executor.ts

@@ -27,18 +27,23 @@ import { ciProvider } from '../utils/ci-provider.js';
 export interface AgentRunResult {
   success: boolean;
   changes: string[];  // Files modified
-  trace: TraceEvent;
+  trace?: TraceEvent; // Optional: may not exist on failure
   cost: number;  // USD
+  error?: string;     // Optional: error message on failure
 }
 
 export interface AgentExecuteOptions {
   dryRun?: boolean;
   maxRetries?: number;
+  agentId?: string;      // Optional: for task-driven execution
+  taskId?: string;       // Optional: for task-driven execution
 }
 
-const DEFAULT_OPTIONS: Required<AgentExecuteOptions> = {
+const DEFAULT_OPTIONS = {
   dryRun: false,
   maxRetries: 3,
+  agentId: undefined,
+  taskId: undefined,
 };
 
 /**
@@ -51,7 +56,7 @@ export async function executeAgent(
   options?: AgentExecuteOptions
 ): Promise<AgentRunResult> {
   const opts = { ...DEFAULT_OPTIONS, ...options };
-  const agentId = `agent-${uuid().slice(0, 8)}`;
+  const agentId = opts.agentId || `agent-${uuid().slice(0, 8)}`;
   const traceId = uuid();
 
   logInfo('Starting agent execution', {
@@ -174,6 +179,7 @@ export async function executeAgent(
         `Gradient improved: ${gradientDelta < 0 ? 'Yes' : 'No'}`,
       ],
       agent_id: agentId,
+      task_id: opts.taskId, // Link to task if part of task execution
       cost: costRecord,
     };
 
@@ -233,7 +239,14 @@ export async function executeAgent(
       await recordTrace(errorTrace);
     }
 
-    throw error;
+    // Return failure result instead of throwing (for task-worker compatibility)
+    return {
+      success: false,
+      changes: [],
+      trace: errorTrace,
+      cost: 0,
+      error: errorObj.message,
+    };
   }
 }