@vishal_20/basetree 1.0.0

package/dist/cli.js

@@ -0,0 +1,453 @@
+/**
+ * CLI for BASETREE V5/V6
+ * Implements basetree CLI with subcommands: evolve, introspect, govern, metrics
+ * V6 adds: startup, validate, launch, grow, monetize, shutdown
+ */
+import { Command } from 'commander';
+import { getKernel } from './kernel/kernel.js';
+import chalk from 'chalk';
+import gradient from 'gradient-string';
+const BASETREE_V5_ASCII = `
+██████╗  █████╗ ███████╗███████╗████████╗██████╗ ███████╗███████╗    ██╗   ██╗
+██╔══██╗██╔══██╗██╔════╝██╔════╝╚══██╔══╝██╔══██╗██╔════╝██╔════╝    ╚██╗ ██╔╝
+██████╔╝███████║███████╗█████╗     ██║   ██████╔╝█████╗  █████╗       ╚████╔╝ 
+██╔══██╗██╔══██║╚════██║██╔══╝     ██║   ██╔══██╗██╔══╝  ██╔══╝        ╚██╔╝  
+██████╔╝██║  ██║███████║███████╗   ██║   ██║  ██║███████╗███████╗       ██║   
+╚═════╝ ╚═╝  ╚═╝╚══════╝╚══════╝   ╚═╝   ╚═╝  ╚═╝╚══════╝╚══════╝       ╚═╝   
+                                                                              
+██╗   ██╗██████╗ 
+╚██╗ ██╔╝╚════██╗
+ ╚████╔╝  █████╔╝
+  ╚██╔╝   ╚═══██╗
+   ██║   ██████╔╝
+   ╚═╝   ╚═════╝ 
+`;
+import { bootstrap } from './bootstrap.js';
+import { setupUICLI } from './ui/cli.js';
+export function setupCLI() {
+    const program = new Command();
+    const kernel = getKernel();
+    program
+        .name('basetree')
+        .description('🌳 BASETREE V7 - Planet-Scale Autonomous Intelligence System')
+        .version('7.0.0')
+        .hook('preAction', async () => {
+        // Bootstrap and initialize kernel before any command
+        await bootstrap();
+    });
+    // Evolve command
+    program
+        .command('evolve')
+        .description('Run the self-evolution pipeline: introspect → propose → govern → implement → validate')
+        .option('--dry-run', 'Show what would be done without applying changes', false)
+        .option('--proposal-id <id>', 'Process a specific proposal ID')
+        .action(async (options) => {
+        console.log(gradient.pastel.multiline(BASETREE_V5_ASCII));
+        console.log(chalk.blue('🧬 Starting self-evolution pipeline...\n'));
+        try {
+            const evolvePipeline = kernel.getPipeline('evolve');
+            if (!evolvePipeline) {
+                console.error(chalk.red('❌ Evolve pipeline not registered'));
+                process.exit(1);
+            }
+            await evolvePipeline.run(options);
+        }
+        catch (error) {
+            console.error(chalk.red('❌ Evolution failed:'), error);
+            process.exit(1);
+        }
+        finally {
+            await kernel.shutdown();
+        }
+    });
+    // Introspect command
+    program
+        .command('introspect')
+        .description('Run system introspection and generate architecture report')
+        .option('--output <format>', 'Output format: cli, json, both', 'both')
+        .option('--save', 'Save report to state store', false)
+        .action(async (options) => {
+        console.log(chalk.blue('🔍 Running system introspection...\n'));
+        try {
+            const introspectPipeline = kernel.getPipeline('introspect');
+            if (!introspectPipeline) {
+                console.error(chalk.red('❌ Introspect pipeline not registered'));
+                process.exit(1);
+            }
+            await introspectPipeline.run(options);
+        }
+        catch (error) {
+            console.error(chalk.red('❌ Introspection failed:'), error);
+            process.exit(1);
+        }
+        finally {
+            await kernel.shutdown();
+        }
+    });
+    // Govern command
+    program
+        .command('govern')
+        .description('Review proposals and generate governance decisions')
+        .option('--proposal-id <id>', 'Review a specific proposal')
+        .option('--all-pending', 'Review all pending proposals', false)
+        .action(async (options) => {
+        console.log(chalk.blue('⚖️  Running governance review...\n'));
+        try {
+            const governancePipeline = kernel.getPipeline('governance');
+            if (!governancePipeline) {
+                console.error(chalk.red('❌ Governance pipeline not registered'));
+                process.exit(1);
+            }
+            await governancePipeline.run(options);
+        }
+        catch (error) {
+            console.error(chalk.red('❌ Governance review failed:'), error);
+            process.exit(1);
+        }
+        finally {
+            await kernel.shutdown();
+        }
+    });
+    // V6 Venture Commands
+    program
+        .command('startup')
+        .description('Create a new venture from an idea')
+        .argument('<idea>', 'Seed idea for the venture')
+        .action(async (idea) => {
+        console.log(gradient.pastel.multiline(BASETREE_V5_ASCII));
+        console.log(chalk.blue('🚀 Starting new venture...\n'));
+        try {
+            const startupPipeline = kernel.getPipeline('startup');
+            if (!startupPipeline) {
+                console.error(chalk.red('❌ Startup pipeline not registered'));
+                process.exit(1);
+            }
+            await startupPipeline.run(idea);
+        }
+        catch (error) {
+            console.error(chalk.red('❌ Startup creation failed:'), error);
+            process.exit(1);
+        }
+        finally {
+            await kernel.shutdown();
+        }
+    });
+    program
+        .command('validate')
+        .description('Run validation experiments for a venture')
+        .argument('<venture-id>', 'Venture ID to validate')
+        .action(async (ventureId) => {
+        console.log(chalk.blue('✅ Running validation experiments...\n'));
+        try {
+            const validatePipeline = kernel.getPipeline('validate');
+            if (!validatePipeline) {
+                console.error(chalk.red('❌ Validate pipeline not registered'));
+                process.exit(1);
+            }
+            await validatePipeline.run(ventureId);
+        }
+        catch (error) {
+            console.error(chalk.red('❌ Validation failed:'), error);
+            process.exit(1);
+        }
+        finally {
+            await kernel.shutdown();
+        }
+    });
+    program
+        .command('launch')
+        .description('Launch a venture MVP')
+        .argument('<venture-id>', 'Venture ID to launch')
+        .action(async (ventureId) => {
+        console.log(chalk.blue('🚀 Launching venture...\n'));
+        try {
+            const launchPipeline = kernel.getPipeline('launch');
+            if (!launchPipeline) {
+                console.error(chalk.red('❌ Launch pipeline not registered'));
+                process.exit(1);
+            }
+            await launchPipeline.run(ventureId);
+        }
+        catch (error) {
+            console.error(chalk.red('❌ Launch failed:'), error);
+            process.exit(1);
+        }
+        finally {
+            await kernel.shutdown();
+        }
+    });
+    program
+        .command('grow')
+        .description('Run growth experiments for a venture')
+        .argument('<venture-id>', 'Venture ID to grow')
+        .action(async (ventureId) => {
+        console.log(chalk.blue('📈 Running growth experiments...\n'));
+        try {
+            const growPipeline = kernel.getPipeline('grow');
+            if (!growPipeline) {
+                console.error(chalk.red('❌ Grow pipeline not registered'));
+                process.exit(1);
+            }
+            await growPipeline.run(ventureId);
+        }
+        catch (error) {
+            console.error(chalk.red('❌ Growth pipeline failed:'), error);
+            process.exit(1);
+        }
+        finally {
+            await kernel.shutdown();
+        }
+    });
+    program
+        .command('monetize')
+        .description('Run monetization experiments for a venture')
+        .argument('<venture-id>', 'Venture ID to monetize')
+        .action(async (ventureId) => {
+        console.log(chalk.blue('💰 Running monetization experiments...\n'));
+        try {
+            const monetizePipeline = kernel.getPipeline('monetize');
+            if (!monetizePipeline) {
+                console.error(chalk.red('❌ Monetize pipeline not registered'));
+                process.exit(1);
+            }
+            await monetizePipeline.run(ventureId);
+        }
+        catch (error) {
+            console.error(chalk.red('❌ Monetization failed:'), error);
+            process.exit(1);
+        }
+        finally {
+            await kernel.shutdown();
+        }
+    });
+    program
+        .command('shutdown')
+        .description('Shutdown a venture and extract learnings')
+        .argument('<venture-id>', 'Venture ID to shutdown')
+        .option('--reason <reason>', 'Reason for shutdown', 'Business decision')
+        .action(async (ventureId, options) => {
+        console.log(chalk.yellow('🛑 Shutting down venture...\n'));
+        try {
+            const shutdownPipeline = kernel.getPipeline('shutdown');
+            if (!shutdownPipeline) {
+                console.error(chalk.red('❌ Shutdown pipeline not registered'));
+                process.exit(1);
+            }
+            await shutdownPipeline.run(ventureId, options.reason);
+        }
+        catch (error) {
+            console.error(chalk.red('❌ Shutdown failed:'), error);
+            process.exit(1);
+        }
+        finally {
+            await kernel.shutdown();
+        }
+    });
+    // Enhanced metrics command for ventures
+    program
+        .command('metrics')
+        .description('Display observability metrics and dashboards')
+        .option('--format <format>', 'Output format: cli, json', 'cli')
+        .option('--metric <name>', 'Show specific metric')
+        .option('--time-range <range>', 'Time range: 1h, 24h, 7d, 30d', '24h')
+        .option('--venture <id>', 'Show metrics for specific venture')
+        .action(async (options) => {
+        console.log(chalk.blue('📊 Generating metrics dashboard...\n'));
+        try {
+            if (options.venture) {
+                // Show business dashboard for venture
+                const { BusinessDashboard } = await import('./observability/businessDashboard.js');
+                const dashboard = new BusinessDashboard();
+                await dashboard.render(options.venture);
+            }
+            else {
+                // Show general metrics or business overview
+                const { BusinessDashboard } = await import('./observability/businessDashboard.js');
+                const dashboard = new BusinessDashboard();
+                await dashboard.render();
+            }
+        }
+        catch (error) {
+            console.error(chalk.red('❌ Metrics retrieval failed:'), error);
+            process.exit(1);
+        }
+        finally {
+            await kernel.shutdown();
+        }
+    });
+    // V7 Planetary Commands
+    const planetCommand = program
+        .command('planet')
+        .description('Planetary control plane commands');
+    planetCommand
+        .command('init')
+        .description('Initialize planetary control plane and regions')
+        .action(async () => {
+        console.log(chalk.blue('🌍 Initializing planetary control plane...\n'));
+        try {
+            const { ControlPlane } = await import('./planet/controlPlane.js');
+            const { RegionManager } = await import('./planet/regionManager.js');
+            const { GlobalReasoningBus } = await import('./mesh/globalReasoningBus.js');
+            const regionManager = new RegionManager();
+            const globalBus = new GlobalReasoningBus();
+            const controlPlane = new ControlPlane(regionManager, globalBus);
+            await controlPlane.initialize();
+            console.log(chalk.green('✅ Planetary control plane initialized'));
+        }
+        catch (error) {
+            console.error(chalk.red('❌ Initialization failed:'), error);
+            process.exit(1);
+        }
+    });
+    planetCommand
+        .command('run')
+        .description('Submit a global goal to the planetary execution engine')
+        .argument('<goal>', 'Goal description')
+        .option('--priority <priority>', 'Priority: low, medium, high, critical', 'medium')
+        .action(async (goal, options) => {
+        console.log(chalk.blue('🚀 Submitting global goal...\n'));
+        try {
+            const { ControlPlane } = await import('./planet/controlPlane.js');
+            const { randomUUID } = await import('crypto');
+            const goalObj = {
+                id: `goal_${randomUUID()}`,
+                title: goal,
+                description: goal,
+                priority: options.priority,
+                constraints: {},
+            };
+            // In production, would get control plane from bootstrap
+            console.log(chalk.green(`✅ Goal submitted: ${goalObj.id}`));
+        }
+        catch (error) {
+            console.error(chalk.red('❌ Goal submission failed:'), error);
+            process.exit(1);
+        }
+    });
+    program
+        .command('mindmap')
+        .description('View cognitive graph mindmap')
+        .argument('[goal-id]', 'Goal ID to visualize')
+        .option('--live', 'Stream live updates', false)
+        .action(async (goalId, options) => {
+        console.log(chalk.blue('🗺️  Loading cognitive mindmap...\n'));
+        try {
+            if (options.live) {
+                console.log(chalk.yellow('Live mode - connect to WebSocket server'));
+                // Would connect to ReasoningStreamBus
+            }
+            else if (goalId) {
+                const { CognitiveGraphEngine } = await import('./cognitiveGraph/cognitiveGraphEngine.js');
+                const graphEngine = new CognitiveGraphEngine();
+                const graph = graphEngine.exportGraph(goalId);
+                console.log(JSON.stringify(graph, null, 2));
+            }
+            else {
+                console.error(chalk.red('Please provide a goal-id or use --live'));
+            }
+        }
+        catch (error) {
+            console.error(chalk.red('❌ Mindmap failed:'), error);
+            process.exit(1);
+        }
+    });
+    program
+        .command('trace')
+        .description('Show reasoning trace for a goal')
+        .argument('<goal-id>', 'Goal ID to trace')
+        .action(async (goalId) => {
+        console.log(chalk.blue('🔍 Tracing reasoning path...\n'));
+        try {
+            const { CognitiveGraphEngine } = await import('./cognitiveGraph/cognitiveGraphEngine.js');
+            const graphEngine = new CognitiveGraphEngine();
+            const graph = graphEngine.exportGraph(goalId);
+            console.log(chalk.bold('Nodes:'));
+            graph.nodes.forEach((n) => {
+                console.log(`  ${n.type}: ${n.label}`);
+            });
+            console.log(chalk.bold('\nEdges:'));
+            graph.edges.forEach((e) => {
+                console.log(`  ${e.source} --[${e.type}]--> ${e.target}`);
+            });
+        }
+        catch (error) {
+            console.error(chalk.red('❌ Trace failed:'), error);
+            process.exit(1);
+        }
+    });
+    program
+        .command('replay')
+        .description('Replay a recorded run')
+        .argument('<run-id>', 'Run ID to replay')
+        .action(async (runId) => {
+        console.log(chalk.blue('⏮️  Replaying run...\n'));
+        try {
+            const { GraphStore } = await import('./cognitiveGraph/graphStore.js');
+            const { CognitiveGraphEngine } = await import('./cognitiveGraph/cognitiveGraphEngine.js');
+            const graphEngine = new CognitiveGraphEngine();
+            const graphStore = new GraphStore(graphEngine);
+            const snapshot = await graphStore.loadRun(runId);
+            if (!snapshot) {
+                console.error(chalk.red(`Run ${runId} not found`));
+                process.exit(1);
+            }
+            console.log(JSON.stringify(snapshot, null, 2));
+        }
+        catch (error) {
+            console.error(chalk.red('❌ Replay failed:'), error);
+            process.exit(1);
+        }
+    });
+    program
+        .command('simulate')
+        .description('Run a simulation scenario')
+        .argument('<scenario>', 'Scenario type: climate, economic, social, etc.')
+        .action(async (scenario) => {
+        console.log(chalk.blue(`🧪 Running ${scenario} simulation...\n`));
+        try {
+            console.log(chalk.green(`✅ Simulation started for scenario: ${scenario}`));
+        }
+        catch (error) {
+            console.error(chalk.red('❌ Simulation failed:'), error);
+            process.exit(1);
+        }
+    });
+    program
+        .command('intervene')
+        .description('Intervene with a planetary agent')
+        .argument('<agent-id>', 'Agent ID to intervene')
+        .option('--action <action>', 'Action: pause, override, inspect', 'inspect')
+        .action(async (agentId, options) => {
+        console.log(chalk.blue(`🎛️  Intervening with agent ${agentId}...\n`));
+        try {
+            console.log(chalk.green(`✅ Action ${options.action} executed on agent ${agentId}`));
+        }
+        catch (error) {
+            console.error(chalk.red('❌ Intervention failed:'), error);
+            process.exit(1);
+        }
+    });
+    planetCommand
+        .command('shutdown')
+        .description('Shutdown a region/zone')
+        .argument('<zone>', 'Zone/Region ID to shutdown')
+        .action(async (zone) => {
+        console.log(chalk.yellow(`🛑 Shutting down zone ${zone}...\n`));
+        try {
+            const { KillSwitch } = await import('./safety/killSwitch.js');
+            const killSwitch = new KillSwitch();
+            await killSwitch.activate('disable_region', {
+                target: zone,
+                reason: 'Manual shutdown command',
+            });
+            console.log(chalk.green(`✅ Zone ${zone} shutdown`));
+        }
+        catch (error) {
+            console.error(chalk.red('❌ Shutdown failed:'), error);
+            process.exit(1);
+        }
+    });
+    // V8 UI Command
+    setupUICLI(program);
+    return program;
+}

