genesis-ai-cli 7.4.5

package/dist/src/orchestrator.d.ts

@@ -0,0 +1,65 @@
+/**
+ * Genesis - MCP Orchestrator
+ *
+ * Central hub that coordinates all 13 MCP servers for system creation.
+ *
+ * MCP Servers:
+ * - KNOWLEDGE: arxiv, semantic-scholar, context7, wolfram
+ * - RESEARCH:  gemini, brave-search, exa, firecrawl
+ * - CREATION:  openai, github
+ * - VISUAL:    stability-ai
+ * - STORAGE:   memory, filesystem
+ */
+import { MCPServerName, MCPCapability, SystemSpec, ResearchResult, Architecture, GeneratedCode, Visual, PipelineResult, KnowledgeEntity, KnowledgeRelation } from './types.js';
+export declare const MCP_CAPABILITIES: Record<MCPServerName, MCPCapability>;
+export declare class MCPOrchestrator {
+    private verbose;
+    constructor(options?: {
+        verbose?: boolean;
+    });
+    private log;
+    /**
+     * Get all MCPs for a category
+     */
+    getMCPsByCategory(category: MCPCapability['category']): MCPServerName[];
+    /**
+     * Research a topic using all knowledge MCPs in parallel
+     */
+    research(topic: string, spec?: SystemSpec): Promise<ResearchResult>;
+    /**
+     * Generate system architecture using AI models
+     */
+    design(spec: SystemSpec, research: ResearchResult): Promise<Architecture>;
+    /**
+     * Generate code from architecture
+     */
+    generate(spec: SystemSpec, architecture: Architecture): Promise<GeneratedCode>;
+    /**
+     * Create visualizations
+     */
+    visualize(spec: SystemSpec, architecture: Architecture): Promise<Visual[]>;
+    /**
+     * Persist to knowledge graph
+     */
+    persist(spec: SystemSpec, entities: KnowledgeEntity[], relations: KnowledgeRelation[]): Promise<void>;
+    /**
+     * Publish to GitHub
+     */
+    publish(spec: SystemSpec, code: GeneratedCode): Promise<string>;
+    buildResearchPrompt(topic: string, sources: MCPServerName[]): string;
+    buildArchitecturePrompt(spec: SystemSpec, research: ResearchResult): string;
+    buildCodePrompt(spec: SystemSpec, architecture: Architecture, language: 'typescript' | 'python' | 'rust'): string;
+    buildVisualPrompt(spec: SystemSpec, type: Visual['type']): string;
+}
+export declare class GenesisPipeline {
+    private orchestrator;
+    constructor(orchestrator: MCPOrchestrator);
+    /**
+     * Run the full system creation pipeline
+     */
+    run(spec: SystemSpec): Promise<PipelineResult<any>[]>;
+    private getMCPsForStage;
+}
+export declare function createOrchestrator(options?: {
+    verbose?: boolean;
+}): MCPOrchestrator;

package/dist/src/orchestrator.js

