erosolar-cli 1.5.2 → 1.5.4

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

@@ -0,0 +1,231 @@
+/**
+ * Self-Modification Engine for Alpha Zero 2
+ *
+ * Enables autonomous code self-modification with version control.
+ * Agents can modify their own tool source code based on performance feedback.
+ *
+ * Principal Investigator: Bo Shang
+ * Framework: erosolar-cli
+ */
+import * as crypto from 'crypto';
+import * as fs from 'fs/promises';
+import * as path from 'path';
+const DEFAULT_CONFIG = {
+    dataDir: '.alpha_zero_versions',
+    maxVersions: 100,
+    enableAutoRollback: true,
+    minQualityThreshold: 0.7,
+    verbose: false,
+};
+/**
+ * Self-Modification Engine
+ *
+ * Manages version-controlled code modifications with automatic rollback.
+ */
+export class SelfModificationEngine {
+    constructor(config = {}) {
+        this.versions = new Map();
+        this.config = { ...DEFAULT_CONFIG, ...config };
+    }
+    /**
+     * Create a checkpoint of current tool code
+     */
+    async createCheckpoint(toolId, sourceCode, metrics) {
+        const hash = this.computeHash(sourceCode);
+        const versionId = `${toolId}-${Date.now()}-${hash.slice(0, 8)}`;
+        const toolVersions = this.versions.get(toolId) || [];
+        const lastVersion = toolVersions.length > 0 ? toolVersions[toolVersions.length - 1] : undefined;
+        const parentVersion = lastVersion?.versionId;
+        const version = {
+            versionId,
+            hash,
+            timestamp: Date.now(),
+            sourceCode,
+            performanceMetrics: metrics,
+            parentVersion,
+        };
+        toolVersions.push(version);
+        this.versions.set(toolId, toolVersions);
+        // Persist to disk
+        await this.saveVersion(toolId, version);
+        if (this.config.verbose) {
+            console.log(`[SelfMod] Created checkpoint ${versionId}`);
+        }
+        return version;
+    }
+    /**
+     * Attempt to modify tool code
+     */
+    async modifyTool(toolId, currentCode, modifiedCode, testFn) {
+        // Create checkpoint of current code
+        const currentVersion = await this.createCheckpoint(toolId, currentCode);
+        // Test modified code if test function provided
+        let testResult;
+        if (testFn) {
+            try {
+                testResult = await testFn(modifiedCode);
+            }
+            catch (error) {
+                return {
+                    success: false,
+                    previousVersion: currentVersion,
+                    error: `Test execution failed: ${error}`,
+                    rolledBack: false,
+                };
+            }
+            // Check if tests pass
+            if (!testResult.passed && this.config.enableAutoRollback) {
+                if (this.config.verbose) {
+                    console.log(`[SelfMod] Tests failed, rolling back`);
+                }
+                return {
+                    success: false,
+                    previousVersion: currentVersion,
+                    error: `Tests failed: ${testResult.failedTests}/${testResult.totalTests}`,
+                    rolledBack: true,
+                };
+            }
+        }
+        // Create new version
+        const newVersion = await this.createCheckpoint(toolId, modifiedCode, {
+            executionTimeMs: 0,
+            memoryUsageMb: 0,
+            errorCount: testResult?.failedTests || 0,
+            successRate: testResult ? testResult.passedTests / testResult.totalTests : 1,
+            qualityScore: this.evaluateCodeQuality(modifiedCode),
+        });
+        newVersion.testResults = testResult;
+        // Calculate performance delta
+        const performanceDelta = newVersion.performanceMetrics && currentVersion.performanceMetrics
+            ? newVersion.performanceMetrics.qualityScore - currentVersion.performanceMetrics.qualityScore
+            : 0;
+        return {
+            success: true,
+            newVersion,
+            previousVersion: currentVersion,
+            performanceDelta,
+            rolledBack: false,
+        };
+    }
+    /**
+     * Rollback to a previous version
+     */
+    async rollback(toolId, targetVersionId) {
+        const toolVersions = this.versions.get(toolId);
+        if (!toolVersions || toolVersions.length < 2) {
+            return null;
+        }
+        if (targetVersionId) {
+            const targetIndex = toolVersions.findIndex(v => v.versionId === targetVersionId);
+            if (targetIndex === -1)
+                return null;
+            // Remove versions after target
+            const removedVersions = toolVersions.splice(targetIndex + 1);
+            if (this.config.verbose) {
+                console.log(`[SelfMod] Rolled back ${removedVersions.length} versions`);
+            }
+            return toolVersions[targetIndex] ?? null;
+        }
+        // Rollback to previous version
+        toolVersions.pop();
+        return toolVersions[toolVersions.length - 1] ?? null;
+    }
+    /**
+     * Get version history for a tool
+     */
+    getVersionHistory(toolId) {
+        return this.versions.get(toolId) || [];
+    }
+    /**
+     * Get current version of a tool
+     */
+    getCurrentVersion(toolId) {
+        const versions = this.versions.get(toolId);
+        return versions && versions.length > 0 ? (versions[versions.length - 1] ?? null) : null;
+    }
+    /**
+     * Compare two versions
+     */
+    compareVersions(version1, version2) {
+        const codeChanged = version1.hash !== version2.hash;
+        const q1 = version1.performanceMetrics?.qualityScore || 0;
+        const q2 = version2.performanceMetrics?.qualityScore || 0;
+        return {
+            codeChanged,
+            performanceImproved: q2 > q1,
+            qualityDelta: q2 - q1,
+        };
+    }
+    /**
+     * Evaluate code quality (simplified AST-based analysis)
+     */
+    evaluateCodeQuality(code) {
+        let score = 0.5; // Base score
+        // Check for documentation
+        if (code.includes('/**') || code.includes('///')) {
+            score += 0.1;
+        }
+        // Check for error handling
+        if (code.includes('try') && code.includes('catch')) {
+            score += 0.1;
+        }
+        // Check for type annotations (TypeScript)
+        if (code.includes(': string') || code.includes(': number') || code.includes(': boolean')) {
+            score += 0.1;
+        }
+        // Check for async/await patterns
+        if (code.includes('async') && code.includes('await')) {
+            score += 0.05;
+        }
+        // Penalize very long functions
+        const lines = code.split('\n').length;
+        if (lines > 200) {
+            score -= 0.1;
+        }
+        return Math.max(0, Math.min(1, score));
+    }
+    /**
+     * Compute SHA-256 hash of code
+     */
+    computeHash(code) {
+        return crypto.createHash('sha256').update(code).digest('hex');
+    }
+    /**
+     * Save version to disk
+     */
+    async saveVersion(toolId, version) {
+        const dir = path.join(this.config.dataDir, toolId);
+        await fs.mkdir(dir, { recursive: true });
+        const filePath = path.join(dir, `${version.versionId}.json`);
+        await fs.writeFile(filePath, JSON.stringify(version, null, 2));
+    }
+    /**
+     * Load versions from disk
+     */
+    async loadVersions(toolId) {
+        const dir = path.join(this.config.dataDir, toolId);
+        try {
+            const files = await fs.readdir(dir);
+            const versions = [];
+            for (const file of files) {
+                if (file.endsWith('.json')) {
+                    const content = await fs.readFile(path.join(dir, file), 'utf-8');
+                    versions.push(JSON.parse(content));
+                }
+            }
+            // Sort by timestamp
+            versions.sort((a, b) => a.timestamp - b.timestamp);
+            this.versions.set(toolId, versions);
+            return versions;
+        }
+        catch {
+            return [];
+        }
+    }
+}
+/**
+ * Create a default self-modification engine
+ */
+export function createSelfModificationEngine(config) {
+    return new SelfModificationEngine(config);
+}

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

