erosolar-cli 1.5.2 → 1.5.4

package/dist/bin/alpha-zero/competitiveRunner.js

@@ -0,0 +1,219 @@
+/**
+ * Alpha Zero 2 - Competitive Agent Runner
+ *
+ * Runs competitive comparisons between two AI agents.
+ *
+ * Principal Investigator: Bo Shang
+ * Framework: erosolar-cli
+ */
+import { extractCodeBlocks, evaluateCodeQuality, calculateRewardScore } from './codeEvaluator.js';
+/**
+ * Run competitive comparisons between two agents.
+ */
+export class CompetitiveAgentRunner {
+    constructor(agent1, agent2) {
+        this.roundResults = [];
+        this.agent1 = agent1;
+        this.agent2 = agent2;
+    }
+    /**
+     * Run both agents on the same prompt and compare results.
+     */
+    async runComparison(prompt, evaluateCode = true) {
+        const startTime = Date.now();
+        // Run both agents concurrently
+        const [result1, result2] = await Promise.allSettled([
+            this.runAgent(this.agent1, prompt, evaluateCode),
+            this.runAgent(this.agent2, prompt, evaluateCode),
+        ]);
+        const agent1Result = result1.status === 'fulfilled'
+            ? result1.value
+            : { response: '', error: String(result1.reason), score: 0, timeMs: 0 };
+        const agent2Result = result2.status === 'fulfilled'
+            ? result2.value
+            : { response: '', error: String(result2.reason), score: 0, timeMs: 0 };
+        const totalTimeMs = Date.now() - startTime;
+        // Determine winner
+        let winner;
+        if (agent1Result.score > agent2Result.score) {
+            winner = this.agent1.getAgentId();
+        }
+        else if (agent2Result.score > agent1Result.score) {
+            winner = this.agent2.getAgentId();
+        }
+        else {
+            winner = 'tie';
+        }
+        const result = {
+            prompt: prompt.slice(0, 100),
+            agent1: {
+                id: this.agent1.getAgentId(),
+                score: agent1Result.score,
+                responseLength: agent1Result.response.length,
+                timeMs: agent1Result.timeMs,
+                error: agent1Result.error,
+            },
+            agent2: {
+                id: this.agent2.getAgentId(),
+                score: agent2Result.score,
+                responseLength: agent2Result.response.length,
+                timeMs: agent2Result.timeMs,
+                error: agent2Result.error,
+            },
+            winner,
+            totalTimeMs,
+        };
+        this.roundResults.push(result);
+        return result;
+    }
+    /**
+     * Run a single agent and return results.
+     */
+    async runAgent(agent, prompt, evaluateCode) {
+        const startTime = Date.now();
+        try {
+            const response = await agent.send(prompt);
+            const timeMs = Date.now() - startTime;
+            // Calculate score
+            let score = 50; // Base score
+            if (evaluateCode && response.includes('```')) {
+                const codeBlocks = extractCodeBlocks(response);
+                if (codeBlocks.length > 0) {
+                    const metrics = evaluateCodeQuality(codeBlocks[0]);
+                    score = calculateRewardScore(metrics);
+                }
+            }
+            return { response, score, timeMs };
+        }
+        catch (error) {
+            return {
+                response: '',
+                score: 0,
+                timeMs: Date.now() - startTime,
+                error: error instanceof Error ? error.message : String(error),
+            };
+        }
+    }
+    /**
+     * Get current competition standings.
+     */
+    getStandings() {
+        const agent1Wins = this.roundResults.filter((r) => r.winner === this.agent1.getAgentId()).length;
+        const agent2Wins = this.roundResults.filter((r) => r.winner === this.agent2.getAgentId()).length;
+        const ties = this.roundResults.filter((r) => r.winner === 'tie').length;
+        const total = this.roundResults.length;
+        return {
+            totalRounds: total,
+            agent1: {
+                id: this.agent1.getAgentId(),
+                wins: agent1Wins,
+                winRate: total > 0 ? agent1Wins / total : 0,
+            },
+            agent2: {
+                id: this.agent2.getAgentId(),
+                wins: agent2Wins,
+                winRate: total > 0 ? agent2Wins / total : 0,
+            },
+            ties,
+        };
+    }
+    /**
+     * Get all round results.
+     */
+    getRoundResults() {
+        return [...this.roundResults];
+    }
+    /**
+     * Reset competition history.
+     */
+    reset() {
+        this.roundResults.length = 0;
+    }
+}
+/**
+ * Tournament runner for multi-round competitions.
+ */
+export class TournamentRunner {
+    constructor(agent1, agent2) {
+        this.status = 'pending';
+        this.currentResult = null;
+        this.agent1 = agent1;
+        this.agent2 = agent2;
+    }
+    /**
+     * Run a tournament with the given configuration.
+     */
+    async run(config, callbacks) {
+        this.status = 'running';
+        const startTime = new Date();
+        const runner = new CompetitiveAgentRunner(this.agent1, this.agent2);
+        const rounds = [];
+        try {
+            for (let i = 0; i < config.rounds; i++) {
+                const prompt = config.prompts[i % config.prompts.length];
+                callbacks?.onRoundStart?.(i + 1, prompt);
+                const result = await runner.runComparison(prompt, config.evaluateCode);
+                rounds.push(result);
+                callbacks?.onRoundComplete?.(i + 1, result);
+            }
+            const endTime = new Date();
+            const totalDurationMs = endTime.getTime() - startTime.getTime();
+            const result = {
+                tournamentId: config.tournamentId,
+                config,
+                rounds,
+                standings: runner.getStandings(),
+                startTime: startTime.toISOString(),
+                endTime: endTime.toISOString(),
+                totalDurationMs,
+            };
+            this.currentResult = result;
+            this.status = 'completed';
+            callbacks?.onTournamentComplete?.(result);
+            return result;
+        }
+        catch (error) {
+            this.status = 'failed';
+            const err = error instanceof Error ? error : new Error(String(error));
+            callbacks?.onError?.(err);
+            throw err;
+        }
+    }
+    /**
+     * Get current tournament status.
+     */
+    getStatus() {
+        return this.status;
+    }
+    /**
+     * Get the tournament result (if completed).
+     */
+    getResult() {
+        return this.currentResult;
+    }
+}
+/**
+ * Generate a summary of tournament results.
+ */
+export function formatTournamentSummary(result) {
+    const lines = [
+        `Tournament: ${result.tournamentId}`,
+        '='.repeat(50),
+        '',
+        'Final Standings:',
+        `  ${result.standings.agent1.id}: ${result.standings.agent1.wins} wins (${(result.standings.agent1.winRate * 100).toFixed(1)}%)`,
+        `  ${result.standings.agent2.id}: ${result.standings.agent2.wins} wins (${(result.standings.agent2.winRate * 100).toFixed(1)}%)`,
+        `  Ties: ${result.standings.ties}`,
+        '',
+        `Total Rounds: ${result.standings.totalRounds}`,
+        `Duration: ${(result.totalDurationMs / 1000).toFixed(2)}s`,
+        '',
+        'Round Results:',
+    ];
+    for (let i = 0; i < result.rounds.length; i++) {
+        const round = result.rounds[i];
+        lines.push(`  Round ${i + 1}: ${round.winner === 'tie' ? 'Tie' : `${round.winner} wins`} ` +
+            `(${round.agent1.score.toFixed(1)} vs ${round.agent2.score.toFixed(1)})`);
+    }
+    return lines.join('\n');
+}

