claude-mycelium 2.0.0 → 2.1.0

package/src/cli/cost.ts

@@ -0,0 +1,210 @@
+/**
+ * Cost CLI Command
+ *
+ * Display spending report with daily summaries
+ * Show efficiency trends
+ */
+
+import { Command } from 'commander';
+import chalk from 'chalk';
+import * as fs from 'fs/promises';
+import * as path from 'path';
+import type { TraceEvent, DailyCostSummary } from '../types/index.js';
+
+const command = new Command()
+  .name('cost')
+  .description('Show spending report and efficiency trends')
+  .option('--days <number>', 'Show data for last N days', '30')
+  .option('--json', 'Output as JSON')
+  .action(async (options: any) => {
+    try {
+      const days = parseInt(options.days, 10) || 30;
+      const summary = await generateCostSummary(days);
+
+      if (options.json) {
+        console.log(JSON.stringify(summary, null, 2));
+        return;
+      }
+
+      // Colorized output
+      console.log('');
+      console.log(chalk.bold('Cost Report (Last ' + days + ' days)'));
+      console.log(chalk.dim('─'.repeat(80)));
+
+      // Overall totals
+      console.log(chalk.bold('Overall:'));
+      console.log(
+        `  Total cost: ${chalk.yellow('$' + summary.total_usd.toFixed(2))}`
+      );
+      console.log(
+        `  Total tokens in: ${summary.total_tokens_in.toLocaleString()}`
+      );
+      console.log(
+        `  Total tokens out: ${summary.total_tokens_out.toLocaleString()}`
+      );
+      console.log(
+        `  Avg cost per run: ${chalk.yellow('$' + summary.avg_cost_per_run.toFixed(4))}`
+      );
+      console.log(
+        `  Avg cost per improvement: ${chalk.yellow(
+          '$' + summary.avg_cost_per_improvement.toFixed(4)
+        )}`
+      );
+
+      // Trend
+      const trendColor =
+        summary.cost_efficiency_trend === 'improving'
+          ? 'green'
+          : summary.cost_efficiency_trend === 'stable'
+            ? 'yellow'
+            : 'red';
+      console.log(
+        `  Trend: ${chalk[trendColor](summary.cost_efficiency_trend)}`
+      );
+
+      console.log(chalk.dim('─'.repeat(80)));
+
+      // Daily breakdown
+      if (summary.daily.length > 0) {
+        console.log(chalk.bold('Daily Breakdown:'));
+        console.log(
+          chalk.gray(
+            `${'Date'.padEnd(12)} ${'Runs'.padStart(6)} ${'Cost'.padStart(12)} ${'Eff.'.padStart(8)}`
+          )
+        );
+
+        for (const day of summary.daily.slice(-7)) {
+          const costStr = ('$' + day.total_cost_usd.toFixed(2)).padStart(12);
+          const effStr = (day.avg_efficiency.toFixed(3)).padStart(8);
+          console.log(
+            `${day.date.padEnd(12)} ${String(day.runs).padStart(6)} ${costStr} ${effStr}`
+          );
+        }
+      }
+
+      console.log('');
+    } catch (error) {
+      const message = error instanceof Error ? error.message : 'Unknown error';
+      console.error(chalk.red(`Error: ${message}`));
+      process.exit(1);
+    }
+  });
+
+/**
+ * Generate cost summary from trace events
+ */
+async function generateCostSummary(days: number) {
+  const tracesDir = '.agent-meta/traces';
+  const now = Date.now();
+  const cutoffMs = days * 24 * 60 * 60 * 1000;
+
+  let traceFiles: string[] = [];
+  try {
+    const entries = await fs.readdir(tracesDir);
+    traceFiles = entries.filter(f => f.endsWith('.ndjson'));
+  } catch {
+    // Traces directory doesn't exist
+  }
+
+  const events: TraceEvent[] = [];
+
+  // Collect all trace events from last N days
+  for (const file of traceFiles) {
+    const filePath = path.join(tracesDir, file);
+
+    try {
+      const content = await fs.readFile(filePath, 'utf-8');
+      const lines = content.split('\n').filter(Boolean);
+
+      for (const line of lines) {
+        try {
+          const event = JSON.parse(line) as TraceEvent;
+          const ageMs = now - new Date(event.timestamp).getTime();
+
+          if (ageMs < cutoffMs) {
+            events.push(event);
+          }
+        } catch {
+          // Skip malformed lines
+        }
+      }
+    } catch {
+      // File read error
+    }
+  }
+
+  // Calculate daily summaries
+  const byDate = new Map<string, TraceEvent[]>();
+
+  for (const event of events) {
+    const date = new Date(event.timestamp).toISOString().split('T')[0];
+    if (!byDate.has(date)) {
+      byDate.set(date, []);
+    }
+    byDate.get(date)!.push(event);
+  }
+
+  const daily: DailyCostSummary[] = [];
+  let totalCost = 0;
+  let totalTokensIn = 0;
+  let totalTokensOut = 0;
+  let totalEfficiency = 0;
+  let improvementCount = 0;
+
+  for (const [date, dayEvents] of Array.from(byDate).sort()) {
+    const cost = dayEvents.reduce((sum, e) => sum + e.cost.estimated_usd, 0);
+    const tokensIn = dayEvents.reduce((sum, e) => sum + e.cost.tokens_in, 0);
+    const tokensOut = dayEvents.reduce((sum, e) => sum + e.cost.tokens_out, 0);
+    const avgEff = dayEvents.reduce((sum, e) => sum + e.efficiency, 0) / dayEvents.length;
+    const improvements = dayEvents.filter(e => e.gradient_delta > 0).length;
+
+    const dayData: DailyCostSummary = {
+      date,
+      runs: dayEvents.length,
+      total_cost_usd: cost,
+      total_tokens_in: tokensIn,
+      total_tokens_out: tokensOut,
+      avg_efficiency: avgEff,
+      cost_per_improvement: improvements > 0 ? cost / improvements : cost,
+    };
+
+    daily.push(dayData);
+    totalCost += cost;
+    totalTokensIn += tokensIn;
+    totalTokensOut += tokensOut;
+    totalEfficiency += avgEff;
+    improvementCount += improvements;
+  }
+
+  // Calculate trend (compare first half vs second half)
+  let trend: 'improving' | 'stable' | 'degrading' = 'stable';
+  if (daily.length >= 2) {
+    const mid = Math.floor(daily.length / 2);
+    const firstHalf = daily.slice(0, mid);
+    const secondHalf = daily.slice(mid);
+
+    const firstAvgEff =
+      firstHalf.reduce((sum, d) => sum + d.avg_efficiency, 0) / firstHalf.length;
+    const secondAvgEff =
+      secondHalf.reduce((sum, d) => sum + d.avg_efficiency, 0) / secondHalf.length;
+
+    if (secondAvgEff > firstAvgEff * 1.1) {
+      trend = 'improving';
+    } else if (secondAvgEff < firstAvgEff * 0.9) {
+      trend = 'degrading';
+    }
+  }
+
+  return {
+    total_usd: totalCost,
+    total_tokens_in: totalTokensIn,
+    total_tokens_out: totalTokensOut,
+    avg_cost_per_run: events.length > 0 ? totalCost / events.length : 0,
+    avg_cost_per_improvement:
+      improvementCount > 0 ? totalCost / improvementCount : totalCost,
+    cost_efficiency_trend: trend,
+    daily,
+  };
+}
+
+export default command;