@@ -0,0 +1,30 @@
+/**
+ * Alpha Zero 2 - Type Definitions
+ *
+ * Core type definitions for the competitive multi-agent RL framework.
+ *
+ * Principal Investigator: Bo Shang
+ * Framework: erosolar-cli
+ */
+/**
+ * Default research metadata.
+ */
+export const ALPHA_ZERO_2_METADATA = {
+    projectName: 'Alpha Zero 2',
+    version: '1.0.0',
+    author: 'Bo Shang',
+    framework: 'erosolar-cli',
+    description: 'Recursive Self-Improvement in Competitive Multi-Agent Systems',
+    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',
+    ],
+    techStack: {
+        python: ['typer', 'rich', 'prompt-toolkit', 'pydantic', 'aiohttp', 'tiktoken'],
+        typescript: ['chalk', 'ora', 'gradient-string', 'boxen', 'nanospinner'],
+        aiProviders: ['anthropic', 'openai', 'google-generativeai'],
+        testing: ['pytest', 'pytest-asyncio', 'mypy', 'ruff', 'eslint'],
+    },
+};

package/dist/bin/bin/erosolar-optimized.js

@@ -0,0 +1,205 @@
+#!/usr/bin/env node
+/**
+ * Optimized Erosolar CLI Entry Point
+ *
+ * Features:
+ * - Fast-path commands for simple operations
+ * - Lazy loading for complex functionality
+ * - Performance monitoring
+ * - Graceful error handling
+ */
+import { readFileSync } from 'node:fs';
+import { dirname, resolve } from 'node:path';
+import { fileURLToPath } from 'node:url';
+// Fast-path command handling
+function handleFastPathCommand(argv) {
+    const command = argv[0];
+    switch (command) {
+        case '--version':
+        case 'version':
+        case '-v':
+            console.log(`Erosolar CLI v${getPackageVersion()}`);
+            return true;
+        case '--help':
+        case 'help':
+        case '-h':
+            showFastHelp();
+            return true;
+        case '--json':
+            // Defer to full implementation for JSON mode
+            return false;
+        case 'health-check':
+            // This will be handled in main async function
+            return false;
+        case 'status':
+            showStatus();
+            return true;
+    }
+    return false;
+}
+// Get package version without full initialization
+function getPackageVersion() {
+    try {
+        const filePath = fileURLToPath(import.meta.url);
+        const packagePath = resolve(dirname(filePath), '../../package.json');
+        const payload = JSON.parse(readFileSync(packagePath, 'utf8'));
+        return typeof payload.version === 'string' ? payload.version : '0.0.0';
+    }
+    catch {
+        return '0.0.0';
+    }
+}
+// Fast help without full initialization
+function showFastHelp() {
+    console.log(`
+Erosolar CLI v${getPackageVersion()} - Fast Help
+
+Usage:
+  erosolar [command] [options]
+
+Fast Commands:
+  version, -v           Show version
+  help, -h             Show this help
+  status               Show system status
+
+Full Commands:
+  [interactive]        Start interactive shell
+  --json <command>     Run command in JSON mode
+  health-check         Run health check
+
+Options:
+  --provider <name>    Specify AI provider
+  --model <name>       Specify AI model
+  --profile <name>     Use specific agent profile
+
+Examples:
+  erosolar version
+  erosolar --json "list files"
+  erosolar --provider openai --model gpt-4
+`);
+}
+// Run health check without full initialization
+async function runHealthCheck() {
+    console.log('🧪 Running fast health check...\n');
+    const checks = [
+        { name: 'Node.js version', check: checkNodeVersion },
+        { name: 'Package configuration', check: checkPackageConfig },
+        { name: 'Build directory', check: checkBuildDir },
+        { name: 'Main binary', check: checkMainBinary },
+    ];
+    let passed = 0;
+    let failed = 0;
+    for (const { name, check } of checks) {
+        try {
+            await check();
+            console.log(`✅ ${name}`);
+            passed++;
+        }
+        catch (error) {
+            console.log(`❌ ${name}: ${error instanceof Error ? error.message : error}`);
+            failed++;
+        }
+    }
+    console.log(`\n📊 Results: ${passed} passed, ${failed} failed`);
+    if (failed > 0) {
+        process.exit(1);
+    }
+}
+// Check Node.js version
+function checkNodeVersion() {
+    const version = process.version;
+    const major = parseInt(version.slice(1).split('.')[0], 10);
+    if (major < 20) {
+        throw new Error(`Node.js ${version} is too old, requires >=20.0.0`);
+    }
+}
+// Check package configuration
+function checkPackageConfig() {
+    const filePath = fileURLToPath(import.meta.url);
+    const packagePath = resolve(dirname(filePath), '../../package.json');
+    if (!readFileSync(packagePath, 'utf8')) {
+        throw new Error('Package.json not found or empty');
+    }
+}
+// Check build directory
+function checkBuildDir() {
+    const filePath = fileURLToPath(import.meta.url);
+    const buildPath = resolve(dirname(filePath), '../../dist');
+    try {
+        const stats = readFileSync(buildPath);
+        if (!stats) {
+            throw new Error('Build directory does not exist');
+        }
+    }
+    catch {
+        throw new Error('Build directory does not exist');
+    }
+}
+// Check main binary
+function checkMainBinary() {
+    const filePath = fileURLToPath(import.meta.url);
+    const binaryPath = resolve(dirname(filePath), '../../dist/bin/erosolar.js');
+    try {
+        const stats = readFileSync(binaryPath);
+        if (!stats) {
+            throw new Error('Main binary does not exist');
+        }
+    }
+    catch {
+        throw new Error('Main binary does not exist');
+    }
+}
+// Show system status
+function showStatus() {
+    console.log(`
+Erosolar CLI Status
+───────────────────
+Version: ${getPackageVersion()}
+Node.js: ${process.version}
+Platform: ${process.platform} ${process.arch}
+Working Directory: ${process.cwd()}
+
+Fast Commands: ✅ Available
+Full Shell: ⚠️  May be slow to initialize
+Health Check: ✅ Available
+`);
+}
+// Main execution
+async function main() {
+    const argv = process.argv.slice(2);
+    // Handle fast-path commands
+    if (handleFastPathCommand(argv)) {
+        return;
+    }
+    // Handle health check (needs to be async)
+    if (argv[0] === 'health-check') {
+        await runHealthCheck();
+        return;
+    }
+    // Defer to full implementation for complex commands
+    console.log('🚀 Starting full Erosolar CLI...');
+    console.log('⏳ This may take a moment for complex initialization...\n');
+    try {
+        if (argv.includes('--json')) {
+            const { runHeadlessApp } = await import('../headless/headlessApp.js');
+            await runHeadlessApp({ argv });
+        }
+        else {
+            const { launchShell } = await import('../shell/shellApp.js');
+            await launchShell('erosolar-code', { enableProfileSelection: true });
+        }
+    }
+    catch (error) {
+        console.error('\n❌ CLI Error:', error instanceof Error ? error.message : error);
+        // Provide helpful suggestions
+        if (error instanceof Error && error.message.includes('Cannot find module')) {
+            console.log('\n💡 Try running: npm run build');
+        }
+        process.exit(1);
+    }
+}
+// Start the application
+main().catch((error) => {
+    console.error('Fatal error:', error instanceof Error ? error.message : error);
+    process.exit(1);
+});

