erosolar-cli 1.7.55 → 1.7.57

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

@@ -1,272 +0,0 @@
-/**
- * Alpha Zero 2 - Code Evaluator
- *
- * AST-based code quality evaluation for generated code.
- *
- * Principal Investigator: Bo Shang
- * Framework: erosolar-cli
- */
-/**
- * Extract code blocks from a response string.
- */
-export function extractCodeBlocks(response) {
-    const codeBlockRegex = /```(?:\w+)?\n([\s\S]*?)```/g;
-    const blocks = [];
-    let match;
-    while ((match = codeBlockRegex.exec(response)) !== null) {
-        const code = match[1]?.trim();
-        if (code && code.length > 0) {
-            blocks.push(code);
-        }
-    }
-    return blocks;
-}
-/**
- * Evaluate code quality metrics.
- *
- * This is a heuristic-based evaluation that analyzes code patterns.
- * For production use, consider integrating actual AST parsers.
- */
-export function evaluateCodeQuality(code) {
-    const lines = code.split('\n');
-    const totalLines = lines.length;
-    // Calculate individual scores
-    const codeQualityScore = calculateCodeQualityScore(code, lines);
-    const algorithmEfficiency = calculateEfficiencyScore(code, lines);
-    const errorHandlingScore = calculateErrorHandlingScore(code);
-    const documentationScore = calculateDocumentationScore(code, lines);
-    const maintainabilityScore = calculateMaintainabilityScore(code, lines, totalLines);
-    const securityScore = calculateSecurityScore(code);
-    return {
-        codeQualityScore,
-        algorithmEfficiency,
-        errorHandlingScore,
-        documentationScore,
-        maintainabilityScore,
-        securityScore,
-    };
-}
-/**
- * Calculate overall code quality score.
- */
-function calculateCodeQualityScore(code, lines) {
-    let score = 0.5; // Base score
-    // Check for consistent indentation
-    const indentationConsistent = checkIndentationConsistency(lines);
-    if (indentationConsistent) {
-        score += 0.1;
-    }
-    // Check for reasonable line lengths
-    const longLines = lines.filter((line) => line.length > 120).length;
-    if (longLines / lines.length < 0.1) {
-        score += 0.1;
-    }
-    // Check for naming conventions (camelCase or snake_case)
-    if (/[a-z][A-Z]/.test(code) || /_[a-z]/.test(code)) {
-        score += 0.1;
-    }
-    // Check for modular structure (functions/classes)
-    if (/(?:function|def|class|const\s+\w+\s*=\s*(?:async\s*)?\()/.test(code)) {
-        score += 0.1;
-    }
-    // Penalize magic numbers
-    const magicNumbers = code.match(/(?<![.\w])[2-9]\d*(?![.\w])/g) || [];
-    if (magicNumbers.length > 5) {
-        score -= 0.1;
-    }
-    return Math.max(0, Math.min(1, score));
-}
-/**
- * Calculate algorithm efficiency score.
- */
-function calculateEfficiencyScore(code, _lines) {
-    let score = 0.5;
-    // Check for efficient data structures
-    if (/(?:Map|Set|WeakMap|WeakSet|dict|set)\s*\(/.test(code)) {
-        score += 0.15;
-    }
-    // Penalize nested loops (potential O(n^2) or worse)
-    const nestedLoops = code.match(/(?:for|while)[\s\S]*?(?:for|while)/g)?.length || 0;
-    if (nestedLoops > 2) {
-        score -= 0.2;
-    }
-    // Check for early returns (efficient control flow)
-    if (/return\s+(?!undefined|null)/.test(code)) {
-        score += 0.1;
-    }
-    // Check for caching/memoization patterns
-    if (/(?:cache|memo|stored|cached)/i.test(code)) {
-        score += 0.15;
-    }
-    // Penalize string concatenation in loops
-    if (/(?:for|while)[\s\S]*?\+\s*=\s*['"`]/.test(code)) {
-        score -= 0.1;
-    }
-    return Math.max(0, Math.min(1, score));
-}
-/**
- * Calculate error handling score.
- */
-function calculateErrorHandlingScore(code) {
-    let score = 0.3;
-    // Check for try-catch blocks
-    const tryCatchCount = (code.match(/try\s*\{/g) || []).length;
-    if (tryCatchCount > 0) {
-        score += 0.2 * Math.min(tryCatchCount, 3);
-    }
-    // Check for error type checking
-    if (/instanceof\s+(?:Error|TypeError|RangeError)/i.test(code)) {
-        score += 0.1;
-    }
-    // Check for null/undefined checks
-    const nullChecks = (code.match(/(?:!==?\s*(?:null|undefined)|\?\?|\.?\?\.)/g) || []).length;
-    if (nullChecks > 0) {
-        score += 0.1 * Math.min(nullChecks / 3, 1);
-    }
-    // Check for error logging
-    if (/(?:console\.error|logger\.error|throw\s+new)/i.test(code)) {
-        score += 0.1;
-    }
-    // Check for finally blocks (cleanup)
-    if (/finally\s*\{/.test(code)) {
-        score += 0.1;
-    }
-    return Math.max(0, Math.min(1, score));
-}
-/**
- * Calculate documentation score.
- */
-function calculateDocumentationScore(code, lines) {
-    let score = 0.2;
-    // Check for JSDoc/docstring comments
-    const docComments = (code.match(/\/\*\*[\s\S]*?\*\/|"""[\s\S]*?"""|'''[\s\S]*?'''/g) || []).length;
-    if (docComments > 0) {
-        score += 0.3 * Math.min(docComments / 3, 1);
-    }
-    // Check for inline comments
-    const inlineComments = lines.filter((line) => /(?:\/\/|#)\s*\w/.test(line)).length;
-    const commentRatio = inlineComments / lines.length;
-    if (commentRatio > 0.05 && commentRatio < 0.3) {
-        score += 0.2;
-    }
-    // Check for type annotations (TypeScript/Python type hints)
-    if (/:\s*(?:string|number|boolean|any|\w+\[\]|Dict|List|Optional)/i.test(code)) {
-        score += 0.2;
-    }
-    // Check for meaningful variable names (longer than 2 chars)
-    const shortNames = (code.match(/\b[a-z]{1,2}\b/g) || []).length;
-    if (shortNames / lines.length < 0.5) {
-        score += 0.1;
-    }
-    return Math.max(0, Math.min(1, score));
-}
-/**
- * Calculate maintainability score.
- */
-function calculateMaintainabilityScore(code, lines, totalLines) {
-    let score = 0.5;
-    // Check function length (prefer smaller functions)
-    const functionMatches = code.match(/(?:function|def|=>\s*\{)/g) || [];
-    if (functionMatches.length > 0) {
-        const avgFunctionLength = totalLines / functionMatches.length;
-        if (avgFunctionLength < 30) {
-            score += 0.2;
-        }
-        else if (avgFunctionLength > 100) {
-            score -= 0.2;
-        }
-    }
-    // Check for single responsibility (low coupling indicators)
-    const importCount = (code.match(/(?:import|require|from\s+['"])/g) || []).length;
-    if (importCount < 10) {
-        score += 0.1;
-    }
-    // Check for constants (uppercase naming)
-    if (/const\s+[A-Z_]+\s*=/.test(code)) {
-        score += 0.1;
-    }
-    // Penalize deeply nested code
-    const maxIndentation = Math.max(...lines.map((line) => {
-        const match = line.match(/^(\s*)/);
-        return match ? match[1].length : 0;
-    }));
-    if (maxIndentation > 20) {
-        score -= 0.15;
-    }
-    return Math.max(0, Math.min(1, score));
-}
-/**
- * Calculate security score.
- */
-function calculateSecurityScore(code) {
-    let score = 0.7; // Assume secure by default
-    // Check for potential injection vulnerabilities
-    const dangerousPatterns = [
-        /eval\s*\(/i,
-        /exec\s*\(/i,
-        /Function\s*\(/i,
-        /innerHTML\s*=/i,
-        /dangerouslySetInnerHTML/i,
-        /document\.write/i,
-    ];
-    for (const pattern of dangerousPatterns) {
-        if (pattern.test(code)) {
-            score -= 0.15;
-        }
-    }
-    // Check for hardcoded secrets
-    if (/(?:password|secret|api[_-]?key|token)\s*=\s*['"][^'"]+['"]/i.test(code)) {
-        score -= 0.3;
-    }
-    // Check for SQL injection risks
-    if (/(?:SELECT|INSERT|UPDATE|DELETE)[\s\S]*?\$\{/.test(code)) {
-        score -= 0.2;
-    }
-    // Check for input validation
-    if (/(?:validate|sanitize|escape|parameterized)/i.test(code)) {
-        score += 0.1;
-    }
-    return Math.max(0, Math.min(1, score));
-}
-/**
- * Check for consistent indentation.
- */
-function checkIndentationConsistency(lines) {
-    const indentSizes = new Set();
-    for (const line of lines) {
-        if (line.trim().length === 0)
-            continue;
-        const match = line.match(/^(\s*)/);
-        if (match && match[1]) {
-            const size = match[1].length;
-            if (size > 0) {
-                indentSizes.add(size);
-            }
-        }
-    }
-    // Check if all indentations are multiples of a common base
-    const sizes = Array.from(indentSizes).sort((a, b) => a - b);
-    if (sizes.length < 2)
-        return true;
-    const base = sizes[0];
-    return sizes.every((size) => size % base === 0);
-}
-/**
- * Calculate a composite reward score from metrics.
- */
-export function calculateRewardScore(metrics) {
-    const weights = {
-        codeQuality: 0.25,
-        efficiency: 0.2,
-        errorHandling: 0.2,
-        documentation: 0.15,
-        maintainability: 0.1,
-        security: 0.1,
-    };
-    return (metrics.codeQualityScore * weights.codeQuality +
-        metrics.algorithmEfficiency * weights.efficiency +
-        metrics.errorHandlingScore * weights.errorHandling +
-        metrics.documentationScore * weights.documentation +
-        metrics.maintainabilityScore * weights.maintainability +
-        metrics.securityScore * weights.security) * 100;
-}

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

@@ -1,219 +0,0 @@
-/**
- * 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

@@ -1,98 +0,0 @@
-/**
- * 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;
-}