@@ -0,0 +1,317 @@
+"use strict";
+/**
+ * Genesis - MCP Orchestrator
+ *
+ * Central hub that coordinates all 13 MCP servers for system creation.
+ *
+ * MCP Servers:
+ * - KNOWLEDGE: arxiv, semantic-scholar, context7, wolfram
+ * - RESEARCH:  gemini, brave-search, exa, firecrawl
+ * - CREATION:  openai, github
+ * - VISUAL:    stability-ai
+ * - STORAGE:   memory, filesystem
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.GenesisPipeline = exports.MCPOrchestrator = exports.MCP_CAPABILITIES = void 0;
+exports.createOrchestrator = createOrchestrator;
+// ============================================================================
+// MCP Capability Map
+// ============================================================================
+exports.MCP_CAPABILITIES = {
+    // Knowledge MCPs
+    'arxiv': {
+        server: 'arxiv',
+        category: 'knowledge',
+        tools: ['search_arxiv', 'parse_paper_content', 'get_recent_ai_papers'],
+        description: 'Academic papers from arXiv',
+    },
+    'semantic-scholar': {
+        server: 'semantic-scholar',
+        category: 'knowledge',
+        tools: ['search_semantic_scholar', 'get_paper', 'get_citations'],
+        description: 'Academic paper search with citations',
+    },
+    'context7': {
+        server: 'context7',
+        category: 'knowledge',
+        tools: ['resolve-library-id', 'query-docs'],
+        description: 'Programming library documentation',
+    },
+    'wolfram': {
+        server: 'wolfram',
+        category: 'knowledge',
+        tools: ['wolfram_query'],
+        description: 'Mathematical and scientific computations',
+    },
+    // Research MCPs
+    'gemini': {
+        server: 'gemini',
+        category: 'research',
+        tools: ['web_search', 'web_search_batch'],
+        description: 'Web search with Gemini AI',
+    },
+    'brave-search': {
+        server: 'brave-search',
+        category: 'research',
+        tools: ['brave_web_search', 'brave_news_search', 'brave_image_search'],
+        description: 'Web, news, and image search',
+    },
+    'exa': {
+        server: 'exa',
+        category: 'research',
+        tools: ['web_search_exa', 'get_code_context_exa'],
+        description: 'Code-focused search',
+    },
+    'firecrawl': {
+        server: 'firecrawl',
+        category: 'research',
+        tools: ['firecrawl_scrape', 'firecrawl_search', 'firecrawl_extract'],
+        description: 'Web scraping and extraction',
+    },
+    // Creation MCPs
+    'openai': {
+        server: 'openai',
+        category: 'creation',
+        tools: ['openai_chat'],
+        description: 'GPT-4o, o1 for code generation',
+    },
+    'github': {
+        server: 'github',
+        category: 'creation',
+        tools: ['create_repository', 'push_files', 'create_pull_request'],
+        description: 'Repository management',
+    },
+    // Visual MCPs
+    'stability-ai': {
+        server: 'stability-ai',
+        category: 'visual',
+        tools: ['generate-image', 'generate-image-sd35'],
+        description: 'Image generation',
+    },
+    // Storage MCPs
+    'memory': {
+        server: 'memory',
+        category: 'storage',
+        tools: ['create_entities', 'create_relations', 'read_graph', 'search_nodes'],
+        description: 'Knowledge graph persistence',
+    },
+    'filesystem': {
+        server: 'filesystem',
+        category: 'storage',
+        tools: ['read_file', 'write_file', 'list_directory'],
+        description: 'Local file operations',
+    },
+};
+// ============================================================================
+// Orchestrator Class
+// ============================================================================
+class MCPOrchestrator {
+    verbose;
+    constructor(options = {}) {
+        this.verbose = options.verbose ?? false;
+    }
+    log(message) {
+        if (this.verbose) {
+            console.log(`[Genesis] ${message}`);
+        }
+    }
+    /**
+     * Get all MCPs for a category
+     */
+    getMCPsByCategory(category) {
+        return Object.entries(exports.MCP_CAPABILITIES)
+            .filter(([_, cap]) => cap.category === category)
+            .map(([server]) => server);
+    }
+    /**
+     * Research a topic using all knowledge MCPs in parallel
+     */
+    async research(topic, spec) {
+        this.log(`Researching: ${topic}`);
+        const result = {
+            papers: [],
+            documentation: [],
+            codeExamples: [],
+            webResults: [],
+            insights: [],
+        };
+        // This would be implemented by the MCP caller
+        // The orchestrator defines WHAT to call, the system executes
+        return result;
+    }
+    /**
+     * Generate system architecture using AI models
+     */
+    async design(spec, research) {
+        this.log(`Designing architecture for: ${spec.name}`);
+        // Architecture generation prompt template
+        const architecturePrompt = this.buildArchitecturePrompt(spec, research);
+        return {
+            components: [],
+            relations: [],
+            invariants: [],
+            operations: [],
+            events: [],
+        };
+    }
+    /**
+     * Generate code from architecture
+     */
+    async generate(spec, architecture) {
+        this.log(`Generating code for: ${spec.name}`);
+        return {
+            files: [],
+            language: 'typescript',
+            tests: [],
+        };
+    }
+    /**
+     * Create visualizations
+     */
+    async visualize(spec, architecture) {
+        this.log(`Creating visuals for: ${spec.name}`);
+        return [];
+    }
+    /**
+     * Persist to knowledge graph
+     */
+    async persist(spec, entities, relations) {
+        this.log(`Persisting ${entities.length} entities to knowledge graph`);
+    }
+    /**
+     * Publish to GitHub
+     */
+    async publish(spec, code) {
+        this.log(`Publishing ${spec.name} to GitHub`);
+        return '';
+    }
+    // ============================================================================
+    // Prompt Builders
+    // ============================================================================
+    buildResearchPrompt(topic, sources) {
+        return `
+Research the topic: "${topic}"
+
+Use the following MCP sources in parallel:
+${sources.map(s => `- ${s}: ${exports.MCP_CAPABILITIES[s].description}`).join('\n')}
+
+Return:
+1. Key papers (arxiv, semantic-scholar)
+2. Relevant documentation (context7)
+3. Code examples (exa, github)
+4. Web insights (gemini, brave-search, firecrawl)
+5. Synthesized insights
+    `.trim();
+    }
+    buildArchitecturePrompt(spec, research) {
+        return `
+Design a system architecture for: "${spec.name}"
+
+Description: ${spec.description}
+Type: ${spec.type}
+Features: ${spec.features.join(', ')}
+${spec.constraints ? `Constraints: ${spec.constraints.join(', ')}` : ''}
+
+Research insights:
+${research.insights.join('\n')}
+
+Generate:
+1. Components with dependencies
+2. Relations between components
+3. Invariants the system must maintain
+4. Operations the system can perform
+5. Events the system emits
+    `.trim();
+    }
+    buildCodePrompt(spec, architecture, language) {
+        return `
+Generate ${language} code for: "${spec.name}"
+
+Architecture:
+- Components: ${architecture.components.map(c => c.name).join(', ')}
+- Operations: ${architecture.operations.map(o => o.id).join(', ')}
+- Invariants: ${architecture.invariants.join('; ')}
+
+Requirements:
+1. Full implementation of all components
+2. Type safety
+3. Error handling
+4. Unit tests for each component
+5. CLI entry point
+    `.trim();
+    }
+    buildVisualPrompt(spec, type) {
+        const prompts = {
+            architecture: `Technical architecture diagram for "${spec.name}". Show components as nodes, relations as edges. Clean, professional style. Dark background, glowing connections.`,
+            concept: `Conceptual visualization of "${spec.name}". Abstract, artistic interpretation of: ${spec.description}. Ethereal, modern digital art style.`,
+            flow: `Data flow diagram for "${spec.name}". Show how data moves through the system. Arrows, pipelines, transformations. Technical illustration style.`,
+            logo: `Minimalist logo for "${spec.name}". Modern, tech-inspired. Simple geometric shapes. Can work on light and dark backgrounds.`,
+        };
+        return prompts[type];
+    }
+}
+exports.MCPOrchestrator = MCPOrchestrator;
+// ============================================================================
+// Pipeline Runner
+// ============================================================================
+class GenesisPipeline {
+    orchestrator;
+    constructor(orchestrator) {
+        this.orchestrator = orchestrator;
+    }
+    /**
+     * Run the full system creation pipeline
+     */
+    async run(spec) {
+        const results = [];
+        const stages = [
+            'research',
+            'design',
+            'generate',
+            'visualize',
+            'persist',
+            'publish',
+        ];
+        for (const stage of stages) {
+            const start = Date.now();
+            try {
+                // Each stage would be executed by the MCP caller
+                results.push({
+                    stage,
+                    success: true,
+                    duration: Date.now() - start,
+                    mcpsUsed: this.getMCPsForStage(stage),
+                });
+            }
+            catch (error) {
+                results.push({
+                    stage,
+                    success: false,
+                    error: String(error),
+                    duration: Date.now() - start,
+                    mcpsUsed: this.getMCPsForStage(stage),
+                });
+                break;
+            }
+        }
+        return results;
+    }
+    getMCPsForStage(stage) {
+        const stageToMCPs = {
+            research: ['arxiv', 'semantic-scholar', 'context7', 'gemini', 'brave-search', 'exa', 'firecrawl'],
+            design: ['openai', 'wolfram'],
+            generate: ['openai', 'context7'],
+            visualize: ['stability-ai'],
+            persist: ['memory', 'filesystem'],
+            publish: ['github'],
+        };
+        return stageToMCPs[stage];
+    }
+}
+exports.GenesisPipeline = GenesisPipeline;
+// ============================================================================
+// Export
+// ============================================================================
+function createOrchestrator(options) {
+    return new MCPOrchestrator(options);
+}

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

