genesis-ai-cli 7.4.5

package/dist/src/pipeline/index.js

@@ -0,0 +1,11 @@
+"use strict";
+/**
+ * Genesis 6.0 - Pipeline Module
+ *
+ * Exports pipeline execution functionality.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createPipelineExecutor = exports.PipelineExecutor = void 0;
+var executor_js_1 = require("./executor.js");
+Object.defineProperty(exports, "PipelineExecutor", { enumerable: true, get: function () { return executor_js_1.PipelineExecutor; } });
+Object.defineProperty(exports, "createPipelineExecutor", { enumerable: true, get: function () { return executor_js_1.createPipelineExecutor; } });

package/dist/src/self-production.d.ts

@@ -0,0 +1,67 @@
+/**
+ * Genesis - Self-Production Module
+ *
+ * Enables Genesis to create improved versions of itself.
+ * This is the core of the autopoietic capability.
+ *
+ * Self-Production Rules:
+ * 1. Triggered upon detection of critical performance improvements
+ * 2. Uses existing pipeline to design new versions
+ * 3. All new versions validated against invariants
+ * 4. System upgrade events generated once verified
+ */
+import { SystemSpec } from './types.js';
+export interface SelfProductionSpec {
+    currentVersion: string;
+    targetVersion: string;
+    improvements: Improvement[];
+    preserveInvariants: string[];
+}
+export interface Improvement {
+    id: string;
+    type: 'performance' | 'capability' | 'reliability' | 'efficiency';
+    description: string;
+    priority: 'critical' | 'high' | 'medium' | 'low';
+    estimatedImpact: number;
+}
+export interface ProductionResult {
+    success: boolean;
+    newVersion?: string;
+    changes: string[];
+    validationPassed: boolean;
+    rollbackAvailable: boolean;
+}
+export declare class SelfProductionEngine {
+    private currentVersion;
+    private productionHistory;
+    private readonly coreInvariants;
+    constructor(version?: string);
+    /**
+     * Analyze system metrics to identify potential improvements
+     */
+    analyzeForImprovements(metrics: SystemMetrics): Improvement[];
+    /**
+     * Create a new version of Genesis with specified improvements
+     */
+    produce(spec: SelfProductionSpec): Promise<ProductionResult>;
+    private validateAgainstInvariants;
+    private generateImprovement;
+    private validateNewVersion;
+    /**
+     * Generate a SystemSpec for creating an improved Genesis
+     */
+    generateSelfImprovementSpec(): SystemSpec;
+    private incrementVersion;
+    getVersion(): string;
+    getHistory(): ProductionResult[];
+    getInvariants(): string[];
+}
+interface SystemMetrics {
+    avgPipelineDuration: number;
+    errorRate: number;
+    systemsCreated: number;
+    cacheHitRate: number;
+    hasAdvancedTemplates: boolean;
+}
+export declare function createSelfProductionEngine(version?: string): SelfProductionEngine;
+export {};

package/dist/src/self-production.js

