erosolar-cli 1.5.3 → 1.5.5

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);
+}

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

@@ -0,0 +1,207 @@
+/**
+ * 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 = [];
+    }
+}