claude-mycelium 2.0.0

package/.claude/settings.local.json

@@ -0,0 +1,14 @@
+{
+  "permissions": {
+    "allow": [
+      "Bash(npm run build:*)",
+      "Bash(npm test:*)",
+      "Bash(find:*)",
+      "Bash(npx @claude-flow/cli@latest swarm init:*)"
+    ]
+  },
+  "enableAllProjectMcpServers": true,
+  "enabledMcpjsonServers": [
+    "claude-flow"
+  ]
+}

package/README.md

@@ -0,0 +1,304 @@
+# Claude Mycelium 🍄
+
+[![npm version](https://img.shields.io/npm/v/claude-mycelium.svg)](https://www.npmjs.com/package/claude-mycelium)
+[![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg)](https://opensource.org/licenses/MIT)
+[![Tests](https://img.shields.io/badge/tests-289%2F292-brightgreen.svg)](https://github.com/ruvnet/claude-mycelium)
+[![TypeScript](https://img.shields.io/badge/TypeScript-5.0-blue.svg)](https://www.typescriptlang.org/)
+
+> **Self-Learning AI Code Evolution System** - Automated code quality improvement through intelligent gradient-based optimization and autonomous agent orchestration.
+
+Claude Mycelium is an autonomous AI agent system that continuously learns and improves your codebase using gradient-based signals, inhibitor-based learning, and LLM-powered code transformations. Like a mycelium network, it spreads intelligence throughout your codebase, connecting patterns and optimizing quality.
+
+## ✨ Features
+
+### 🎯 Intelligent Signal System
+- **Complexity Signal** - Detects cyclomatic complexity hotspots
+- **Churn Signal** - Identifies frequently modified files
+- **Centrality Signal** - Maps dependency relationships
+- **Technical Debt Signal** - Tracks code quality issues
+- **Error Signal** - Monitors runtime error patterns
+
+### 🤖 Autonomous Agent System
+- **4 Agent Modes** - Error Reducer, Complexity Reducer, Debt Payer, Stabilizer
+- **Gradient-Based Optimization** - Mathematical gradient descent for code quality
+- **Inhibitor-Based Learning** - Learns from failures through mycelium-inspired signals
+- **Automatic Rollback** - Reverts changes if tests fail
+- **Cost Tracking** - Monitors LLM API usage and efficiency
+
+### 🔬 Phase 2 Complete
+- ✅ **LLM Integration** - Anthropic Claude with streaming support
+- ✅ **Agent Execution** - 10-step orchestration loop
+- ✅ **Change Application** - Safe code modification with backup/rollback
+- ✅ **Trace System** - JSONL-based learning foundation
+- ✅ **Cost Tracking** - Multi-model pricing and budget monitoring
+
+## 🚀 Quick Start
+
+### Installation
+
+```bash
+npm install claude-mycelium
+```
+
+### Prerequisites
+
+- Node.js 20+
+- TypeScript 5.0+
+- Anthropic API Key
+
+### Basic Usage
+
+```typescript
+import { executeAgent } from 'claude-mycelium';
+
+// Set your API key
+process.env.ANTHROPIC_API_KEY = 'sk-ant-...';
+
+// Run the agent on a file
+const result = await executeAgent(
+  'src/my-file.ts',
+  'error_reducer',
+  { dryRun: false }
+);
+
+console.log(`Changes: ${result.changes}`);
+console.log(`Cost: $${result.cost.toFixed(4)}`);
+console.log(`Efficiency: ${result.trace.metabolic_efficiency.toFixed(3)}`);
+```
+
+### Calculate Gradient Scores
+
+```typescript
+import { calculateGradient } from 'claude-mycelium';
+
+const gradient = await calculateGradient('src/my-file.ts');
+console.log(`Overall Score: ${gradient.score.toFixed(2)}`);
+console.log(`Complexity: ${gradient.signals.complexity.value}`);
+console.log(`Technical Debt: ${gradient.signals.debt.value}`);
+```
+
+### Agent Modes
+
+```typescript
+// Error Reducer - Adds error handling and validation
+await executeAgent('src/api.ts', 'error_reducer');
+
+// Complexity Reducer - Simplifies complex functions
+await executeAgent('src/utils.ts', 'complexity_reducer');
+
+// Debt Payer - Fixes linting issues and code smells
+await executeAgent('src/legacy.ts', 'debt_payer');
+
+// Stabilizer - Reduces file churn and improves stability
+await executeAgent('src/volatile.ts', 'stabilizer');
+```
+
+## 📊 Architecture
+
+```
+┌─────────────────────────────────────────────────────────┐
+│  Claude Mycelium - Self-Learning Code Evolution        │
+└─────────────────────────────────────────────────────────┘
+                         │
+        ┌────────────────┼────────────────┐
+        │                │                │
+   [Signals]        [Gradient]       [Agents]
+        │                │                │
+   5 dimensions    Mathematical      4 modes
+   of quality      optimization      of action
+        │                │                │
+        └────────────────┼────────────────┘
+                         │
+              ┌──────────┴──────────┐
+              │                     │
+         [LLM Layer]          [Learning Layer]
+              │                     │
+      Anthropic Claude        Trace System
+      Cost Tracking          Efficiency Metrics
+      Retry Logic           Pattern Recognition
+```
+
+## 🛠️ Configuration
+
+### Environment Variables
+
+```bash
+# Required
+ANTHROPIC_API_KEY=sk-ant-...
+
+# Optional
+LOG_LEVEL=info              # debug, info, warn, error
+MAX_RETRIES=3               # LLM retry attempts
+DRY_RUN=false              # Simulate without changes
+```
+
+### API Options
+
+```typescript
+interface ExecuteOptions {
+  dryRun?: boolean;         // Validate without applying
+  maxRetries?: number;      // LLM retry attempts
+  createBackup?: boolean;   // Backup before changes
+}
+```
+
+## 📈 How It Works
+
+### The 10-Step Execution Loop
+
+1. **Calculate Gradient** - Measure current code quality
+2. **Select Mode** - Choose optimal agent strategy
+3. **Generate Prompt** - Create context-aware instructions
+4. **Call LLM** - Request code improvements
+5. **Parse Response** - Extract code changes
+6. **Validate** - Check TypeScript syntax
+7. **Apply Changes** - Safely modify files
+8. **Run Tests** - Verify correctness
+9. **Calculate New Gradient** - Measure improvement
+10. **Record Trace** - Learn from outcome
+
+### Gradient-Based Optimization
+
+Claude Mycelium treats code quality as a mathematical optimization problem:
+
+```
+Gradient = Σ(weight_i × signal_i)
+
+Where:
+- signal_complexity: Cyclomatic complexity
+- signal_churn: File modification frequency
+- signal_debt: Technical debt indicators
+- signal_error: Error rate patterns
+- signal_centrality: Dependency coupling
+```
+
+## 🎓 Advanced Usage
+
+### Custom Signal Weights
+
+```typescript
+import { calculateGradient } from 'claude-mycelium';
+
+const gradient = await calculateGradient('src/app.ts', {
+  weights: {
+    complexity: 0.3,
+    churn: 0.2,
+    debt: 0.3,
+    error: 0.1,
+    centrality: 0.1,
+  }
+});
+```
+
+### Batch Processing
+
+```typescript
+import { executeAgent } from 'claude-mycelium';
+import { glob } from 'glob';
+
+const files = await glob('src/**/*.ts');
+
+for (const file of files) {
+  const gradient = await calculateGradient(file);
+
+  if (gradient.score > 0.7) {
+    // High complexity - needs improvement
+    await executeAgent(file, 'complexity_reducer');
+  }
+}
+```
+
+### Learning from Traces
+
+```typescript
+import { getRecentEfficiency } from 'claude-mycelium';
+
+// Get efficiency of last 10 changes
+const efficiency = await getRecentEfficiency('src/app.ts', 10);
+console.log(`Historical efficiency: ${efficiency}`);
+```
+
+## 📦 What's Included
+
+- `src/core/` - Agent execution and orchestration
+- `src/signals/` - 5 quality measurement systems
+- `src/gradient/` - Mathematical optimization
+- `src/llm/` - Anthropic Claude integration
+- `src/trace/` - Learning and efficiency tracking
+- `src/cost/` - Budget monitoring and reporting
+
+## 🔒 Safety Features
+
+- **Backup System** - Creates backups before any changes
+- **Automatic Rollback** - Reverts on test failures
+- **TypeScript Validation** - Syntax checking before apply
+- **Path Safety** - Prevents modification of .git/ and node_modules/
+- **File Size Limits** - Protects against large file issues
+- **Dry Run Mode** - Test without applying changes
+
+## 📊 Performance
+
+- **Test Coverage**: 289/292 tests passing (99%)
+- **LLM Models**: Claude Sonnet 4.5, Opus 4.5, Haiku 3.5
+- **Retry Logic**: Exponential backoff for rate limits
+- **Cost Tracking**: Per-file and aggregate metrics
+- **Efficiency**: Gradient improvement per dollar spent
+
+## 🗺️ Roadmap
+
+### Phase 1 ✅ Complete
+- Signal system (5 dimensions)
+- Gradient calculation
+- Mode selection
+- Caching and optimization
+
+### Phase 2 ✅ Complete
+- LLM integration (Anthropic Claude)
+- Agent execution loop
+- Change application with rollback
+- Trace system and learning foundation
+- Cost tracking and efficiency metrics
+
+### Phase 3 🔄 Next
+- Concurrency & coordination
+- File locks (atomic operations)
+- Process spawning and IPC
+- Multi-agent coordination
+
+### Phase 4 📋 Planned
+- Inhibitor signals (ADR-002)
+- Quarantine system
+- Explorer mode
+- Learning from failures
+
+### Phase 5-9 📋 Future
+- Multi-file orchestration
+- Task planning and execution
+- CLI and watch mode
+- Distributed swarm coordination
+
+## 🤝 Contributing
+
+We welcome contributions! Please see [CONTRIBUTING.md](CONTRIBUTING.md) for guidelines.
+
+## 📄 License
+
+MIT License - see [LICENSE](LICENSE) for details
+
+## 🙏 Acknowledgments
+
+- Built with [Anthropic Claude](https://www.anthropic.com/claude)
+- Inspired by gradient descent optimization
+- Named after mycelium networks in nature
+
+## 📞 Support
+
+- **Issues**: [GitHub Issues](https://github.com/ruvnet/claude-mycelium/issues)
+- **Discussions**: [GitHub Discussions](https://github.com/ruvnet/claude-mycelium/discussions)
+- **Email**: support@claude-mycelium.dev
+
+---
+
+**Made with Claude Opus 4.5** 🍄✨
+
+*Continuous code evolution through autonomous AI agents*

package/dist/coordination/gradient-cache.d.ts

@@ -0,0 +1,48 @@
+/**
+ * Gradient Cache
+ * Per ADR-001 and second-spec §2
+ *
+ * Caches computed gradients for 5 minutes to avoid expensive recomputation.
+ * Invalidated when files change or on explicit cache clear.
+ *
+ * Cache is in-memory for simplicity. Future: could persist to .agent-meta/
+ */
+import type { GradientScore } from '../core/gradient.js';
+/**
+ * Get cached gradient if available and not expired
+ */
+export declare function getCachedGradient(filePath: string): GradientScore | null;
+/**
+ * Store gradient in cache
+ */
+export declare function setCachedGradient(gradient: GradientScore): void;
+/**
+ * Invalidate cache for specific file
+ */
+export declare function invalidateGradient(filePath: string): void;
+/**
+ * Invalidate entire cache
+ * Used when files change or on explicit clear
+ */
+export declare function invalidateGradientCache(): void;
+/**
+ * Get cache statistics
+ */
+export declare function getGradientCacheStats(): {
+    size: number;
+    entries: Array<{
+        file: string;
+        age: number;
+        score: number;
+    }>;
+};
+/**
+ * Get cached gradient with fallback to computation
+ */
+export declare function getOrComputeGradient(filePath: string, computeFn: () => Promise<GradientScore>): Promise<GradientScore>;
+/**
+ * Batch get or compute gradients
+ * Efficiently handles mix of cached and uncached files
+ */
+export declare function getOrComputeGradientBatch(filePaths: string[], computeBatchFn: (files: string[]) => Promise<Map<string, GradientScore>>): Promise<Map<string, GradientScore>>;
+//# sourceMappingURL=gradient-cache.d.ts.map

package/dist/coordination/gradient-cache.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"gradient-cache.d.ts","sourceRoot":"","sources":["../../src/coordination/gradient-cache.ts"],"names":[],"mappings":"AAAA;;;;;;;;GAQG;AAGH,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,qBAAqB,CAAC;AAazD;;GAEG;AACH,wBAAgB,iBAAiB,CAAC,QAAQ,EAAE,MAAM,GAAG,aAAa,GAAG,IAAI,CA2BxE;AAED;;GAEG;AACH,wBAAgB,iBAAiB,CAAC,QAAQ,EAAE,aAAa,GAAG,IAAI,CAW/D;AAED;;GAEG;AACH,wBAAgB,kBAAkB,CAAC,QAAQ,EAAE,MAAM,GAAG,IAAI,CAMzD;AAED;;;GAGG;AACH,wBAAgB,uBAAuB,IAAI,IAAI,CAK9C;AAED;;GAEG;AACH,wBAAgB,qBAAqB,IAAI;IACvC,IAAI,EAAE,MAAM,CAAC;IACb,OAAO,EAAE,KAAK,CAAC;QAAE,IAAI,EAAE,MAAM,CAAC;QAAC,GAAG,EAAE,MAAM,CAAC;QAAC,KAAK,EAAE,MAAM,CAAA;KAAE,CAAC,CAAC;CAC9D,CAmBA;AAED;;GAEG;AACH,wBAAsB,oBAAoB,CACxC,QAAQ,EAAE,MAAM,EAChB,SAAS,EAAE,MAAM,OAAO,CAAC,aAAa,CAAC,GACtC,OAAO,CAAC,aAAa,CAAC,CAaxB;AAED;;;GAGG;AACH,wBAAsB,yBAAyB,CAC7C,SAAS,EAAE,MAAM,EAAE,EACnB,cAAc,EAAE,CAAC,KAAK,EAAE,MAAM,EAAE,KAAK,OAAO,CAAC,GAAG,CAAC,MAAM,EAAE,aAAa,CAAC,CAAC,GACvE,OAAO,CAAC,GAAG,CAAC,MAAM,EAAE,aAAa,CAAC,CAAC,CAmCrC"}

package/dist/coordination/gradient-cache.js

@@ -0,0 +1,145 @@
+/**
+ * Gradient Cache
+ * Per ADR-001 and second-spec §2
+ *
+ * Caches computed gradients for 5 minutes to avoid expensive recomputation.
+ * Invalidated when files change or on explicit cache clear.
+ *
+ * Cache is in-memory for simplicity. Future: could persist to .agent-meta/
+ */
+import { logDebug } from '../utils/logger.js';
+// 5-minute TTL per spec
+const CACHE_TTL_MS = 5 * 60 * 1000;
+// In-memory cache
+const cache = new Map();
+/**
+ * Get cached gradient if available and not expired
+ */
+export function getCachedGradient(filePath) {
+    const cached = cache.get(filePath);
+    if (!cached) {
+        return null;
+    }
+    const now = Date.now();
+    const age = now - cached.computedAt;
+    if (age > CACHE_TTL_MS) {
+        // Expired
+        cache.delete(filePath);
+        logDebug('Gradient cache expired', {
+            file: filePath,
+            age: Math.round(age / 1000) + 's',
+        });
+        return null;
+    }
+    logDebug('Gradient cache hit', {
+        file: filePath,
+        age: Math.round(age / 1000) + 's',
+        score: cached.gradient.score.toFixed(3),
+    });
+    return cached.gradient;
+}
+/**
+ * Store gradient in cache
+ */
+export function setCachedGradient(gradient) {
+    cache.set(gradient.file, {
+        gradient,
+        computedAt: Date.now(),
+    });
+    logDebug('Gradient cached', {
+        file: gradient.file,
+        score: gradient.score.toFixed(3),
+        ttl: CACHE_TTL_MS / 1000 + 's',
+    });
+}
+/**
+ * Invalidate cache for specific file
+ */
+export function invalidateGradient(filePath) {
+    const hadCache = cache.delete(filePath);
+    if (hadCache) {
+        logDebug('Gradient cache invalidated', { file: filePath });
+    }
+}
+/**
+ * Invalidate entire cache
+ * Used when files change or on explicit clear
+ */
+export function invalidateGradientCache() {
+    const count = cache.size;
+    cache.clear();
+    logDebug('Gradient cache cleared', { count });
+}
+/**
+ * Get cache statistics
+ */
+export function getGradientCacheStats() {
+    const now = Date.now();
+    const entries = [];
+    for (const [file, cached] of cache.entries()) {
+        entries.push({
+            file,
+            age: Math.round((now - cached.computedAt) / 1000),
+            score: cached.gradient.score,
+        });
+    }
+    // Sort by age (oldest first)
+    entries.sort((a, b) => b.age - a.age);
+    return {
+        size: cache.size,
+        entries,
+    };
+}
+/**
+ * Get cached gradient with fallback to computation
+ */
+export async function getOrComputeGradient(filePath, computeFn) {
+    // Check cache first
+    const cached = getCachedGradient(filePath);
+    if (cached) {
+        return cached;
+    }
+    // Cache miss - compute and store
+    logDebug('Gradient cache miss, computing', { file: filePath });
+    const gradient = await computeFn();
+    setCachedGradient(gradient);
+    return gradient;
+}
+/**
+ * Batch get or compute gradients
+ * Efficiently handles mix of cached and uncached files
+ */
+export async function getOrComputeGradientBatch(filePaths, computeBatchFn) {
+    const results = new Map();
+    const uncached = [];
+    // Check cache for each file
+    for (const file of filePaths) {
+        const cached = getCachedGradient(file);
+        if (cached) {
+            results.set(file, cached);
+        }
+        else {
+            uncached.push(file);
+        }
+    }
+    // Compute remaining files in batch
+    if (uncached.length > 0) {
+        logDebug('Batch gradient cache miss', {
+            cached: filePaths.length - uncached.length,
+            uncached: uncached.length,
+        });
+        const computed = await computeBatchFn(uncached);
+        // Store newly computed gradients
+        for (const [file, gradient] of computed.entries()) {
+            setCachedGradient(gradient);
+            results.set(file, gradient);
+        }
+    }
+    else {
+        logDebug('Batch gradient cache hit (all)', {
+            count: filePaths.length,
+        });
+    }
+    return results;
+}
+//# sourceMappingURL=gradient-cache.js.map

package/dist/coordination/gradient-cache.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"gradient-cache.js","sourceRoot":"","sources":["../../src/coordination/gradient-cache.ts"],"names":[],"mappings":"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"}

package/dist/coordination/index.d.ts

@@ -0,0 +1,10 @@
+/**
+ * Coordination Layer - Index
+ *
+ * Exports coordination utilities for managing agent work:
+ * - Gradient caching
+ * - File locks (Phase 3)
+ * - Process management (Phase 3)
+ */
+export * from './gradient-cache.js';
+//# sourceMappingURL=index.d.ts.map

package/dist/coordination/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/coordination/index.ts"],"names":[],"mappings":"AAAA;;;;;;;GAOG;AAEH,cAAc,qBAAqB,CAAC"}

package/dist/coordination/index.js

@@ -0,0 +1,10 @@
+/**
+ * Coordination Layer - Index
+ *
+ * Exports coordination utilities for managing agent work:
+ * - Gradient caching
+ * - File locks (Phase 3)
+ * - Process management (Phase 3)
+ */
+export * from './gradient-cache.js';
+//# sourceMappingURL=index.js.map

package/dist/coordination/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../../src/coordination/index.ts"],"names":[],"mappings":"AAAA;;;;;;;GAOG;AAEH,cAAc,qBAAqB,CAAC"}

package/dist/core/agent-executor.d.ts

@@ -0,0 +1,31 @@
+/**
+ * Main Agent Executor
+ * Per second-spec §4
+ *
+ * Orchestrates the complete agent execution flow:
+ * 1. Calculate gradient for file
+ * 2. Generate prompt using mode-specific template
+ * 3. Call LLM
+ * 4. Parse LLM response for code changes
+ * 5. Apply changes
+ * 6. Record trace event
+ * 7. Calculate cost
+ * 8. Return result
+ */
+import type { Mode, TraceEvent } from '../types/index.js';
+export interface AgentRunResult {
+    success: boolean;
+    changes: string[];
+    trace: TraceEvent;
+    cost: number;
+}
+export interface AgentExecuteOptions {
+    dryRun?: boolean;
+    maxRetries?: number;
+}
+/**
+ * Execute agent work on a single file
+ * Main entry point for agent execution
+ */
+export declare function executeAgent(file: string, mode: Mode, options?: AgentExecuteOptions): Promise<AgentRunResult>;
+//# sourceMappingURL=agent-executor.d.ts.map

package/dist/core/agent-executor.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"agent-executor.d.ts","sourceRoot":"","sources":["../../src/core/agent-executor.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;GAaG;AAUH,OAAO,KAAK,EAAE,IAAI,EAAE,UAAU,EAAyB,MAAM,mBAAmB,CAAC;AAIjF,MAAM,WAAW,cAAc;IAC7B,OAAO,EAAE,OAAO,CAAC;IACjB,OAAO,EAAE,MAAM,EAAE,CAAC;IAClB,KAAK,EAAE,UAAU,CAAC;IAClB,IAAI,EAAE,MAAM,CAAC;CACd;AAED,MAAM,WAAW,mBAAmB;IAClC,MAAM,CAAC,EAAE,OAAO,CAAC;IACjB,UAAU,CAAC,EAAE,MAAM,CAAC;CACrB;AAOD;;;GAGG;AACH,wBAAsB,YAAY,CAChC,IAAI,EAAE,MAAM,EACZ,IAAI,EAAE,IAAI,EACV,OAAO,CAAC,EAAE,mBAAmB,GAC5B,OAAO,CAAC,cAAc,CAAC,CAuKzB"}