@@ -0,0 +1,205 @@
+"use strict";
+/**
+ * Genesis - Self-Production Module
+ *
+ * Enables Genesis to create improved versions of itself.
+ * This is the core of the autopoietic capability.
+ *
+ * Self-Production Rules:
+ * 1. Triggered upon detection of critical performance improvements
+ * 2. Uses existing pipeline to design new versions
+ * 3. All new versions validated against invariants
+ * 4. System upgrade events generated once verified
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SelfProductionEngine = void 0;
+exports.createSelfProductionEngine = createSelfProductionEngine;
+// ============================================================================
+// Self-Production Engine
+// ============================================================================
+class SelfProductionEngine {
+    currentVersion;
+    productionHistory = [];
+    // Core invariants that must be preserved during self-production
+    coreInvariants = [
+        'Pipeline stages execute sequentially',
+        'MCP orchestration maintains connections',
+        'State machine transitions are valid',
+        'Generated code passes validation',
+        'Self-production preserves all invariants',
+    ];
+    constructor(version = '1.0.0') {
+        this.currentVersion = version;
+    }
+    // ============================================================================
+    // Analysis
+    // ============================================================================
+    /**
+     * Analyze system metrics to identify potential improvements
+     */
+    analyzeForImprovements(metrics) {
+        const improvements = [];
+        // Performance improvements
+        if (metrics.avgPipelineDuration > 30000) {
+            improvements.push({
+                id: 'perf-001',
+                type: 'performance',
+                description: 'Parallelize independent MCP calls',
+                priority: 'high',
+                estimatedImpact: 0.4,
+            });
+        }
+        // Reliability improvements
+        if (metrics.errorRate > 0.05) {
+            improvements.push({
+                id: 'rel-001',
+                type: 'reliability',
+                description: 'Add retry logic with exponential backoff',
+                priority: 'critical',
+                estimatedImpact: 0.3,
+            });
+        }
+        // Capability improvements
+        if (metrics.systemsCreated > 10 && !metrics.hasAdvancedTemplates) {
+            improvements.push({
+                id: 'cap-001',
+                type: 'capability',
+                description: 'Generate advanced system templates from history',
+                priority: 'medium',
+                estimatedImpact: 0.2,
+            });
+        }
+        // Efficiency improvements
+        if (metrics.cacheHitRate < 0.5) {
+            improvements.push({
+                id: 'eff-001',
+                type: 'efficiency',
+                description: 'Implement semantic caching for research results',
+                priority: 'medium',
+                estimatedImpact: 0.25,
+            });
+        }
+        return improvements;
+    }
+    // ============================================================================
+    // Production
+    // ============================================================================
+    /**
+     * Create a new version of Genesis with specified improvements
+     */
+    async produce(spec) {
+        console.log(`[SelfProduction] Starting production: ${spec.currentVersion} → ${spec.targetVersion}`);
+        // Step 1: Validate improvements don't violate invariants
+        const invariantCheck = this.validateAgainstInvariants(spec.improvements);
+        if (!invariantCheck.valid) {
+            return {
+                success: false,
+                changes: [],
+                validationPassed: false,
+                rollbackAvailable: false,
+            };
+        }
+        // Step 2: Generate improvement code
+        const changes = [];
+        for (const improvement of spec.improvements) {
+            const change = await this.generateImprovement(improvement);
+            changes.push(change);
+        }
+        // Step 3: Validate new version
+        const validationPassed = await this.validateNewVersion(changes);
+        if (validationPassed) {
+            this.currentVersion = spec.targetVersion;
+            const result = {
+                success: true,
+                newVersion: spec.targetVersion,
+                changes,
+                validationPassed: true,
+                rollbackAvailable: true,
+            };
+            this.productionHistory.push(result);
+            return result;
+        }
+        return {
+            success: false,
+            changes,
+            validationPassed: false,
+            rollbackAvailable: true,
+        };
+    }
+    validateAgainstInvariants(improvements) {
+        const violations = [];
+        // Check each improvement doesn't break invariants
+        for (const improvement of improvements) {
+            // In a real system, this would analyze the code changes
+            // For now, we assume all improvements preserve invariants
+        }
+        return { valid: violations.length === 0, violations };
+    }
+    async generateImprovement(improvement) {
+        // This would use OpenAI MCP to generate actual code improvements
+        return `// Improvement: ${improvement.id}\n// ${improvement.description}`;
+    }
+    async validateNewVersion(changes) {
+        // Run tests, check invariants, verify functionality
+        // In a real system, this would be comprehensive
+        return true;
+    }
+    // ============================================================================
+    // Templates
+    // ============================================================================
+    /**
+     * Generate a SystemSpec for creating an improved Genesis
+     */
+    generateSelfImprovementSpec() {
+        const nextVersion = this.incrementVersion(this.currentVersion);
+        return {
+            name: `genesis-${nextVersion}`,
+            description: 'Self-improved version of Genesis System Creator',
+            type: 'autopoietic',
+            features: [
+                'state-machine',
+                'events',
+                'mcp-orchestration',
+                'self-production',
+                'invariant-checking',
+            ],
+            inspirations: [
+                'autopoiesis theory',
+                'maturana-varela',
+                'free energy principle',
+            ],
+        };
+    }
+    incrementVersion(version) {
+        const parts = version.split('.').map(Number);
+        parts[2]++; // Increment patch
+        if (parts[2] >= 10) {
+            parts[2] = 0;
+            parts[1]++;
+        }
+        if (parts[1] >= 10) {
+            parts[1] = 0;
+            parts[0]++;
+        }
+        return parts.join('.');
+    }
+    // ============================================================================
+    // Status
+    // ============================================================================
+    getVersion() {
+        return this.currentVersion;
+    }
+    getHistory() {
+        return [...this.productionHistory];
+    }
+    getInvariants() {
+        return [...this.coreInvariants];
+    }
+}
+exports.SelfProductionEngine = SelfProductionEngine;
+// ============================================================================
+// Export
+// ============================================================================
+function createSelfProductionEngine(version) {
+    return new SelfProductionEngine(version);
+}