package/dist/bin/alpha-zero/index.js

@@ -0,0 +1,98 @@
+/**
+ * Alpha Zero 2 - Multi-Agent Competitive RL Framework
+ *
+ * A competitive reinforcement learning framework where two autonomous erosolar-cli
+ * agents compete on code optimization tasks while recursively improving their own
+ * implementations.
+ *
+ * Principal Investigator: Bo Shang
+ * Framework: erosolar-cli
+ * Status: Active Development
+ *
+ * Core Innovations:
+ * - Recursive Self-Modification Engine: Agents modify their own tool source code
+ * - Competitive Multi-Agent Framework: Tournament system with parallel execution
+ * - Version-Controlled Self-Improvement: SHA-256 checkpoints with automatic rollback
+ * - AST-Based Code Quality Metrics: Comprehensive evaluation across 10+ dimensions
+ *
+ * Structure:
+ * - Core: Types, metrics tracking, code evaluation
+ * - Self-Modification: Version-controlled code self-improvement
+ * - Introspection: Runtime analysis and self-awareness
+ * - Competitive: Multi-agent tournament framework
+ * - Security: Optional security research module (lazy loaded)
+ *
+ * Tech Stack (erosolar-cli):
+ * - Python: typer, rich, prompt-toolkit, pydantic, aiohttp, tiktoken
+ * - TypeScript: chalk, ora, gradient-string, boxen, nanospinner
+ * - AI Providers: anthropic, openai, google-generativeai
+ * - Testing: pytest, pytest-asyncio, mypy, ruff, eslint
+ *
+ * Research Contributions:
+ * - Demonstrated practical recursive self-improvement in autonomous agents
+ * - Proved competitive dynamics accelerate capability development
+ * - Established version control patterns for safe code self-modification
+ * - Created comprehensive metrics for evaluating code generation quality
+ *
+ * Citation:
+ *     @software{alpha_zero_2,
+ *       title={Alpha Zero 2: Recursive Self-Improvement in Competitive Multi-Agent Systems},
+ *       author={Bo Shang},
+ *       year={2024},
+ *       framework={erosolar-cli},
+ *       url={https://github.com/ErosolarAI/erosolar-by-bo}
+ *     }
+ */
+export { ALPHA_ZERO_2_METADATA } from './types.js';
+// Metrics Tracker
+export { MetricsTracker, createDefaultMetrics } from './metricsTracker.js';
+// Code Evaluator
+export { extractCodeBlocks, evaluateCodeQuality, calculateRewardScore, } from './codeEvaluator.js';
+// Agent Wrapper
+export { AlphaZeroAgentWrapper } from './agentWrapper.js';
+// Competitive Runner
+export { CompetitiveAgentRunner, TournamentRunner, formatTournamentSummary, } from './competitiveRunner.js';
+// Self-Modification Engine
+export { SelfModificationEngine, createSelfModificationEngine, } from './selfModification.js';
+// Introspection Engine
+export { IntrospectionEngine, createIntrospectionEngine, } from './introspection.js';
+// Security Module (optional, lazy loaded)
+export { isGoogleEnabled, getGoogleModule } from './security/googleLoader.js';
+export * from './security/index.js';
+/**
+ * Version information
+ */
+export const ALPHA_ZERO_VERSION = '1.0.0';
+export const ALPHA_ZERO_AUTHOR = 'Bo Shang';
+export const ALPHA_ZERO_FRAMEWORK = 'erosolar-cli';
+/**
+ * Check if security research module is available
+ */
+let _securityModule = null;
+export function isSecurityEnabled() {
+    if (_securityModule !== null) {
+        return true;
+    }
+    try {
+        // Module exists, can be loaded
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+/**
+ * Get security module (lazy load)
+ */
+export async function getSecurityModule() {
+    if (_securityModule === null) {
+        try {
+            _securityModule = await import('./security/index.js');
+        }
+        catch (error) {
+            throw new Error('Security research module not available. ' +
+                'Ensure security modules are built and available.');
+        }
+    }
+    return _securityModule;
+}

package/dist/bin/alpha-zero/introspection.js

@@ -0,0 +1,298 @@
+/**
+ * Introspection Engine for Alpha Zero 2
+ *
+ * Provides runtime analysis and self-awareness capabilities for agents.
+ * Tracks execution patterns and suggests improvements.
+ *
+ * Principal Investigator: Bo Shang
+ * Framework: erosolar-cli
+ */
+const DEFAULT_CONFIG = {
+    maxTraces: 1000,
+    enableProfiling: true,
+    suggestionThreshold: 0.3,
+    verbose: false,
+};
+/**
+ * Introspection Engine
+ *
+ * Provides self-awareness and analysis capabilities for agents.
+ */
+export class IntrospectionEngine {
+    constructor(config = {}) {
+        this.profiles = new Map();
+        this.codeAnalyses = new Map();
+        this.config = { ...DEFAULT_CONFIG, ...config };
+    }
+    /**
+     * Record an execution trace
+     */
+    recordExecution(toolId, trace) {
+        const profile = this.getOrCreateProfile(toolId);
+        const fullTrace = {
+            ...trace,
+            timestamp: Date.now(),
+        };
+        profile.traces.push(fullTrace);
+        profile.executionCount++;
+        profile.lastExecution = Date.now();
+        // Update averages
+        const totalTime = profile.traces.reduce((sum, t) => sum + (t.durationMs || 0), 0);
+        profile.averageExecutionTimeMs = totalTime / profile.executionCount;
+        // Update success rate
+        const successes = profile.traces.filter(t => t.success).length;
+        profile.successRate = successes / profile.executionCount;
+        // Trim old traces
+        if (profile.traces.length > this.config.maxTraces) {
+            profile.traces = profile.traces.slice(-this.config.maxTraces);
+        }
+        if (this.config.verbose) {
+            console.log(`[Introspection] Recorded execution for ${toolId}`);
+        }
+    }
+    /**
+     * Get performance profile for a tool
+     */
+    getProfile(toolId) {
+        return this.profiles.get(toolId) || null;
+    }
+    /**
+     * Get all performance profiles
+     */
+    getAllProfiles() {
+        return Array.from(this.profiles.values());
+    }
+    /**
+     * Analyze code and return analysis result
+     */
+    analyzeCode(filePath, code) {
+        const lines = code.split('\n');
+        const analysis = {
+            filePath,
+            lineCount: lines.length,
+            functionCount: this.countFunctions(code),
+            cyclomaticComplexity: this.calculateComplexity(code),
+            hasDocstrings: this.hasDocstrings(code),
+            hasTypeAnnotations: this.hasTypeAnnotations(code),
+            imports: this.extractImports(code),
+            exports: this.extractExports(code),
+            issues: this.findIssues(code),
+        };
+        this.codeAnalyses.set(filePath, analysis);
+        return analysis;
+    }
+    /**
+     * Generate improvement suggestions based on execution history
+     */
+    generateSuggestions(toolId) {
+        const profile = this.profiles.get(toolId);
+        if (!profile)
+            return [];
+        const suggestions = [];
+        // Check success rate
+        if (profile.successRate < this.config.suggestionThreshold) {
+            suggestions.push({
+                category: 'error-handling',
+                severity: 'high',
+                message: `Tool ${toolId} has low success rate (${(profile.successRate * 100).toFixed(1)}%)`,
+                suggestedAction: 'Add error handling and input validation',
+            });
+        }
+        // Check execution time
+        if (profile.averageExecutionTimeMs > 5000) {
+            suggestions.push({
+                category: 'performance',
+                severity: 'medium',
+                message: `Tool ${toolId} has high average execution time (${profile.averageExecutionTimeMs.toFixed(0)}ms)`,
+                suggestedAction: 'Consider caching, async operations, or algorithmic improvements',
+            });
+        }
+        // Check error patterns
+        const recentErrors = profile.traces
+            .filter(t => !t.success && t.timestamp > Date.now() - 3600000)
+            .map(t => t.error);
+        if (recentErrors.length > 5) {
+            const errorTypes = Array.from(new Set(recentErrors));
+            suggestions.push({
+                category: 'quality',
+                severity: 'high',
+                message: `Tool ${toolId} has ${recentErrors.length} recent errors`,
+                suggestedAction: `Address error types: ${errorTypes.slice(0, 3).join(', ')}`,
+            });
+        }
+        return suggestions;
+    }
+    /**
+     * Get aggregated metrics across all tools
+     */
+    getAggregatedMetrics() {
+        const profiles = this.getAllProfiles();
+        if (profiles.length === 0) {
+            return {
+                totalExecutions: 0,
+                averageSuccessRate: 0,
+                averageExecutionTime: 0,
+                toolCount: 0,
+            };
+        }
+        const totalExecutions = profiles.reduce((sum, p) => sum + p.executionCount, 0);
+        const avgSuccessRate = profiles.reduce((sum, p) => sum + p.successRate, 0) / profiles.length;
+        const avgTime = profiles.reduce((sum, p) => sum + p.averageExecutionTimeMs, 0) / profiles.length;
+        return {
+            totalExecutions,
+            averageSuccessRate: avgSuccessRate,
+            averageExecutionTime: avgTime,
+            toolCount: profiles.length,
+        };
+    }
+    /**
+     * Identify bottlenecks in execution
+     */
+    identifyBottlenecks() {
+        const bottlenecks = [];
+        for (const profile of Array.from(this.profiles.values())) {
+            // Slow tools
+            if (profile.averageExecutionTimeMs > 10000) {
+                bottlenecks.push({
+                    toolId: profile.toolId,
+                    issue: 'Very slow execution',
+                    severity: 0.8,
+                });
+            }
+            else if (profile.averageExecutionTimeMs > 5000) {
+                bottlenecks.push({
+                    toolId: profile.toolId,
+                    issue: 'Slow execution',
+                    severity: 0.5,
+                });
+            }
+            // Unreliable tools
+            if (profile.successRate < 0.5) {
+                bottlenecks.push({
+                    toolId: profile.toolId,
+                    issue: 'High failure rate',
+                    severity: 0.9,
+                });
+            }
+            else if (profile.successRate < 0.8) {
+                bottlenecks.push({
+                    toolId: profile.toolId,
+                    issue: 'Moderate failure rate',
+                    severity: 0.6,
+                });
+            }
+        }
+        // Sort by severity
+        return bottlenecks.sort((a, b) => b.severity - a.severity);
+    }
+    /**
+     * Clear all recorded data
+     */
+    clear() {
+        this.profiles.clear();
+        this.codeAnalyses.clear();
+    }
+    // Private helper methods
+    getOrCreateProfile(toolId) {
+        let profile = this.profiles.get(toolId);
+        if (!profile) {
+            profile = {
+                toolId,
+                executionCount: 0,
+                averageExecutionTimeMs: 0,
+                successRate: 1,
+                errorCount: 0,
+                traces: [],
+            };
+            this.profiles.set(toolId, profile);
+        }
+        return profile;
+    }
+    countFunctions(code) {
+        const functionPatterns = [
+            /function\s+\w+/g,
+            /\w+\s*=\s*(?:async\s+)?function/g,
+            /(?:async\s+)?(?:\w+|\(\w*\))\s*=>/g,
+            /\w+\s*\([^)]*\)\s*\{/g,
+        ];
+        let count = 0;
+        for (const pattern of functionPatterns) {
+            const matches = code.match(pattern);
+            if (matches)
+                count += matches.length;
+        }
+        return count;
+    }
+    calculateComplexity(code) {
+        // Simple cyclomatic complexity approximation
+        const controlFlowKeywords = [
+            'if', 'else', 'for', 'while', 'switch', 'case',
+            'try', 'catch', '&&', '\\|\\|', '\\?',
+        ];
+        let complexity = 1;
+        for (const keyword of controlFlowKeywords) {
+            const regex = new RegExp(`\\b${keyword}\\b`, 'g');
+            const matches = code.match(regex);
+            if (matches)
+                complexity += matches.length;
+        }
+        return complexity;
+    }
+    hasDocstrings(code) {
+        return code.includes('/**') || code.includes('///') || code.includes('/*');
+    }
+    hasTypeAnnotations(code) {
+        return (code.includes(': string') ||
+            code.includes(': number') ||
+            code.includes(': boolean') ||
+            code.includes(': void') ||
+            code.includes('<') && code.includes('>'));
+    }
+    extractImports(code) {
+        const importRegex = /import\s+.*?from\s+['"]([^'"]+)['"]/g;
+        const imports = [];
+        let match;
+        while ((match = importRegex.exec(code)) !== null) {
+            if (match[1])
+                imports.push(match[1]);
+        }
+        return imports;
+    }
+    extractExports(code) {
+        const exportRegex = /export\s+(?:const|function|class|type|interface)\s+(\w+)/g;
+        const exports = [];
+        let match;
+        while ((match = exportRegex.exec(code)) !== null) {
+            if (match[1])
+                exports.push(match[1]);
+        }
+        return exports;
+    }
+    findIssues(code) {
+        const issues = [];
+        // Check for console.log in production code
+        if (code.includes('console.log')) {
+            issues.push('Contains console.log statements');
+        }
+        // Check for TODO/FIXME comments
+        if (code.includes('TODO') || code.includes('FIXME')) {
+            issues.push('Contains TODO/FIXME comments');
+        }
+        // Check for any type
+        if (code.includes(': any')) {
+            issues.push('Uses any type');
+        }
+        // Check for very long lines
+        const longLines = code.split('\n').filter(line => line.length > 120);
+        if (longLines.length > 0) {
+            issues.push(`Has ${longLines.length} lines over 120 characters`);
+        }
+        return issues;
+    }
+}
+/**
+ * Create a default introspection engine
+ */
+export function createIntrospectionEngine(config) {
+    return new IntrospectionEngine(config);
+}