package/dist/bin/capabilities/agentSpawningCapability.js

@@ -0,0 +1,116 @@
+import { TaskRunner } from '../subagents/taskRunner.js';
+export class AgentSpawningCapabilityModule {
+    constructor() {
+        this.id = 'capability.agent-spawning';
+    }
+    async create(context) {
+        const runner = new TaskRunner(context);
+        return {
+            id: 'agent-spawning.tools',
+            description: 'Launch specialized agents to handle complex, multi-step tasks autonomously',
+            toolSuite: {
+                id: 'agent-spawning',
+                description: 'Task agent spawning and management',
+                tools: [
+                    {
+                        name: 'Task',
+                        description: `Launch a new agent to handle complex, multi-step tasks autonomously.
+
+The Task tool launches specialized agents (subprocesses) that autonomously handle complex tasks. Each agent type has specific capabilities and tools available to it.
+
+Available agent types and the tools they have access to:
+- general-purpose: General-purpose agent for researching complex questions, searching for code, and executing multi-step tasks. When you are searching for a keyword or file and are not confident that you will find the right match in the first few tries use this agent to perform the search for you. (Tools: *)
+- Explore: Fast agent specialized for exploring codebases. Use this when you need to quickly find files by patterns (eg. "src/components/**/*.tsx"), search code for keywords (eg. "API endpoints"), or answer questions about the codebase (eg. "how do API endpoints work?"). When calling this agent, specify the desired thoroughness level: "quick" for basic searches, "medium" for moderate exploration, or "very thorough" for comprehensive analysis across multiple locations and naming conventions. (Tools: All tools)
+- Plan: Fast agent specialized for planning tasks. Use this when you need to break down complex tasks into steps, analyze requirements, or create implementation strategies. (Tools: All tools)
+
+When using the Task tool, you must specify a subagent_type parameter to select which agent type to use.
+
+When NOT to use the Task tool:
+- If you want to read a specific file path, use the Read or Glob tool instead of the Task tool, to find the match more quickly
+- If you are searching for a specific class definition like "class Foo", use the Glob tool instead, to find the match more quickly
+- If you are searching for code within a specific file or set of 2-3 files, use the Read tool instead of the Task tool, to find the match more quickly
+- Other tasks that are not related to the agent descriptions above
+
+Usage notes:
+- Launch multiple agents concurrently whenever possible, to maximize performance; to do that, use a single message with multiple tool uses
+- When the agent is done, it will return a single message back to you. The result returned by the agent is not visible to the user. To show the user the result, you should send a text message back to the user with a concise summary of the result.
+- Each agent invocation is stateless. You will not be able to send additional messages to the agent, nor will the agent be able to communicate with you outside of its final report. Therefore, your prompt should contain a highly detailed task description for the agent to perform autonomously and you should specify exactly what information the agent should return back to you in its final and only message to you.
+- The agent's outputs should generally be trusted
+- Clearly tell the agent whether you expect it to write code or just to do research (search, file reads, web fetches, etc.), since it is not aware of the user's intent
+- If the agent description mentions that it should be used proactively, then you should try your best to use it without the user having to ask for it first. Use your judgement.
+
+Example usage:
+- "Find all TypeScript files in the project and identify which ones use async/await"
+- "Explore the authentication system and explain how JWT tokens are validated"
+- "Plan the implementation of a new user dashboard feature"`,
+                        parameters: {
+                            type: 'object',
+                            properties: {
+                                description: {
+                                    type: 'string',
+                                    description: 'A short (3-5 word) description of the task',
+                                },
+                                prompt: {
+                                    type: 'string',
+                                    description: 'The task for the agent to perform',
+                                },
+                                subagent_type: {
+                                    type: 'string',
+                                    description: 'The type of specialized agent to use for this task',
+                                },
+                                model: {
+                                    type: 'string',
+                                    enum: ['sonnet', 'opus', 'haiku'],
+                                    description: 'Optional model to use for this agent. If not specified, inherits from parent. Prefer haiku for quick, straightforward tasks to minimize cost and latency.',
+                                },
+                                resume: {
+                                    type: 'string',
+                                    description: 'Optional agent ID to resume from. If provided, the agent will continue from the previous execution transcript.',
+                                },
+                            },
+                            required: ['description', 'prompt', 'subagent_type'],
+                        },
+                        handler: async (args) => {
+                            try {
+                                const input = parseTaskArguments(args);
+                                const result = await runner.runTask(input);
+                                return result.output;
+                            }
+                            catch (error) {
+                                const message = error instanceof Error ? error.message : String(error);
+                                return `Task tool failed: ${message}`;
+                            }
+                        },
+                    },
+                ],
+            },
+        };
+    }
+}
+function parseTaskArguments(args) {
+    const description = expectString(args['description'], 'description');
+    const prompt = expectString(args['prompt'], 'prompt');
+    const subagentType = expectString(args['subagent_type'], 'subagent_type');
+    const modelValue = typeof args['model'] === 'string' ? args['model'].trim().toLowerCase() : undefined;
+    let model;
+    if (modelValue) {
+        if (modelValue !== 'sonnet' && modelValue !== 'opus' && modelValue !== 'haiku') {
+            throw new Error(`Invalid model "${args['model']}". Allowed values are sonnet, opus, or haiku.`);
+        }
+        model = modelValue;
+    }
+    const resumeId = typeof args['resume'] === 'string' ? args['resume'].trim() : undefined;
+    return {
+        description,
+        prompt,
+        subagentType,
+        model,
+        resumeId: resumeId && resumeId.length ? resumeId : undefined,
+    };
+}
+function expectString(value, field) {
+    if (typeof value !== 'string' || !value.trim()) {
+        throw new Error(`Task tool is missing a valid "${field}" parameter.`);
+    }
+    return value.trim();
+}