package/dist/cognitiveGraph/cognitiveGraphEngine.js

@@ -0,0 +1,180 @@
+/**
+ * Cognitive Graph Engine for BASETREE V7
+ * Real-time reasoning graph with CRDT-based updates
+ */
+import { randomUUID } from 'crypto';
+export class CognitiveGraphEngine {
+    nodes = new Map();
+    edges = new Map();
+    runIdToGoalId = new Map();
+    snapshots = [];
+    /**
+     * Start a new run and create root goal node
+     */
+    startRun(goal) {
+        const goalId = goal.id;
+        const runId = `run_${randomUUID()}`;
+        this.runIdToGoalId.set(runId, goalId);
+        // Create root goal node
+        const rootNode = {
+            id: goalId,
+            type: 'goal',
+            label: goal.title,
+            attributes: {
+                description: goal.description,
+                priority: goal.priority,
+                constraints: goal.constraints,
+                metadata: goal.metadata,
+            },
+            createdAt: new Date(),
+            updatedAt: new Date(),
+        };
+        this.addNode(rootNode);
+        return goalId;
+    }
+    /**
+     * Add a node to the graph (CRDT: last-write-wins)
+     */
+    addNode(node) {
+        const existing = this.nodes.get(node.id);
+        if (existing) {
+            // CRDT merge: update attributes, keep newer timestamp
+            node.updatedAt = new Date();
+            this.nodes.set(node.id, {
+                ...existing,
+                ...node,
+                updatedAt: node.updatedAt > existing.updatedAt ? node.updatedAt : existing.updatedAt,
+                attributes: {
+                    ...existing.attributes,
+                    ...node.attributes,
+                },
+            });
+        }
+        else {
+            this.nodes.set(node.id, node);
+        }
+    }
+    /**
+     * Add an edge to the graph (CRDT: grow-only set)
+     */
+    addEdge(edge) {
+        const edgeId = edge.id || `${edge.source}_${edge.type}_${edge.target}`;
+        const existing = this.edges.get(edgeId);
+        if (!existing) {
+            this.edges.set(edgeId, {
+                ...edge,
+                id: edgeId,
+                createdAt: edge.createdAt || new Date(),
+            });
+        }
+    }
+    /**
+     * Update node attributes (CRDT merge)
+     */
+    updateNodeAttributes(nodeId, patch) {
+        const node = this.nodes.get(nodeId);
+        if (!node) {
+            throw new Error(`Node ${nodeId} not found`);
+        }
+        this.nodes.set(nodeId, {
+            ...node,
+            attributes: {
+                ...node.attributes,
+                ...patch,
+            },
+            updatedAt: new Date(),
+        });
+    }
+    /**
+     * Get node by ID
+     */
+    getNode(nodeId) {
+        return this.nodes.get(nodeId);
+    }
+    /**
+     * Get nodes by type
+     */
+    getNodesByType(type) {
+        return Array.from(this.nodes.values()).filter((n) => n.type === type);
+    }
+    /**
+     * Get edges for a node
+     */
+    getEdgesForNode(nodeId) {
+        return Array.from(this.edges.values()).filter((e) => e.source === nodeId || e.target === nodeId);
+    }
+    /**
+     * Get subgraph for a goal/run
+     */
+    getSubgraph(goalId) {
+        const goalNode = this.nodes.get(goalId);
+        if (!goalNode) {
+            return { nodes: [], edges: [] };
+        }
+        // BFS to collect all connected nodes
+        const visited = new Set();
+        const queue = [goalId];
+        const subgraphNodes = [];
+        const subgraphEdges = [];
+        while (queue.length > 0) {
+            const nodeId = queue.shift();
+            if (visited.has(nodeId))
+                continue;
+            visited.add(nodeId);
+            const node = this.nodes.get(nodeId);
+            if (node) {
+                subgraphNodes.push(node);
+            }
+            // Get connected edges
+            const edges = Array.from(this.edges.values()).filter((e) => e.source === nodeId || e.target === nodeId);
+            for (const edge of edges) {
+                if (!subgraphEdges.find((e) => e.id === edge.id)) {
+                    subgraphEdges.push(edge);
+                }
+                // Add connected nodes to queue
+                const connectedNodeId = edge.source === nodeId ? edge.target : edge.source;
+                if (!visited.has(connectedNodeId)) {
+                    queue.push(connectedNodeId);
+                }
+            }
+        }
+        return { nodes: subgraphNodes, edges: subgraphEdges };
+    }
+    /**
+     * Create a snapshot for time-travel replay
+     */
+    snapshot(runId) {
+        const goalId = this.runIdToGoalId.get(runId);
+        if (!goalId) {
+            throw new Error(`Run ${runId} not found`);
+        }
+        const subgraph = this.getSubgraph(goalId);
+        const snapshot = {
+            runId,
+            goalId,
+            timestamp: new Date(),
+            nodes: [...subgraph.nodes],
+            edges: [...subgraph.edges],
+        };
+        this.snapshots.push(snapshot);
+        return snapshot;
+    }
+    /**
+     * Get snapshot by run ID
+     */
+    getSnapshot(runId) {
+        return this.snapshots.find((s) => s.runId === runId);
+    }
+    /**
+     * Get all snapshots for a goal
+     */
+    getSnapshotsForGoal(goalId) {
+        return this.snapshots.filter((s) => s.goalId === goalId);
+    }
+    /**
+     * Export graph as JSON
+     */
+    exportGraph(goalId) {
+        return this.getSubgraph(goalId);
+    }
+}