erosolar-cli 1.7.55 → 1.7.57

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

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

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

@@ -1,207 +0,0 @@
-/**
- * Alpha Zero 2 - Metrics Tracker
- *
- * Performance metrics tracking for agent sessions.
- *
- * Principal Investigator: Bo Shang
- * Framework: erosolar-cli
- */
-/**
- * Creates default performance metrics.
- */
-export function createDefaultMetrics(sessionId) {
-    return {
-        sessionId,
-        totalMessages: 0,
-        totalToolCalls: 0,
-        totalTokensUsed: 0,
-        totalTimeMs: 0,
-        successfulToolCalls: 0,
-        failedToolCalls: 0,
-        codeBlocksGenerated: 0,
-        avgResponseTimeMs: 0,
-        avgCodeQuality: 0,
-        avgAlgorithmEfficiency: 0,
-        avgErrorHandling: 0,
-    };
-}
-/**
- * Tracks performance metrics for an agent session.
- */
-export class MetricsTracker {
-    constructor(sessionId) {
-        this.responseTimes = [];
-        this.codeQualityScores = [];
-        this.efficiencyScores = [];
-        this.errorHandlingScores = [];
-        this.traces = [];
-        this.metrics = createDefaultMetrics(sessionId);
-    }
-    /**
-     * Record a message exchange.
-     */
-    recordMessage(elapsedMs, usage) {
-        this.metrics.totalMessages += 1;
-        this.metrics.totalTimeMs += elapsedMs;
-        this.responseTimes.push(elapsedMs);
-        if (usage) {
-            const tokens = usage.totalTokens ?? (usage.inputTokens ?? 0) + (usage.outputTokens ?? 0);
-            this.metrics.totalTokensUsed += tokens;
-        }
-        this.updateAverages();
-    }
-    /**
-     * Record a tool call.
-     */
-    recordToolCall(success) {
-        this.metrics.totalToolCalls += 1;
-        if (success) {
-            this.metrics.successfulToolCalls += 1;
-        }
-        else {
-            this.metrics.failedToolCalls += 1;
-        }
-    }
-    /**
-     * Record code generation.
-     */
-    recordCodeGeneration(codeBlockCount) {
-        this.metrics.codeBlocksGenerated += codeBlockCount;
-    }
-    /**
-     * Record code quality evaluation.
-     */
-    recordCodeQuality(quality) {
-        this.codeQualityScores.push(quality.codeQualityScore);
-        this.efficiencyScores.push(quality.algorithmEfficiency);
-        this.errorHandlingScores.push(quality.errorHandlingScore);
-        this.updateAverages();
-    }
-    /**
-     * Add an execution trace.
-     */
-    addTrace(trace) {
-        this.traces.push(trace);
-        // Keep only the last 100 traces
-        if (this.traces.length > 100) {
-            this.traces.shift();
-        }
-    }
-    /**
-     * Update running averages.
-     */
-    updateAverages() {
-        if (this.responseTimes.length > 0) {
-            this.metrics.avgResponseTimeMs =
-                this.responseTimes.reduce((a, b) => a + b, 0) / this.responseTimes.length;
-        }
-        if (this.codeQualityScores.length > 0) {
-            this.metrics.avgCodeQuality =
-                this.codeQualityScores.reduce((a, b) => a + b, 0) / this.codeQualityScores.length;
-        }
-        if (this.efficiencyScores.length > 0) {
-            this.metrics.avgAlgorithmEfficiency =
-                this.efficiencyScores.reduce((a, b) => a + b, 0) / this.efficiencyScores.length;
-        }
-        if (this.errorHandlingScores.length > 0) {
-            this.metrics.avgErrorHandling =
-                this.errorHandlingScores.reduce((a, b) => a + b, 0) / this.errorHandlingScores.length;
-        }
-    }
-    /**
-     * Get current metrics.
-     */
-    getMetrics() {
-        return { ...this.metrics };
-    }
-    /**
-     * Get execution traces.
-     */
-    getTraces() {
-        return [...this.traces];
-    }
-    /**
-     * Get human-readable performance summary.
-     */
-    getPerformanceSummary() {
-        const m = this.metrics;
-        const lines = [
-            `Agent Performance Summary: ${m.sessionId}`,
-            '='.repeat(50),
-            `Messages: ${m.totalMessages}`,
-            `Total Time: ${(m.totalTimeMs / 1000).toFixed(2)}s`,
-            `Avg Response: ${m.avgResponseTimeMs.toFixed(0)}ms`,
-            `Code Blocks: ${m.codeBlocksGenerated}`,
-            `Tokens Used: ${m.totalTokensUsed.toLocaleString()}`,
-            '',
-            'Tool Usage:',
-            `  Total Calls: ${m.totalToolCalls}`,
-            `  Success Rate: ${m.totalToolCalls > 0 ? ((m.successfulToolCalls / m.totalToolCalls) * 100).toFixed(1) : 0}%`,
-            '',
-            'Code Quality Metrics:',
-            `  Quality Score: ${(m.avgCodeQuality * 100).toFixed(1)}/100`,
-            `  Algorithm Efficiency: ${(m.avgAlgorithmEfficiency * 100).toFixed(1)}/100`,
-            `  Error Handling: ${(m.avgErrorHandling * 100).toFixed(1)}/100`,
-        ];
-        return lines.join('\n');
-    }
-    /**
-     * Get improvement suggestions based on metrics.
-     */
-    getImprovementSuggestions() {
-        const suggestions = [];
-        const m = this.metrics;
-        if (m.avgResponseTimeMs > 5000) {
-            suggestions.push({
-                category: 'performance',
-                severity: 'high',
-                message: 'Response time is high - consider optimizing prompts or using a faster model',
-                suggestedAction: 'Review prompt complexity and consider caching common operations',
-            });
-        }
-        if (m.avgCodeQuality < 0.5 && m.codeBlocksGenerated > 0) {
-            suggestions.push({
-                category: 'quality',
-                severity: 'medium',
-                message: 'Code quality is below average - enhance system prompt with coding best practices',
-                suggestedAction: 'Add explicit code style guidelines to the system prompt',
-            });
-        }
-        if (m.avgAlgorithmEfficiency < 0.5 && m.codeBlocksGenerated > 0) {
-            suggestions.push({
-                category: 'efficiency',
-                severity: 'medium',
-                message: 'Algorithm efficiency is low - add guidance for efficient data structures',
-                suggestedAction: 'Include examples of optimal algorithm patterns in prompts',
-            });
-        }
-        if (m.avgErrorHandling < 0.3 && m.codeBlocksGenerated > 0) {
-            suggestions.push({
-                category: 'error-handling',
-                severity: 'high',
-                message: 'Error handling is weak - instruct agent to include try/catch blocks',
-                suggestedAction: 'Require explicit error handling in generated code',
-            });
-        }
-        if (m.totalToolCalls > 0 && m.failedToolCalls / m.totalToolCalls > 0.2) {
-            suggestions.push({
-                category: 'performance',
-                severity: 'medium',
-                message: `Tool failure rate is ${((m.failedToolCalls / m.totalToolCalls) * 100).toFixed(1)}%`,
-                suggestedAction: 'Review failed tool calls and improve error recovery',
-            });
-        }
-        return suggestions;
-    }
-    /**
-     * Reset all metrics.
-     */
-    reset() {
-        this.metrics = createDefaultMetrics(this.metrics.sessionId);
-        this.responseTimes = [];
-        this.codeQualityScores = [];
-        this.efficiencyScores = [];
-        this.errorHandlingScores = [];
-        this.traces = [];
-    }
-}