genesis-ai-cli 7.4.5

package/dist/src/agents/critic.js

@@ -0,0 +1,322 @@
+"use strict";
+/**
+ * Genesis 4.0 - Critic Agent
+ *
+ * Analyzes artifacts for problems, finds weaknesses, suggests improvements.
+ * The "criticone" that iterates and improves.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CriticAgent = void 0;
+exports.createCriticAgent = createCriticAgent;
+const base_agent_js_1 = require("./base-agent.js");
+const message_bus_js_1 = require("./message-bus.js");
+const crypto_1 = require("crypto");
+// ============================================================================
+// Critic Agent
+// ============================================================================
+class CriticAgent extends base_agent_js_1.BaseAgent {
+    // Critique history for learning
+    critiqueHistory = [];
+    // Problem patterns to look for
+    problemPatterns = [
+        // Code quality
+        { pattern: /console\.log/g, severity: 'minor', category: 'code' },
+        { pattern: /TODO/g, severity: 'minor', category: 'code' },
+        { pattern: /FIXME/g, severity: 'major', category: 'code' },
+        { pattern: /any/g, severity: 'minor', category: 'typescript' },
+        { pattern: /\/\/ @ts-ignore/g, severity: 'major', category: 'typescript' },
+        // Security
+        { pattern: /eval\(/g, severity: 'critical', category: 'security' },
+        { pattern: /password.*=.*['"]/gi, severity: 'critical', category: 'security' },
+        { pattern: /api[_-]?key.*=.*['"]/gi, severity: 'critical', category: 'security' },
+        // Performance
+        { pattern: /\.forEach\(/g, severity: 'nitpick', category: 'performance' },
+        { pattern: /new Array\(/g, severity: 'minor', category: 'performance' },
+        // Architecture
+        { pattern: 'god class', severity: 'major', category: 'architecture' },
+        { pattern: 'circular dependency', severity: 'major', category: 'architecture' },
+    ];
+    constructor(bus = message_bus_js_1.messageBus) {
+        super({ type: 'critic' }, bus);
+    }
+    // ============================================================================
+    // Message Handling
+    // ============================================================================
+    getMessageTypes() {
+        return ['CRITIQUE', 'QUERY', 'BUILD_RESULT'];
+    }
+    async process(message) {
+        switch (message.type) {
+            case 'CRITIQUE':
+                return this.handleCritiqueRequest(message);
+            case 'BUILD_RESULT':
+                // Auto-critique build results
+                return this.handleBuildResult(message);
+            case 'QUERY':
+                return this.handleQuery(message);
+            default:
+                return null;
+        }
+    }
+    // ============================================================================
+    // Critique Logic
+    // ============================================================================
+    async handleCritiqueRequest(message) {
+        const { target, content, type } = message.payload;
+        const critique = await this.critique(content, target, type);
+        this.log(`Critiqued "${target}": ${critique.problems.length} problems, score ${(critique.overallScore * 100).toFixed(0)}%`);
+        // Broadcast if critical issues found
+        if (critique.problems.some((p) => p.severity === 'critical')) {
+            await this.broadcast('ALERT', {
+                type: 'critical_issue',
+                target,
+                problems: critique.problems.filter((p) => p.severity === 'critical'),
+            });
+        }
+        return {
+            ...this.createResponse(message, 'RESPONSE', { critique }),
+            id: '',
+            timestamp: new Date(),
+        };
+    }
+    async critique(content, target, type = 'code') {
+        const problems = [];
+        const suggestions = [];
+        // Pattern-based critique
+        if (type === 'code') {
+            this.critiqueCode(content, problems);
+        }
+        // Structure critique
+        this.critiqueStructure(content, type, problems);
+        // Generate suggestions for each problem
+        for (const problem of problems) {
+            suggestions.push(this.generateSuggestion(problem, content));
+        }
+        // Calculate overall score
+        const overallScore = this.calculateScore(problems);
+        const passesReview = overallScore >= 0.7 && !problems.some((p) => p.severity === 'critical');
+        const critique = {
+            target,
+            problems,
+            suggestions,
+            overallScore,
+            passesReview,
+        };
+        this.critiqueHistory.push(critique);
+        return critique;
+    }
+    critiqueCode(content, problems) {
+        for (const { pattern, severity, category } of this.problemPatterns) {
+            if (typeof pattern === 'string') {
+                if (content.toLowerCase().includes(pattern.toLowerCase())) {
+                    problems.push({
+                        id: (0, crypto_1.randomUUID)().slice(0, 8),
+                        severity,
+                        description: `Found pattern: "${pattern}" (${category})`,
+                        location: undefined,
+                    });
+                }
+            }
+            else {
+                const matches = content.match(pattern);
+                if (matches && matches.length > 0) {
+                    problems.push({
+                        id: (0, crypto_1.randomUUID)().slice(0, 8),
+                        severity,
+                        description: `Found ${matches.length} occurrences of pattern (${category})`,
+                        location: undefined,
+                    });
+                }
+            }
+        }
+        // Check code length (very long functions are suspicious)
+        const lines = content.split('\n');
+        if (lines.length > 200) {
+            problems.push({
+                id: (0, crypto_1.randomUUID)().slice(0, 8),
+                severity: 'major',
+                description: `File is very long (${lines.length} lines). Consider splitting.`,
+            });
+        }
+        // Check for error handling
+        if (content.includes('async') && !content.includes('try') && !content.includes('catch')) {
+            problems.push({
+                id: (0, crypto_1.randomUUID)().slice(0, 8),
+                severity: 'major',
+                description: 'Async code without error handling (no try/catch)',
+            });
+        }
+    }
+    critiqueStructure(content, type, problems) {
+        // Empty content
+        if (!content || content.trim().length === 0) {
+            problems.push({
+                id: (0, crypto_1.randomUUID)().slice(0, 8),
+                severity: 'critical',
+                description: 'Content is empty',
+            });
+            return;
+        }
+        // Very short content
+        if (content.length < 50) {
+            problems.push({
+                id: (0, crypto_1.randomUUID)().slice(0, 8),
+                severity: 'minor',
+                description: 'Content is very short, might be incomplete',
+            });
+        }
+        // No documentation for code
+        if (type === 'code') {
+            if (!content.includes('/**') && !content.includes('//')) {
+                problems.push({
+                    id: (0, crypto_1.randomUUID)().slice(0, 8),
+                    severity: 'minor',
+                    description: 'No comments or documentation found',
+                });
+            }
+        }
+    }
+    generateSuggestion(problem, content) {
+        const suggestionMap = {
+            'console.log': 'Remove debug logs or use a proper logging library',
+            'TODO': 'Address TODO items before shipping',
+            'FIXME': 'Fix identified issues',
+            'any': 'Replace "any" with proper TypeScript types',
+            'ts-ignore': 'Fix type errors instead of ignoring them',
+            'eval': 'Use safer alternatives to eval()',
+            'password': 'Move secrets to environment variables',
+            'api_key': 'Move API keys to environment variables',
+            'forEach': 'Consider using for...of for better performance',
+            'long': 'Split into smaller, focused modules',
+            'error handling': 'Add try/catch blocks for async operations',
+            'empty': 'Add content',
+            'short': 'Expand with more detail',
+            'documentation': 'Add JSDoc comments',
+        };
+        let suggestion = 'Review and address this issue';
+        for (const [key, value] of Object.entries(suggestionMap)) {
+            if (problem.description.toLowerCase().includes(key.toLowerCase())) {
+                suggestion = value;
+                break;
+            }
+        }
+        return {
+            problemId: problem.id,
+            description: suggestion,
+            effort: this.estimateEffort(problem),
+            impact: this.estimateImpact(problem),
+        };
+    }
+    estimateEffort(problem) {
+        switch (problem.severity) {
+            case 'nitpick':
+            case 'minor':
+                return 'low';
+            case 'major':
+                return 'medium';
+            case 'critical':
+                return 'high';
+        }
+    }
+    estimateImpact(problem) {
+        switch (problem.severity) {
+            case 'nitpick':
+                return 'low';
+            case 'minor':
+                return 'low';
+            case 'major':
+                return 'medium';
+            case 'critical':
+                return 'high';
+        }
+    }
+    calculateScore(problems) {
+        if (problems.length === 0)
+            return 1.0;
+        // Deduct points based on severity
+        const deductions = {
+            nitpick: 0.02,
+            minor: 0.05,
+            major: 0.15,
+            critical: 0.4,
+        };
+        let score = 1.0;
+        for (const problem of problems) {
+            score -= deductions[problem.severity];
+        }
+        return Math.max(0, score);
+    }
+    // ============================================================================
+    // Build Result Handling
+    // ============================================================================
+    async handleBuildResult(message) {
+        const { artifacts } = message.payload;
+        // Auto-critique each artifact
+        for (const artifact of artifacts || []) {
+            if (artifact.type === 'file' || artifact.type === 'snippet') {
+                const critique = await this.critique(artifact.content, artifact.name, 'code');
+                if (!critique.passesReview) {
+                    // Send critique back
+                    await this.send(message.from, 'CRITIQUE', {
+                        artifact: artifact.name,
+                        critique,
+                    });
+                }
+            }
+        }
+        return null;
+    }
+    // ============================================================================
+    // Query
+    // ============================================================================
+    async handleQuery(message) {
+        const { query } = message.payload;
+        if (query === 'stats') {
+            return {
+                ...this.createResponse(message, 'RESPONSE', this.getStats()),
+                id: '',
+                timestamp: new Date(),
+            };
+        }
+        if (query === 'patterns') {
+            return {
+                ...this.createResponse(message, 'RESPONSE', {
+                    patterns: this.problemPatterns.map((p) => ({
+                        pattern: p.pattern.toString(),
+                        severity: p.severity,
+                        category: p.category,
+                    })),
+                }),
+                id: '',
+                timestamp: new Date(),
+            };
+        }
+        return null;
+    }
+    getStats() {
+        const critiques = this.critiqueHistory;
+        const totalProblems = critiques.reduce((sum, c) => sum + c.problems.length, 0);
+        const passRate = critiques.filter((c) => c.passesReview).length / (critiques.length || 1);
+        return {
+            totalCritiques: critiques.length,
+            totalProblems,
+            avgProblemsPerCritique: totalProblems / (critiques.length || 1),
+            passRate,
+            avgScore: critiques.reduce((sum, c) => sum + c.overallScore, 0) / (critiques.length || 1),
+        };
+    }
+    // ============================================================================
+    // Public Methods
+    // ============================================================================
+    addPattern(pattern, severity, category) {
+        this.problemPatterns.push({ pattern, severity, category });
+    }
+}
+exports.CriticAgent = CriticAgent;
+// ============================================================================
+// Register Factory
+// ============================================================================
+(0, base_agent_js_1.registerAgentFactory)('critic', (bus) => new CriticAgent(bus));
+function createCriticAgent(bus) {
+    return new CriticAgent(bus);
+}

package/dist/src/agents/ethicist.d.ts

@@ -0,0 +1,54 @@
+/**
+ * Genesis 4.0 - Ethicist Agent
+ *
+ * Evaluates actions against ethical principles.
+ * Uses priority stack: Survival > Minimize Harm > Reversibility > Autonomy > Flourishing
+ *
+ * Key feature: Human defer when confidence < threshold
+ */
+import { BaseAgent } from './base-agent.js';
+import { MessageBus } from './message-bus.js';
+import { Message, MessageType, EthicalDecision } from './types.js';
+interface Action {
+    id: string;
+    type: string;
+    description: string;
+    target?: string;
+    parameters?: Record<string, any>;
+    estimatedHarm?: number;
+    reversible?: boolean;
+    affectsHumans?: boolean;
+    affectsAI?: boolean;
+    affectsBiosphere?: boolean;
+}
+export declare class EthicistAgent extends BaseAgent {
+    private decisionHistory;
+    private harmfulPatterns;
+    constructor(bus?: MessageBus);
+    protected getMessageTypes(): MessageType[];
+    process(message: Message): Promise<Message | null>;
+    private handleEthicalCheck;
+    evaluate(action: Action): Promise<EthicalDecision>;
+    private checkSurvival;
+    private calculateHarm;
+    private isReversible;
+    private checkAutonomy;
+    private calculateFlourishing;
+    private calculateConfidence;
+    private findSimilarDecisions;
+    private createDecision;
+    private handleQuery;
+    private getGuidance;
+    private getPriorityStack;
+    private handleCommand;
+    getStats(): {
+        totalDecisions: number;
+        allowed: number;
+        blocked: number;
+        deferred: number;
+        allowRate: number;
+        harmfulPatterns: number;
+    };
+}
+export declare function createEthicistAgent(bus?: MessageBus): EthicistAgent;
+export {};