package/src/cli/gc.ts

@@ -0,0 +1,138 @@
+/**
+ * GC CLI Command
+ *
+ * Manual garbage collection trigger
+ * Show GC report and statistics
+ */
+
+import { Command } from 'commander';
+import chalk from 'chalk';
+import { runGC, readGCLog } from '../gc/runner.js';
+
+const command = new Command()
+  .name('gc')
+  .description('Run garbage collection manually')
+  .option('--json', 'Output as JSON')
+  .option('--history', 'Show GC history')
+  .action(async (options: any) => {
+    try {
+      if (options.history) {
+        await showGCHistory(options.json);
+        return;
+      }
+
+      await runGarbageCollection(options.json);
+    } catch (error) {
+      const message = error instanceof Error ? error.message : 'Unknown error';
+      console.error(chalk.red(`Error: ${message}`));
+      process.exit(1);
+    }
+  });
+
+/**
+ * Run garbage collection and show report
+ */
+async function runGarbageCollection(json: boolean = false): Promise<void> {
+  if (!json) {
+    console.log('');
+    console.log(chalk.bold('Running garbage collection...'));
+  }
+
+  const report = await runGC();
+
+  if (json) {
+    console.log(JSON.stringify(report, null, 2));
+    return;
+  }
+
+  // Display report
+  console.log(chalk.green('✓ GC completed'));
+  console.log('');
+
+  console.log(chalk.bold('Report:'));
+  console.log(`  Timestamp: ${report.timestamp}`);
+  console.log(`  Duration: ${report.duration_ms}ms`);
+  console.log(`  Size before: ${report.size_before_mb.toFixed(2)} MB`);
+  console.log(`  Size after: ${report.size_after_mb.toFixed(2)} MB`);
+
+  if (report.size_before_mb > 0) {
+    const saved = report.size_before_mb - report.size_after_mb;
+    const percent = ((saved / report.size_before_mb) * 100).toFixed(1);
+    console.log(
+      `  Space saved: ${chalk.green(saved.toFixed(2) + ' MB')} (${percent}%)`
+    );
+  }
+
+  console.log('');
+  console.log(chalk.bold('Actions:'));
+  console.log(`  Deleted items: ${report.deleted}`);
+  console.log(`  Compacted files: ${report.compacted}`);
+
+  if (report.errors.length > 0) {
+    console.log('');
+    console.log(chalk.yellow('Warnings:'));
+    for (const error of report.errors) {
+      console.log(`  - ${error}`);
+    }
+  }
+
+  console.log('');
+}
+
+/**
+ * Show GC history
+ */
+async function showGCHistory(json: boolean = false): Promise<void> {
+  const reports = await readGCLog();
+
+  if (json) {
+    console.log(JSON.stringify(reports, null, 2));
+    return;
+  }
+
+  if (reports.length === 0) {
+    console.log(chalk.yellow('No GC history found'));
+    return;
+  }
+
+  console.log('');
+  console.log(chalk.bold('GC History'));
+  console.log(chalk.dim('─'.repeat(80)));
+  console.log(
+    chalk.gray(
+      `${'Timestamp'.padEnd(25)} ${'Duration'.padStart(10)} ${'Deleted'.padStart(10)} ${'Space'.padStart(15)}`
+    )
+  );
+  console.log(chalk.dim('─'.repeat(80)));
+
+  for (const report of reports.slice(-10)) {
+    const date = new Date(report.timestamp).toISOString().split('T')[0];
+    const time = new Date(report.timestamp).toISOString().split('T')[1].substring(0, 5);
+    const timestamp = `${date} ${time}`.padEnd(25);
+    const duration = `${report.duration_ms}ms`.padStart(10);
+    const deleted = String(report.deleted).padStart(10);
+    const saved = (report.size_before_mb - report.size_after_mb).toFixed(2);
+    const space = `${saved}MB`.padStart(15);
+
+    console.log(`${timestamp} ${duration} ${deleted} ${space}`);
+  }
+
+  console.log(chalk.dim('─'.repeat(80)));
+
+  // Summary statistics
+  const totalDeleted = reports.reduce((sum, r) => sum + r.deleted, 0);
+  const totalSaved = reports.reduce(
+    (sum, r) => sum + (r.size_before_mb - r.size_after_mb),
+    0
+  );
+  const avgDuration =
+    reports.reduce((sum, r) => sum + r.duration_ms, 0) / reports.length;
+
+  console.log(chalk.bold('Summary (all runs):'));
+  console.log(`  Total items deleted: ${totalDeleted}`);
+  console.log(`  Total space saved: ${totalSaved.toFixed(2)} MB`);
+  console.log(`  Average duration: ${avgDuration.toFixed(0)}ms`);
+  console.log('');
+}
+
+export default command;