package/dist/bin/capabilities/bashCapability.js

@@ -0,0 +1,22 @@
+import { createBashTools } from '../tools/bashTools.js';
+export class BashCapabilityModule {
+    constructor(options = {}) {
+        this.id = 'capability.bash';
+        this.options = options;
+    }
+    async create(context) {
+        const workingDir = this.options.workingDir ?? context.workingDir;
+        return {
+            id: this.options.id ?? 'bash.tools.shell',
+            description: this.options.description ?? 'Shell execution with stdout/stderr summaries for reproducibility.',
+            toolSuite: {
+                id: 'bash',
+                description: 'Shell access',
+                tools: createBashTools(workingDir),
+            },
+            metadata: {
+                workingDir,
+            },
+        };
+    }
+}

package/dist/bin/capabilities/cloudCapability.js

@@ -0,0 +1,36 @@
+import { createCloudTools } from '../tools/cloudTools.js';
+export class CloudCapabilityModule {
+    constructor(options = {}) {
+        this.id = 'capability.cloud';
+        this.options = options;
+    }
+    async create(context) {
+        const workingDir = this.options.workingDir ?? context.workingDir;
+        return {
+            id: this.options.id ?? 'cloud.tools.deployment',
+            description: this.options.description ??
+                'Cloud deployment tools with automatic CLI detection, configuration checking, and auto-fixing for Firebase, Aliyun, AWS, GCP, Azure, Vercel, Netlify, and more.',
+            toolSuite: {
+                id: 'cloud',
+                description: 'Multi-cloud deployment and management tools',
+                tools: createCloudTools(workingDir),
+            },
+            metadata: {
+                workingDir,
+                supportedProviders: [
+                    'firebase',
+                    'aliyun',
+                    'aws',
+                    'gcloud',
+                    'azure',
+                    'vercel',
+                    'netlify',
+                    'cloudflare',
+                    'fly',
+                    'railway',
+                    'supabase',
+                ],
+            },
+        };
+    }
+}