package/dist/src/subagents/executor.d.ts

@@ -0,0 +1,58 @@
+/**
+ * Genesis v7.4 - Subagent Executor
+ *
+ * Executes subagents in isolated contexts with tool restrictions.
+ */
+import { TaskRequest, TaskResult, BackgroundTask, SubagentEventHandler, SubagentConfig } from './types.js';
+import { ToolDispatcher } from '../cli/dispatcher.js';
+export declare class SubagentExecutor {
+    private config;
+    private runningTasks;
+    private eventHandlers;
+    private dispatcher;
+    constructor(config?: Partial<SubagentConfig>);
+    /**
+     * Set the tool dispatcher for subagents
+     */
+    setDispatcher(dispatcher: ToolDispatcher): void;
+    /**
+     * Execute a task synchronously
+     */
+    execute(request: TaskRequest): Promise<TaskResult>;
+    /**
+     * Execute a task in background
+     */
+    executeBackground(request: TaskRequest): Promise<string>;
+    /**
+     * Get background task status
+     */
+    getTask(taskId: string): BackgroundTask | undefined;
+    /**
+     * Get all tasks
+     */
+    getTasks(): BackgroundTask[];
+    /**
+     * Get running tasks
+     */
+    getRunningTasks(): BackgroundTask[];
+    /**
+     * Wait for a background task to complete
+     */
+    waitForTask(taskId: string, timeout?: number): Promise<TaskResult>;
+    /**
+     * Cancel a background task
+     */
+    cancelTask(taskId: string): boolean;
+    /**
+     * Subscribe to events
+     */
+    on(handler: SubagentEventHandler): () => void;
+    private runBackgroundTask;
+    private createSubagentLLM;
+    private buildSystemPrompt;
+    private runSubagent;
+    private timeoutPromise;
+    private emit;
+}
+export declare function getSubagentExecutor(): SubagentExecutor;
+export declare function resetSubagentExecutor(): void;

package/dist/src/subagents/executor.js

