claude-mycelium 2.0.0 → 2.2.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,97 @@
+/**
+ * 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 * as path from 'path';
+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'],
+        absolute: true, // Get absolute paths
+      });
+
+      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;