package/dist/bin/capabilities/codeAnalysisCapability.js

@@ -0,0 +1,22 @@
+import { createCodeAnalysisTools } from '../tools/codeAnalysisTools.js';
+export class CodeAnalysisCapabilityModule {
+    constructor(options = {}) {
+        this.id = 'capability.code-analysis';
+        this.options = options;
+    }
+    async create(context) {
+        const workingDir = this.options.workingDir ?? context.workingDir;
+        return {
+            id: this.options.id ?? 'code-analysis.tools.structural',
+            description: this.options.description ?? 'Advanced code structure analysis, dependency tracking, and complexity metrics.',
+            toolSuite: {
+                id: 'code-analysis',
+                description: 'Code analysis and metrics',
+                tools: createCodeAnalysisTools(workingDir),
+            },
+            metadata: {
+                workingDir,
+            },
+        };
+    }
+}

package/dist/bin/capabilities/codeQualityCapability.js

@@ -0,0 +1,23 @@
+import { createCodeQualityTools } from '../tools/codeQualityTools.js';
+export class CodeQualityCapabilityModule {
+    constructor(options = {}) {
+        this.id = 'capability.code-quality';
+        this.options = options;
+    }
+    async create(context) {
+        const workingDir = this.options.workingDir ?? context.workingDir;
+        return {
+            id: this.options.id ?? 'code-quality.tools.linting',
+            description: this.options.description ??
+                'Code quality helpers for linting, maintainability analysis, and ESLint rule discovery.',
+            toolSuite: {
+                id: 'code-quality',
+                description: 'Code quality and linting',
+                tools: createCodeQualityTools(workingDir),
+            },
+            metadata: {
+                workingDir,
+            },
+        };
+    }
+}