@@ -0,0 +1,283 @@
+"use strict";
+/**
+ * Genesis v7.4 - Subagent Executor
+ *
+ * Executes subagents in isolated contexts with tool restrictions.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SubagentExecutor = void 0;
+exports.getSubagentExecutor = getSubagentExecutor;
+exports.resetSubagentExecutor = resetSubagentExecutor;
+const crypto_1 = require("crypto");
+const types_js_1 = require("./types.js");
+const registry_js_1 = require("./registry.js");
+const index_js_1 = require("../llm/index.js");
+// ============================================================================
+// Subagent Executor
+// ============================================================================
+class SubagentExecutor {
+    config;
+    runningTasks = new Map();
+    eventHandlers = new Set();
+    dispatcher = null;
+    constructor(config = {}) {
+        this.config = { ...types_js_1.DEFAULT_SUBAGENT_CONFIG, ...config };
+    }
+    /**
+     * Set the tool dispatcher for subagents
+     */
+    setDispatcher(dispatcher) {
+        this.dispatcher = dispatcher;
+    }
+    /**
+     * Execute a task synchronously
+     */
+    async execute(request) {
+        const taskId = (0, crypto_1.randomUUID)().slice(0, 8);
+        const startTime = Date.now();
+        // Get subagent definition
+        const subagent = (0, registry_js_1.getSubagent)(request.subagentType);
+        if (!subagent) {
+            return {
+                taskId,
+                subagentType: request.subagentType,
+                success: false,
+                error: `Unknown subagent type: ${request.subagentType}. Available: ${Object.keys(registry_js_1.BUILTIN_SUBAGENTS).join(', ')}`,
+                duration: Date.now() - startTime,
+            };
+        }
+        this.emit({
+            type: 'task_start',
+            taskId,
+            timestamp: new Date(),
+            data: { description: request.description, subagentType: request.subagentType },
+        });
+        try {
+            // Create isolated LLM bridge for subagent
+            const llm = this.createSubagentLLM(request.model || subagent.model);
+            // Build system prompt with tool restrictions
+            const systemPrompt = this.buildSystemPrompt(subagent.systemPrompt, subagent.tools);
+            // Execute with timeout
+            const timeout = subagent.timeout || this.config.defaultTimeout;
+            const result = await Promise.race([
+                this.runSubagent(llm, systemPrompt, request.prompt, subagent.tools, taskId),
+                this.timeoutPromise(timeout, taskId),
+            ]);
+            this.emit({
+                type: 'task_complete',
+                taskId,
+                timestamp: new Date(),
+                data: { success: true },
+            });
+            return {
+                taskId,
+                subagentType: request.subagentType,
+                success: true,
+                result,
+                duration: Date.now() - startTime,
+            };
+        }
+        catch (error) {
+            const errorMessage = error instanceof Error ? error.message : String(error);
+            this.emit({
+                type: 'task_error',
+                taskId,
+                timestamp: new Date(),
+                data: { error: errorMessage },
+            });
+            return {
+                taskId,
+                subagentType: request.subagentType,
+                success: false,
+                error: errorMessage,
+                duration: Date.now() - startTime,
+            };
+        }
+    }
+    /**
+     * Execute a task in background
+     */
+    async executeBackground(request) {
+        const taskId = (0, crypto_1.randomUUID)().slice(0, 8);
+        // Check concurrent limit
+        const runningCount = Array.from(this.runningTasks.values())
+            .filter(t => t.status === 'running').length;
+        if (runningCount >= this.config.maxConcurrent) {
+            throw new Error(`Max concurrent tasks (${this.config.maxConcurrent}) reached`);
+        }
+        // Create background task entry
+        const task = {
+            taskId,
+            description: request.description,
+            subagentType: request.subagentType,
+            status: 'pending',
+            startTime: Date.now(),
+            output: [],
+        };
+        this.runningTasks.set(taskId, task);
+        // Start execution in background
+        this.runBackgroundTask(taskId, request).catch(error => {
+            const t = this.runningTasks.get(taskId);
+            if (t) {
+                t.status = 'failed';
+                t.endTime = Date.now();
+                t.result = {
+                    taskId,
+                    subagentType: request.subagentType,
+                    success: false,
+                    error: error instanceof Error ? error.message : String(error),
+                    duration: Date.now() - t.startTime,
+                };
+            }
+        });
+        return taskId;
+    }
+    /**
+     * Get background task status
+     */
+    getTask(taskId) {
+        return this.runningTasks.get(taskId);
+    }
+    /**
+     * Get all tasks
+     */
+    getTasks() {
+        return Array.from(this.runningTasks.values());
+    }
+    /**
+     * Get running tasks
+     */
+    getRunningTasks() {
+        return this.getTasks().filter(t => t.status === 'running');
+    }
+    /**
+     * Wait for a background task to complete
+     */
+    async waitForTask(taskId, timeout) {
+        const task = this.runningTasks.get(taskId);
+        if (!task) {
+            throw new Error(`Task not found: ${taskId}`);
+        }
+        const maxWait = timeout || this.config.defaultTimeout;
+        const startWait = Date.now();
+        while (task.status === 'pending' || task.status === 'running') {
+            if (Date.now() - startWait > maxWait) {
+                throw new Error(`Timeout waiting for task ${taskId}`);
+            }
+            await new Promise(resolve => setTimeout(resolve, 100));
+        }
+        if (!task.result) {
+            throw new Error(`Task ${taskId} completed without result`);
+        }
+        return task.result;
+    }
+    /**
+     * Cancel a background task
+     */
+    cancelTask(taskId) {
+        const task = this.runningTasks.get(taskId);
+        if (!task || task.status !== 'running') {
+            return false;
+        }
+        task.status = 'cancelled';
+        task.endTime = Date.now();
+        this.emit({
+            type: 'task_cancelled',
+            taskId,
+            timestamp: new Date(),
+        });
+        return true;
+    }
+    /**
+     * Subscribe to events
+     */
+    on(handler) {
+        this.eventHandlers.add(handler);
+        return () => this.eventHandlers.delete(handler);
+    }
+    // ============================================================================
+    // Private Methods
+    // ============================================================================
+    async runBackgroundTask(taskId, request) {
+        const task = this.runningTasks.get(taskId);
+        if (!task)
+            return;
+        task.status = 'running';
+        const result = await this.execute(request);
+        task.status = result.success ? 'completed' : 'failed';
+        task.endTime = Date.now();
+        task.result = result;
+    }
+    createSubagentLLM(modelTier) {
+        // Map tier to actual model
+        const modelMap = {
+            fast: 'qwen2.5-coder', // Local, fast
+            balanced: 'mistral', // Local, balanced
+            powerful: 'gpt-4o', // Cloud, powerful
+        };
+        const model = modelMap[modelTier || 'balanced'];
+        // Use Ollama for fast/balanced, OpenAI for powerful
+        if (modelTier === 'powerful' && process.env.OPENAI_API_KEY) {
+            return (0, index_js_1.createLLMBridge)({ provider: 'openai', model });
+        }
+        return (0, index_js_1.createLLMBridge)({ provider: 'ollama', model });
+    }
+    buildSystemPrompt(basePrompt, allowedTools) {
+        const toolsSection = allowedTools.includes('*')
+            ? 'You have access to ALL tools.'
+            : `You have access to these tools ONLY: ${allowedTools.join(', ')}`;
+        return `${basePrompt}
+
+## Tool Access
+${toolsSection}
+
+## Response Format
+After completing your task, provide a clear summary of:
+1. What you found/did
+2. Key results with file:line references where applicable
+3. Any issues or warnings`;
+    }
+    async runSubagent(llm, systemPrompt, userPrompt, _allowedTools, taskId) {
+        // Simple single-turn execution for now
+        // TODO: Multi-turn with tool execution loop
+        const response = await llm.chat(userPrompt, systemPrompt);
+        this.emit({
+            type: 'task_progress',
+            taskId,
+            timestamp: new Date(),
+            data: { tokensUsed: response.usage },
+        });
+        return response.content;
+    }
+    timeoutPromise(ms, taskId) {
+        return new Promise((_, reject) => {
+            setTimeout(() => {
+                reject(new Error(`Task ${taskId} timed out after ${ms}ms`));
+            }, ms);
+        });
+    }
+    emit(event) {
+        for (const handler of this.eventHandlers) {
+            try {
+                handler(event);
+            }
+            catch {
+                // Ignore handler errors
+            }
+        }
+    }
+}
+exports.SubagentExecutor = SubagentExecutor;
+// ============================================================================
+// Singleton
+// ============================================================================
+let executorInstance = null;
+function getSubagentExecutor() {
+    if (!executorInstance) {
+        executorInstance = new SubagentExecutor();
+    }
+    return executorInstance;
+}
+function resetSubagentExecutor() {
+    executorInstance = null;
+}

package/dist/src/subagents/index.d.ts

@@ -0,0 +1,37 @@
+/**
+ * Genesis v7.4 - Subagent System
+ *
+ * Parallel subprocess execution for complex tasks.
+ * Equivalent to Claude Code's Task tool.
+ *
+ * Usage:
+ * ```typescript
+ * import { getSubagentExecutor, TaskRequest } from './subagents/index.js';
+ *
+ * const executor = getSubagentExecutor();
+ *
+ * // Synchronous execution
+ * const result = await executor.execute({
+ *   description: 'Find auth handlers',
+ *   prompt: 'Search for authentication handling code',
+ *   subagentType: 'explore',
+ * });
+ *
+ * // Background execution
+ * const taskId = await executor.executeBackground({
+ *   description: 'Research OAuth patterns',
+ *   prompt: 'Find best practices for OAuth2 implementation',
+ *   subagentType: 'research',
+ *   runInBackground: true,
+ * });
+ *
+ * // Check status
+ * const task = executor.getTask(taskId);
+ *
+ * // Wait for completion
+ * const result = await executor.waitForTask(taskId);
+ * ```
+ */
+export * from './types.js';
+export * from './registry.js';
+export * from './executor.js';