genesis-ai-cli 7.4.5

package/dist/src/agents/sensor.js

@@ -0,0 +1,377 @@
+"use strict";
+/**
+ * Genesis 4.0 - Sensor Agent
+ *
+ * Interface to MCP servers (the system's sensory organs).
+ * Routes requests to appropriate MCP servers and collects results.
+ *
+ * 13 MCP Servers as Senses:
+ * - KNOWLEDGE: arxiv, semantic-scholar, context7, wolfram
+ * - RESEARCH: gemini, brave-search, exa, firecrawl
+ * - CREATION: openai, github, stability-ai
+ * - STORAGE: memory, filesystem
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SensorAgent = void 0;
+exports.createSensorAgent = createSensorAgent;
+const base_agent_js_1 = require("./base-agent.js");
+const message_bus_js_1 = require("./message-bus.js");
+const index_js_1 = require("../mcp/index.js");
+// ============================================================================
+// Sensor Agent
+// ============================================================================
+class SensorAgent extends base_agent_js_1.BaseAgent {
+    // Registry of MCP servers
+    mcpServers = new Map();
+    // Request history for analytics
+    requestHistory = [];
+    constructor(bus = message_bus_js_1.messageBus) {
+        super({ type: 'sensor' }, bus);
+        this.initializeMCPRegistry();
+    }
+    initializeMCPRegistry() {
+        // Knowledge MCPs
+        this.registerMCP('arxiv', 'knowledge', [
+            'search_papers', 'get_paper', 'parse_paper', 'get_recent_ai'
+        ]);
+        this.registerMCP('semantic-scholar', 'knowledge', [
+            'search_papers', 'get_paper', 'get_citations', 'to_bibtex'
+        ]);
+        this.registerMCP('context7', 'knowledge', [
+            'resolve_library', 'query_docs'
+        ]);
+        this.registerMCP('wolfram', 'knowledge', [
+            'query', 'calculate', 'facts'
+        ]);
+        // Research MCPs
+        this.registerMCP('gemini', 'research', [
+            'web_search', 'web_search_batch'
+        ]);
+        this.registerMCP('brave-search', 'research', [
+            'web_search', 'local_search', 'news_search', 'image_search', 'video_search'
+        ]);
+        this.registerMCP('exa', 'research', [
+            'web_search', 'code_context'
+        ]);
+        this.registerMCP('firecrawl', 'research', [
+            'scrape', 'map', 'search', 'crawl', 'extract'
+        ]);
+        // Creation MCPs
+        this.registerMCP('openai', 'creation', [
+            'chat', 'generate_text'
+        ]);
+        this.registerMCP('github', 'creation', [
+            'create_repo', 'create_file', 'create_pr', 'search_code', 'list_issues'
+        ]);
+        this.registerMCP('stability-ai', 'creation', [
+            'generate_image', 'upscale', 'remove_background', 'outpaint'
+        ]);
+        // Storage MCPs
+        this.registerMCP('memory', 'storage', [
+            'create_entities', 'search_nodes', 'read_graph', 'add_observations'
+        ]);
+        this.registerMCP('filesystem', 'storage', [
+            'read_file', 'write_file', 'list_directory', 'search_files'
+        ]);
+    }
+    registerMCP(name, category, capabilities) {
+        this.mcpServers.set(name, {
+            name,
+            category,
+            capabilities,
+            available: true, // Assume available, will update on first use
+            lastChecked: new Date(),
+            successRate: 1.0,
+            callCount: 0,
+        });
+    }
+    // ============================================================================
+    // Message Handling
+    // ============================================================================
+    getMessageTypes() {
+        return ['SENSE', 'QUERY', 'COMMAND'];
+    }
+    async process(message) {
+        switch (message.type) {
+            case 'SENSE':
+                return this.handleSenseRequest(message);
+            case 'QUERY':
+                return this.handleQuery(message);
+            case 'COMMAND':
+                return this.handleCommand(message);
+            default:
+                return null;
+        }
+    }
+    // ============================================================================
+    // Sense (MCP Request)
+    // ============================================================================
+    async handleSenseRequest(message) {
+        const request = message.payload;
+        const result = await this.sense(request);
+        return {
+            ...this.createResponse(message, 'RESPONSE', result),
+            id: '',
+            timestamp: new Date(),
+        };
+    }
+    async sense(request) {
+        const startTime = Date.now();
+        // Find appropriate server
+        const server = this.findServer(request);
+        if (!server) {
+            return {
+                server: 'none',
+                success: false,
+                error: `No server found for capability: ${request.capability}`,
+                latency: Date.now() - startTime,
+                mode: 'simulated',
+            };
+        }
+        this.log(`Sensing via ${server.name}: ${request.capability}`);
+        // Use the MCP client module (supports real/simulated/hybrid modes)
+        const mcpClient = (0, index_js_1.getMCPClient)();
+        const result = await mcpClient.call(server.name, request.capability, request.params, {
+            timeout: request.timeout,
+        });
+        // Record the request for tracking
+        this.recordRequest(server.name, result.success, result.latency);
+        return {
+            server: server.name,
+            success: result.success,
+            data: result.data,
+            error: result.error,
+            latency: result.latency,
+            mode: result.mode,
+        };
+    }
+    findServer(request) {
+        // Specific server requested
+        if (request.server) {
+            return this.mcpServers.get(request.server) || null;
+        }
+        // Find by category
+        if (request.category) {
+            for (const server of this.mcpServers.values()) {
+                if (server.category === request.category &&
+                    server.capabilities.includes(request.capability) &&
+                    server.available) {
+                    return server;
+                }
+            }
+        }
+        // Find any server with the capability
+        for (const server of this.mcpServers.values()) {
+            if (server.capabilities.includes(request.capability) && server.available) {
+                return server;
+            }
+        }
+        // Try fuzzy match on capability
+        const capabilityLower = request.capability.toLowerCase();
+        for (const server of this.mcpServers.values()) {
+            if (server.available &&
+                server.capabilities.some((c) => c.includes(capabilityLower) || capabilityLower.includes(c))) {
+                return server;
+            }
+        }
+        return null;
+    }
+    // ============================================================================
+    // Request Tracking
+    // ============================================================================
+    recordRequest(server, success, latency) {
+        // Update server stats
+        const mcpServer = this.mcpServers.get(server);
+        if (mcpServer) {
+            mcpServer.callCount++;
+            mcpServer.lastChecked = new Date();
+            // Update success rate (exponential moving average)
+            const alpha = 0.1;
+            mcpServer.successRate = alpha * (success ? 1 : 0) + (1 - alpha) * mcpServer.successRate;
+            // Mark unavailable if success rate drops too low
+            if (mcpServer.successRate < 0.3 && mcpServer.callCount > 10) {
+                mcpServer.available = false;
+                this.log(`Server ${server} marked unavailable (success rate: ${(mcpServer.successRate * 100).toFixed(0)}%)`);
+            }
+        }
+        // Add to history
+        this.requestHistory.push({
+            server,
+            success,
+            latency,
+            timestamp: new Date(),
+        });
+        // Keep history bounded
+        if (this.requestHistory.length > 1000) {
+            this.requestHistory.shift();
+        }
+    }
+    // ============================================================================
+    // Query
+    // ============================================================================
+    async handleQuery(message) {
+        const { query } = message.payload;
+        if (query === 'servers') {
+            return {
+                ...this.createResponse(message, 'RESPONSE', {
+                    servers: Array.from(this.mcpServers.values()),
+                }),
+                id: '',
+                timestamp: new Date(),
+            };
+        }
+        if (query === 'categories') {
+            const byCategory = {
+                knowledge: [],
+                research: [],
+                creation: [],
+                storage: [],
+            };
+            for (const server of this.mcpServers.values()) {
+                byCategory[server.category].push(server.name);
+            }
+            return {
+                ...this.createResponse(message, 'RESPONSE', { categories: byCategory }),
+                id: '',
+                timestamp: new Date(),
+            };
+        }
+        if (query === 'capabilities') {
+            const capabilities = {};
+            for (const server of this.mcpServers.values()) {
+                capabilities[server.name] = server.capabilities;
+            }
+            return {
+                ...this.createResponse(message, 'RESPONSE', { capabilities }),
+                id: '',
+                timestamp: new Date(),
+            };
+        }
+        if (query === 'stats') {
+            return {
+                ...this.createResponse(message, 'RESPONSE', this.getStats()),
+                id: '',
+                timestamp: new Date(),
+            };
+        }
+        return null;
+    }
+    // ============================================================================
+    // Commands
+    // ============================================================================
+    async handleCommand(message) {
+        const { command, params } = message.payload;
+        switch (command) {
+            case 'check_health':
+                await this.checkAllServers();
+                return {
+                    ...this.createResponse(message, 'RESPONSE', {
+                        servers: Array.from(this.mcpServers.values()),
+                    }),
+                    id: '',
+                    timestamp: new Date(),
+                };
+            case 'enable_server':
+                const serverToEnable = this.mcpServers.get(params.server);
+                if (serverToEnable) {
+                    serverToEnable.available = true;
+                    serverToEnable.successRate = 0.5; // Reset
+                }
+                return {
+                    ...this.createResponse(message, 'RESPONSE', { success: true }),
+                    id: '',
+                    timestamp: new Date(),
+                };
+            case 'disable_server':
+                const serverToDisable = this.mcpServers.get(params.server);
+                if (serverToDisable) {
+                    serverToDisable.available = false;
+                }
+                return {
+                    ...this.createResponse(message, 'RESPONSE', { success: true }),
+                    id: '',
+                    timestamp: new Date(),
+                };
+            case 'execute_step':
+                // Execute sensing for a plan step
+                const result = await this.sense({
+                    capability: params.step,
+                    params: { context: params.planId },
+                });
+                return {
+                    ...this.createResponse(message, 'RESPONSE', result),
+                    id: '',
+                    timestamp: new Date(),
+                };
+            default:
+                return null;
+        }
+    }
+    async checkAllServers() {
+        const mcpClient = (0, index_js_1.getMCPClient)();
+        for (const server of this.mcpServers.values()) {
+            // Check availability via MCP client
+            server.available = await mcpClient.isAvailable(server.name);
+            server.lastChecked = new Date();
+        }
+    }
+    // ============================================================================
+    // Stats
+    // ============================================================================
+    getStats() {
+        const servers = Array.from(this.mcpServers.values());
+        const available = servers.filter((s) => s.available);
+        const recentRequests = this.requestHistory.slice(-100);
+        const successfulRequests = recentRequests.filter((r) => r.success);
+        const avgLatency = recentRequests.length > 0
+            ? recentRequests.reduce((sum, r) => sum + r.latency, 0) / recentRequests.length
+            : 0;
+        return {
+            totalServers: servers.length,
+            availableServers: available.length,
+            serversByCategory: {
+                knowledge: servers.filter((s) => s.category === 'knowledge').length,
+                research: servers.filter((s) => s.category === 'research').length,
+                creation: servers.filter((s) => s.category === 'creation').length,
+                storage: servers.filter((s) => s.category === 'storage').length,
+            },
+            totalRequests: this.requestHistory.length,
+            recentSuccessRate: recentRequests.length > 0
+                ? successfulRequests.length / recentRequests.length
+                : 1,
+            avgLatency,
+        };
+    }
+    // ============================================================================
+    // Public API
+    // ============================================================================
+    getAvailableServers() {
+        return Array.from(this.mcpServers.values()).filter((s) => s.available);
+    }
+    getServersByCategory(category) {
+        return Array.from(this.mcpServers.values()).filter((s) => s.category === category);
+    }
+    hasCapability(capability) {
+        return this.findServer({ capability, params: {} }) !== null;
+    }
+    /**
+     * Get the current MCP mode (real/simulated/hybrid)
+     */
+    getMCPMode() {
+        return (0, index_js_1.getMCPClient)().getMode();
+    }
+    /**
+     * Check if running in simulated mode
+     */
+    isSimulated() {
+        return this.getMCPMode() === 'simulated';
+    }
+}
+exports.SensorAgent = SensorAgent;
+// ============================================================================
+// Register Factory
+// ============================================================================
+(0, base_agent_js_1.registerAgentFactory)('sensor', (bus) => new SensorAgent(bus));
+function createSensorAgent(bus) {
+    return new SensorAgent(bus);
+}