@@ -0,0 +1,257 @@
+/**
+ * Genesis 6.0 - State Persistence
+ *
+ * Save and load Genesis state to/from disk.
+ * Supports JSON format with optional compression.
+ *
+ * State includes:
+ * - Memory (episodic, semantic, procedural)
+ * - Conversation history
+ * - Session metadata
+ * - Configuration
+ */
+import { LLMMessage } from '../llm/index.js';
+export interface GenesisState {
+    version: string;
+    created: Date;
+    lastModified: Date;
+    checksum: string;
+    memory: MemoryState;
+    conversation: ConversationState;
+    session: SessionState;
+    config: ConfigState;
+}
+export interface MemoryState {
+    episodic: any[];
+    semantic: any[];
+    procedural: any[];
+    stats: {
+        totalEpisodes: number;
+        totalFacts: number;
+        totalSkills: number;
+        lastConsolidation?: Date;
+    };
+}
+export interface ConversationState {
+    history: LLMMessage[];
+    totalMessages: number;
+    totalTokens: number;
+}
+export interface SessionState {
+    id: string;
+    startTime: Date;
+    interactions: number;
+    lastActivity: Date;
+}
+export interface ConfigState {
+    llm: {
+        provider?: string;
+        model?: string;
+    };
+    persistence: {
+        autoSaveInterval?: number;
+        maxBackups?: number;
+    };
+}
+export interface PersistenceOptions {
+    dataDir?: string;
+    autoSave?: boolean;
+    autoSaveIntervalMs?: number;
+    maxBackups?: number;
+    onSave?: (state: GenesisState) => void;
+    onLoad?: (state: GenesisState) => void;
+    onError?: (error: Error) => void;
+}
+export declare class StateStore {
+    private dataDir;
+    private statePath;
+    private backupDir;
+    private options;
+    private autoSaveTimer;
+    private dirty;
+    private state;
+    constructor(options?: PersistenceOptions);
+    /**
+     * Save state to disk
+     */
+    save(): Promise<void>;
+    /**
+     * Save state synchronously
+     */
+    saveSync(): void;
+    /**
+     * Load state from disk
+     */
+    load(): Promise<GenesisState>;
+    /**
+     * Load state synchronously
+     */
+    loadSync(): GenesisState;
+    /**
+     * Get current state
+     */
+    getState(): GenesisState;
+    /**
+     * Update state (partial update)
+     */
+    update(updates: Partial<GenesisState>): void;
+    /**
+     * Check if state has unsaved changes
+     */
+    isDirty(): boolean;
+    /**
+     * Update memory state
+     */
+    updateMemory(memory: Partial<MemoryState>): void;
+    /**
+     * Add episodic memory
+     */
+    addEpisode(episode: any): void;
+    /**
+     * Add semantic memory
+     */
+    addFact(fact: any): void;
+    /**
+     * Add procedural memory
+     */
+    addSkill(skill: any): void;
+    /**
+     * Update conversation history
+     */
+    updateConversation(messages: LLMMessage[], tokens?: number): void;
+    /**
+     * Add message to conversation
+     */
+    addMessage(message: LLMMessage): void;
+    /**
+     * Clear conversation history
+     */
+    clearConversation(): void;
+    /**
+     * Record an interaction
+     */
+    recordInteraction(): void;
+    /**
+     * Start new session
+     */
+    newSession(): void;
+    /**
+     * Create backup of current state
+     */
+    backup(): Promise<string | null>;
+    /**
+     * Create backup synchronously
+     */
+    backupSync(): string | null;
+    /**
+     * List available backups
+     */
+    listBackups(): string[];
+    /**
+     * Restore from backup
+     */
+    restoreBackup(backupName: string): Promise<void>;
+    /**
+     * Export state to a portable format
+     */
+    export(outputPath: string): Promise<void>;
+    /**
+     * Import state from file
+     */
+    import(inputPath: string, merge?: boolean): Promise<void>;
+    /**
+     * Start auto-save timer
+     */
+    startAutoSave(intervalMs: number): void;
+    /**
+     * Stop auto-save timer
+     */
+    stopAutoSave(): void;
+    /**
+     * Reset state to empty
+     */
+    reset(): void;
+    /**
+     * Delete all persisted data
+     */
+    purge(): Promise<void>;
+    /**
+     * Close and cleanup
+     */
+    close(): void;
+    private createEmptyState;
+    private mergeState;
+    private calculateChecksum;
+    private ensureDirectories;
+    private cleanOldBackups;
+    private cleanOldBackupsSync;
+    /**
+     * Get data directory path
+     */
+    getDataDir(): string;
+    /**
+     * Get stats
+     */
+    stats(): {
+        dataDir: string;
+        stateExists: boolean;
+        stateSize: number;
+        backupCount: number;
+        isDirty: boolean;
+        lastModified: Date;
+    };
+}
+export declare function createStateStore(options?: PersistenceOptions): StateStore;
+export declare function getStateStore(options?: PersistenceOptions): StateStore;
+export declare function resetStateStore(): void;
+export interface SessionInfo {
+    id: string;
+    name?: string;
+    created: Date;
+    lastModified: Date;
+    messageCount: number;
+    tokenCount: number;
+    summary?: string;
+}
+export interface SessionManagerOptions {
+    dataDir?: string;
+    maxSessions?: number;
+}
+export declare class SessionManager {
+    private dataDir;
+    private sessionsDir;
+    private options;
+    constructor(options?: SessionManagerOptions);
+    /**
+     * List all saved sessions
+     */
+    listSessions(): SessionInfo[];
+    /**
+     * Get the most recent session ID
+     */
+    getLastSessionId(): string | null;
+    /**
+     * Save current state as a session
+     */
+    saveSession(state: GenesisState, name?: string): string;
+    /**
+     * Load a session by ID (or 'last' for most recent)
+     */
+    loadSession(sessionIdOrLast: string): GenesisState | null;
+    /**
+     * Fork a session (create a copy with new ID)
+     */
+    forkSession(sessionId: string, newName?: string): string | null;
+    /**
+     * Delete a session
+     */
+    deleteSession(sessionId: string): boolean;
+    /**
+     * Rename a session
+     */
+    renameSession(sessionId: string, newName: string): boolean;
+    private getSessionPath;
+    private ensureDirectory;
+    private cleanupOldSessions;
+}
+export declare function getSessionManager(options?: SessionManagerOptions): SessionManager;