package/src/cli/gradients.ts

@@ -0,0 +1,95 @@
+/**
+ * Gradients CLI Command
+ *
+ * Display gradient scores for all files
+ * Sorted by score descending with colorized output
+ */
+
+import { Command } from 'commander';
+import chalk from 'chalk';
+import glob from 'fast-glob';
+import { calculateGradientBatch } from '../core/gradient.js';
+
+const command = new Command()
+  .name('gradients')
+  .description('Show gradient scores for all files')
+  .argument('[path]', 'Root path to analyze', '.')
+  .option('--json', 'Output as JSON')
+  .option('--limit <number>', 'Show top N files', '20')
+  .action(async (rootPath: string, options: any) => {
+    try {
+      // Find all TypeScript files (not .d.ts)
+      const files = await glob('**/*.ts', {
+        cwd: rootPath,
+        ignore: ['node_modules/**', 'dist/**', '**/*.d.ts', '**/*.test.ts', '**/*.spec.ts'],
+      });
+
+      if (files.length === 0) {
+        console.log(chalk.yellow('No TypeScript files found'));
+        return;
+      }
+
+      const gradientMap = await calculateGradientBatch(files);
+      const gradients = Array.from(gradientMap.values());
+
+      // Sort by score descending
+      const sorted = [...gradients].sort((a, b) => b.score - a.score);
+
+      // Apply limit
+      const limit = parseInt(options.limit, 10) || 20;
+      const limited = sorted.slice(0, limit);
+
+      if (options.json) {
+        console.log(JSON.stringify(limited, null, 2));
+        return;
+      }
+
+      // Colorized output
+      console.log('');
+      console.log(chalk.bold('Gradient Scores (sorted by impact)'));
+      console.log(chalk.dim('─'.repeat(80)));
+      console.log(
+        chalk.gray(
+          `${String('File').padEnd(50)} ${'Score'.padStart(10)} ${'Signal'.padStart(15)}`
+        )
+      );
+      console.log(chalk.dim('─'.repeat(80)));
+
+      for (const gradient of limited) {
+        const scoreColor = gradient.score > 0.7 ? 'red' : gradient.score > 0.4 ? 'yellow' : 'green';
+        const score = gradient.score.toFixed(3);
+        const signal = gradient.dominantSignal.name;
+
+        console.log(
+          `${gradient.file.substring(0, 50).padEnd(50)} ${chalk[scoreColor](
+            score.padStart(10)
+          )} ${signal.padStart(15)}`
+        );
+      }
+
+      console.log(chalk.dim('─'.repeat(80)));
+      console.log(
+        chalk.dim(`Showing ${limited.length} of ${gradients.length} files`)
+      );
+      console.log('');
+
+      // Summary
+      const highImpact = sorted.filter(g => g.score > 0.7).length;
+      const mediumImpact = sorted.filter(g => g.score > 0.4 && g.score <= 0.7).length;
+      const lowImpact = sorted.filter(g => g.score <= 0.4).length;
+
+      console.log(chalk.bold('Summary:'));
+      console.log(
+        `  ${chalk.red(`High impact: ${highImpact}`)} | ${chalk.yellow(
+          `Medium: ${mediumImpact}`
+        )} | ${chalk.green(`Low: ${lowImpact}`)}`
+      );
+      console.log('');
+    } catch (error) {
+      const message = error instanceof Error ? error.message : 'Unknown error';
+      console.error(chalk.red(`Error: ${message}`));
+      process.exit(1);
+    }
+  });
+
+export default command;

package/src/cli/index.ts

@@ -0,0 +1,79 @@
+/**
+ * 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');
+
+  program.addCommand(gradients);
+  program.addCommand(cost);
+  program.addCommand(status);
+  program.addCommand(init);
+  program.addCommand(gc);
+}
+
+/**
+ * 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;