package/dist/src/agents/test-agents.d.ts

@@ -0,0 +1,6 @@
+/**
+ * Genesis 4.0 - Agent System Test
+ *
+ * Quick test to verify all agents spawn and communicate correctly.
+ */
+export {};

package/dist/src/agents/test-agents.js

@@ -0,0 +1,73 @@
+"use strict";
+/**
+ * Genesis 4.0 - Agent System Test
+ *
+ * Quick test to verify all agents spawn and communicate correctly.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+const index_js_1 = require("./index.js");
+async function testAgentSystem() {
+    console.log('='.repeat(60));
+    console.log('Genesis 4.0 - Agent System Test');
+    console.log('='.repeat(60));
+    // Create the full ecosystem
+    console.log('\n1. Spawning all agents...');
+    const { registry, agents } = (0, index_js_1.createAgentEcosystem)();
+    console.log(`   Spawned ${agents.size} agents:`);
+    for (const [type, agent] of agents) {
+        console.log(`   - ${type}: ${agent.id}`);
+    }
+    // Wake all agents
+    console.log('\n2. Waking all agents...');
+    for (const agent of agents.values()) {
+        agent.wake();
+    }
+    // Test message passing
+    console.log('\n3. Testing message passing...');
+    // Test Explorer
+    console.log('   - Testing Explorer...');
+    const explorerResponse = await index_js_1.messageBus.request('test', 'explorer', 'QUERY', { query: 'search for AI papers' }, 5000).catch(() => ({ payload: { error: 'timeout' } }));
+    console.log(`     Result: ${JSON.stringify(explorerResponse.payload).slice(0, 80)}...`);
+    // Test Feeling
+    console.log('   - Testing Feeling...');
+    const feelingResponse = await index_js_1.messageBus.request('test', 'feeling', 'FEELING', { content: 'This is an exciting new discovery!', context: 'research' }, 5000).catch(() => ({ payload: { error: 'timeout' } }));
+    console.log(`     Result: ${JSON.stringify(feelingResponse.payload).slice(0, 80)}...`);
+    // Test Ethicist
+    console.log('   - Testing Ethicist...');
+    const ethicsResponse = await index_js_1.messageBus.request('test', 'ethicist', 'ETHICAL_CHECK', {
+        id: 'test-action',
+        type: 'create',
+        description: 'Create a new document',
+    }, 5000).catch(() => ({ payload: { error: 'timeout' } }));
+    console.log(`     Result: ${JSON.stringify(ethicsResponse.payload).slice(0, 80)}...`);
+    // Test Planner
+    console.log('   - Testing Planner...');
+    const planResponse = await index_js_1.messageBus.request('test', 'planner', 'PLAN', { goal: 'Research and build a new feature', template: 'pipeline' }, 5000).catch(() => ({ payload: { error: 'timeout' } }));
+    console.log(`     Result: ${JSON.stringify(planResponse.payload).slice(0, 80)}...`);
+    // Test Critic
+    console.log('   - Testing Critic...');
+    const critiqueResponse = await index_js_1.messageBus.request('test', 'critic', 'CRITIQUE', {
+        target: 'test-code',
+        content: 'console.log("debug"); function test() { // TODO: implement }',
+        type: 'code',
+    }, 5000).catch(() => ({ payload: { error: 'timeout' } }));
+    console.log(`     Result: ${JSON.stringify(critiqueResponse.payload).slice(0, 80)}...`);
+    // Test Sensor
+    console.log('   - Testing Sensor...');
+    const sensorResponse = await index_js_1.messageBus.request('test', 'sensor', 'QUERY', { query: 'stats' }, 5000).catch(() => ({ payload: { error: 'timeout' } }));
+    console.log(`     Result: ${JSON.stringify(sensorResponse.payload).slice(0, 80)}...`);
+    // Get registry stats
+    console.log('\n4. Registry Stats:');
+    const stats = registry.getStats();
+    console.log(`   Total agents: ${stats.totalAgents}`);
+    console.log(`   By type: ${JSON.stringify(stats.byType)}`);
+    console.log(`   By state: ${JSON.stringify(stats.byState)}`);
+    // Shutdown
+    console.log('\n5. Shutting down...');
+    registry.shutdownAll();
+    console.log('\n' + '='.repeat(60));
+    console.log('Test Complete!');
+    console.log('='.repeat(60));
+}
+// Run test
+testAgentSystem().catch(console.error);

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

@@ -0,0 +1,194 @@
+/**
+ * Genesis 4.0 - Agent Types
+ *
+ * Core type definitions for the multi-agent system.
+ */
+export type AgentType = 'explorer' | 'critic' | 'builder' | 'memory' | 'feeling' | 'narrator' | 'ethicist' | 'predictor' | 'planner' | 'sensor' | 'economic' | 'consciousness' | 'world-model' | 'causal' | 'swarm' | 'grounding' | 'anticipatory';
+export type AgentState = 'idle' | 'working' | 'waiting' | 'sleeping' | 'error';
+export type AgentId = string;
+export type MessageType = 'QUERY' | 'RESPONSE' | 'BROADCAST' | 'COMMAND' | 'ALERT' | 'FEELING' | 'MEMORY_STORE' | 'MEMORY_RETRIEVE' | 'ETHICAL_CHECK' | 'PREDICTION' | 'PLAN' | 'BUILD' | 'BUILD_REQUEST' | 'BUILD_RESULT' | 'CRITIQUE' | 'EXPLORATION' | 'NARRATE' | 'EVENT' | 'PREDICT' | 'FEEDBACK' | 'SENSE' | 'ERROR' | 'HEALTH' | 'WAKE' | 'SLEEP' | 'SHUTDOWN' | 'CONSOLIDATE' | 'DREAM' | 'COST_TRACK' | 'BUDGET_CHECK' | 'WORLD_PREDICT' | 'WORLD_SIMULATE' | 'WORLD_ENCODE' | 'PHI_CHECK' | 'PHI_REPORT' | 'GWT_BROADCAST' | 'ATTENTION' | 'MUTATION' | 'SANDBOX_TEST' | 'SWARM_UPDATE' | 'EMERGENCE' | 'GROUND_CLAIM' | 'INTERVENTION' | 'COUNTERFACTUAL';
+export type MessagePriority = 'critical' | 'high' | 'normal' | 'low';
+export interface Message {
+    id: string;
+    type: MessageType;
+    from: AgentId;
+    to: AgentId | 'broadcast' | 'kernel';
+    payload: any;
+    timestamp: Date;
+    priority: MessagePriority;
+    replyTo?: string;
+    correlationId?: string;
+}
+export interface Agent {
+    id: AgentId;
+    type: AgentType;
+    state: AgentState;
+    process(message: Message): Promise<Message | null>;
+    wake(): void;
+    sleep(): void;
+    shutdown(): void;
+    health(): HealthStatus;
+}
+export interface HealthStatus {
+    agentId: AgentId;
+    state: AgentState;
+    uptime: number;
+    messagesProcessed: number;
+    errors: number;
+    lastActivity: Date;
+    memoryUsage?: number;
+}
+export interface AgentConfig {
+    id?: AgentId;
+    type: AgentType;
+    priority?: MessagePriority;
+    maxConcurrent?: number;
+    timeout?: number;
+}
+export interface Feeling {
+    valence: number;
+    arousal: number;
+    importance: number;
+    category: FeelingCategory;
+}
+export type FeelingCategory = 'curiosity' | 'satisfaction' | 'frustration' | 'urgency' | 'calm' | 'concern';
+export interface EthicalDecision {
+    action: string;
+    allow: boolean | 'defer';
+    confidence: number;
+    reason: string;
+    priority: EthicalPriority;
+    reversible: boolean;
+    potentialHarm: number;
+    flourishingScore?: number;
+}
+export type EthicalPriority = 'P0_SURVIVAL' | 'P1_MINIMIZE_HARM' | 'P2_REVERSIBILITY' | 'P3_AUTONOMY' | 'P4_FLOURISHING';
+export interface MemoryItem {
+    id: string;
+    type: 'episodic' | 'semantic' | 'procedural';
+    content: any;
+    created: Date;
+    lastAccessed: Date;
+    accessCount: number;
+    R0: number;
+    S: number;
+    importance: number;
+    emotionalValence: number;
+    associations: string[];
+    consolidated: boolean;
+}
+export interface MemoryQuery {
+    type?: 'episodic' | 'semantic' | 'procedural';
+    keywords?: string[];
+    minImportance?: number;
+    timeRange?: {
+        start: Date;
+        end: Date;
+    };
+    limit?: number;
+}
+export interface Plan {
+    id: string;
+    goal: string;
+    steps: PlanStep[];
+    status: 'pending' | 'in_progress' | 'completed' | 'failed';
+    createdAt: Date;
+    estimatedDuration?: number;
+}
+export interface PlanStep {
+    id: string;
+    description: string;
+    agent: AgentType;
+    dependencies: string[];
+    status: 'pending' | 'in_progress' | 'completed' | 'failed' | 'skipped';
+    result?: any;
+}
+export interface Prediction {
+    action: string;
+    outcomes: PredictedOutcome[];
+    confidence: number;
+    timeHorizon: 'immediate' | 'short' | 'medium' | 'long';
+}
+export interface PredictedOutcome {
+    description: string;
+    probability: number;
+    impact: number;
+    reversible: boolean;
+}
+export interface ExplorationResult {
+    query: string;
+    sources: ExplorationSource[];
+    findings: Finding[];
+    novelty: number;
+    relevance: number;
+}
+export interface ExplorationSource {
+    type: 'arxiv' | 'semantic-scholar' | 'brave' | 'gemini' | 'exa' | 'firecrawl' | 'context7' | 'wolfram';
+    url?: string;
+    title?: string;
+}
+export interface Finding {
+    content: string;
+    source: ExplorationSource;
+    importance: number;
+    isNovel: boolean;
+}
+export interface Critique {
+    target: string;
+    problems: Problem[];
+    suggestions: Suggestion[];
+    overallScore: number;
+    passesReview: boolean;
+}
+export interface Problem {
+    id: string;
+    severity: 'critical' | 'major' | 'minor' | 'nitpick';
+    description: string;
+    location?: string;
+}
+export interface Suggestion {
+    problemId: string;
+    description: string;
+    effort: 'low' | 'medium' | 'high';
+    impact: 'low' | 'medium' | 'high';
+}
+export interface BuildRequest {
+    type: 'code' | 'document' | 'config' | 'test';
+    spec: string;
+    language?: string;
+    framework?: string;
+    constraints?: string[];
+}
+export interface BuildResult {
+    success: boolean;
+    artifacts: Artifact[];
+    errors?: string[];
+    warnings?: string[];
+}
+export interface Artifact {
+    type: 'file' | 'snippet' | 'diagram';
+    name: string;
+    content: string;
+    path?: string;
+}
+export interface BuildArtifact {
+    type: 'file' | 'snippet' | 'diagram';
+    name: string;
+    language?: string;
+    content: string;
+    path?: string;
+    metadata?: Record<string, any>;
+}
+export interface Narrative {
+    title: string;
+    summary: string;
+    events: NarrativeEvent[];
+    themes: string[];
+    mood: FeelingCategory;
+}
+export interface NarrativeEvent {
+    timestamp: Date;
+    description: string;
+    significance: number;
+    agents: AgentId[];
+}

package/dist/src/agents/types.js

@@ -0,0 +1,7 @@
+"use strict";
+/**
+ * Genesis 4.0 - Agent Types
+ *
+ * Core type definitions for the multi-agent system.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });