@vishal_20/basetree 1.0.0

package/dist/discovery/knowledgeSynthesizer.js

@@ -0,0 +1,83 @@
+/**
+ * Knowledge Synthesizer for BASETREE V7
+ * Synthesizes results into coherent knowledge summaries and drafts papers
+ */
+import { GeminiProvider } from '../core/ai/GeminiProvider.js';
+export class KnowledgeSynthesizer {
+    civilizationMemory;
+    ai;
+    constructor(civilizationMemory) {
+        this.civilizationMemory = civilizationMemory;
+        this.ai = new GeminiProvider();
+    }
+    /**
+     * Synthesize knowledge from multiple sources
+     */
+    async synthesize(title, query, relatedMemoryIds) {
+        // Retrieve relevant memories
+        const memories = relatedMemoryIds
+            ? await Promise.all(relatedMemoryIds.map(async (id) => {
+                const results = await this.civilizationMemory.search(id, undefined, 1);
+                return results[0];
+            }))
+            : await this.civilizationMemory.search(query, undefined, 10);
+        const context = memories
+            .map((m) => `## ${m.title}\n${m.content}`)
+            .join('\n\n');
+        // Use AI to synthesize
+        const prompt = `Synthesize the following knowledge into a coherent summary:
+
+${context}
+
+Provide:
+1. A comprehensive summary
+2. Key findings (bullet points)
+3. Conclusions
+4. A draft scientific paper abstract
+
+Format as JSON with fields: summary, findings (array), conclusions (array), paperDraft.`;
+        try {
+            const response = await this.ai.generateResponse(prompt);
+            const text = typeof response === 'string' ? response : JSON.stringify(response);
+            const synthesis = this.parseSynthesis(text, title);
+            // Record synthesis in civilization memory
+            await this.civilizationMemory.recordScientificDiscovery(synthesis.title, synthesis.summary);
+            return synthesis;
+        }
+        catch (error) {
+            console.warn('Failed to synthesize with AI, using fallback:', error);
+            return this.createFallbackSynthesis(title, query);
+        }
+    }
+    parseSynthesis(text, title) {
+        try {
+            const jsonMatch = text.match(/\{[\s\S]*\}/);
+            if (jsonMatch) {
+                const parsed = JSON.parse(jsonMatch[0]);
+                return {
+                    id: `synth_${Date.now()}`,
+                    title,
+                    summary: parsed.summary || '',
+                    findings: parsed.findings || [],
+                    conclusions: parsed.conclusions || [],
+                    paperDraft: parsed.paperDraft,
+                    createdAt: new Date(),
+                };
+            }
+        }
+        catch (error) {
+            // Fall through
+        }
+        return this.createFallbackSynthesis(title, '');
+    }
+    createFallbackSynthesis(title, query) {
+        return {
+            id: `synth_${Date.now()}`,
+            title,
+            summary: `Synthesis of knowledge related to: ${query}`,
+            findings: ['Finding 1', 'Finding 2'],
+            conclusions: ['Conclusion 1'],
+            createdAt: new Date(),
+        };
+    }
+}

package/dist/discovery/simulationPipeline.js

@@ -0,0 +1,57 @@
+/**
+ * Simulation Pipeline for BASETREE V7
+ * Manages simulation tasks across regions
+ */
+import { randomUUID } from 'crypto';
+export class SimulationPipeline {
+    executionEngine;
+    constructor(executionEngine) {
+        this.executionEngine = executionEngine;
+    }
+    /**
+     * Create and schedule a simulation task
+     */
+    async createSimulation(config) {
+        const taskId = `sim_${randomUUID()}`;
+        const goal = {
+            id: `goal_${taskId}`,
+            title: `${config.type} Simulation`,
+            description: `Run ${config.type} simulation with specified parameters`,
+            priority: 'medium',
+            constraints: {
+                requiredRegions: config.regionId ? [config.regionId] : undefined,
+            },
+            metadata: {
+                simulationType: config.type,
+                parameters: config.parameters,
+                duration: config.duration,
+            },
+        };
+        const task = {
+            id: taskId,
+            goalId: goal.id,
+            runId: `run_${randomUUID()}`,
+            type: 'simulation',
+            payload: {
+                config,
+            },
+            dependencies: [],
+            constraints: {
+                preferredRegion: config.regionId,
+            },
+        };
+        await this.executionEngine.scheduleTask(task);
+        return taskId;
+    }
+    /**
+     * Run multiple simulations in parallel
+     */
+    async runSimulationBatch(configs) {
+        const taskIds = [];
+        for (const config of configs) {
+            const taskId = await this.createSimulation(config);
+            taskIds.push(taskId);
+        }
+        return taskIds;
+    }
+}

package/dist/experiments/experimentationEngine.js

@@ -0,0 +1,174 @@
+/**
+ * Experimentation Engine for BASETREE V6
+ * Landing page generation, A/B testing, pricing experiments, feature gates
+ */
+import { getKernel } from '../kernel/kernel.js';
+import { join } from 'path';
+export class ExperimentationEngine {
+    kernel = getKernel();
+    async createLandingPageExperiment(venture, variants) {
+        const experimentId = `exp_${Date.now()}_${Math.random().toString(36).substr(2, 9)}`;
+        const venturePath = join('ventures', venture.slug, 'landing');
+        const experimentVariants = variants.map((variant, index) => ({
+            id: `variant_${index}`,
+            name: variant,
+            description: `Landing page variant: ${variant}`,
+            trafficShare: 1 / variants.length,
+            metrics: {
+                visitors: 0,
+                signups: 0,
+                conversions: 0,
+                revenue: 0,
+            },
+        }));
+        const experiment = {
+            id: experimentId,
+            ventureId: venture.id,
+            type: 'landing_page',
+            hypothesis: `Testing ${variants.length} landing page variants to optimize conversion`,
+            variants: experimentVariants,
+            createdAt: new Date(),
+            status: 'pending',
+        };
+        await this.kernel.getStateStore().saveExperiment(experiment);
+        return experiment;
+    }
+    async runABTest(experimentId) {
+        const experiment = await this.kernel.getStateStore().getExperiment(experimentId);
+        if (!experiment || experiment.status !== 'completed') {
+            return null;
+        }
+        // Find variant with best conversion rate
+        let bestVariant = experiment.variants[0];
+        let bestScore = 0;
+        for (const variant of experiment.variants) {
+            const conversionRate = variant.metrics.visitors > 0
+                ? variant.metrics.conversions / variant.metrics.visitors
+                : 0;
+            const revenuePerVisitor = variant.metrics.visitors > 0
+                ? variant.metrics.revenue / variant.metrics.visitors
+                : 0;
+            // Combined score: conversion rate * 0.6 + revenue per visitor normalized * 0.4
+            const score = conversionRate * 0.6 + Math.min(revenuePerVisitor / 100, 1) * 0.4;
+            if (score > bestScore) {
+                bestScore = score;
+                bestVariant = variant;
+            }
+        }
+        return bestVariant;
+    }
+    async createPricingExperiment(venture, prices) {
+        const experimentId = `exp_${Date.now()}_${Math.random().toString(36).substr(2, 9)}`;
+        const variants = prices.map((price, index) => ({
+            id: `price_${index}`,
+            name: `$${price}/month`,
+            description: `Pricing tier at $${price} per month`,
+            trafficShare: 1 / prices.length,
+            metrics: {
+                visitors: 0,
+                signups: 0,
+                conversions: 0,
+                revenue: 0,
+            },
+        }));
+        const experiment = {
+            id: experimentId,
+            ventureId: venture.id,
+            type: 'pricing',
+            hypothesis: `Testing price points $${prices.join(', $')} to determine optimal pricing`,
+            variants,
+            createdAt: new Date(),
+            status: 'pending',
+        };
+        await this.kernel.getStateStore().saveExperiment(experiment);
+        return experiment;
+    }
+    async trackExperimentMetrics(experimentId, variantId, event, value) {
+        const experiment = await this.kernel.getStateStore().getExperiment(experimentId);
+        if (!experiment) {
+            return;
+        }
+        const variant = experiment.variants.find((v) => v.id === variantId);
+        if (!variant) {
+            return;
+        }
+        // Update metrics based on event
+        switch (event) {
+            case 'page_view':
+                variant.metrics.visitors++;
+                break;
+            case 'signup':
+                variant.metrics.signups++;
+                break;
+            case 'conversion':
+                variant.metrics.conversions++;
+                break;
+            case 'revenue':
+                variant.metrics.revenue += value || 0;
+                break;
+        }
+        // Update experiment status if needed
+        if (experiment.status === 'pending' && variant.metrics.visitors > 0) {
+            experiment.status = 'running';
+        }
+        await this.kernel.getStateStore().updateExperiment(experimentId, {
+            variants: experiment.variants,
+            status: experiment.status,
+        });
+    }
+    async completeExperiment(experimentId) {
+        const experiment = await this.kernel.getStateStore().getExperiment(experimentId);
+        if (!experiment) {
+            return;
+        }
+        const winner = await this.runABTest(experimentId);
+        const resultSummary = winner
+            ? `Winner: ${winner.name} with ${((winner.metrics.conversions / Math.max(winner.metrics.visitors, 1)) * 100).toFixed(2)}% conversion rate`
+            : 'No clear winner';
+        await this.kernel.getStateStore().updateExperiment(experimentId, {
+            status: 'completed',
+            completedAt: new Date(),
+            resultSummary,
+        });
+    }
+    async createFeatureGateExperiment(venture, feature, userSegments) {
+        const experimentId = `exp_${Date.now()}_${Math.random().toString(36).substr(2, 9)}`;
+        const variants = [
+            {
+                id: 'enabled',
+                name: 'Feature Enabled',
+                description: `${feature} enabled for all users`,
+                trafficShare: 0.5,
+                metrics: {
+                    visitors: 0,
+                    signups: 0,
+                    conversions: 0,
+                    revenue: 0,
+                },
+            },
+            {
+                id: 'disabled',
+                name: 'Feature Disabled',
+                description: `${feature} disabled (control)`,
+                trafficShare: 0.5,
+                metrics: {
+                    visitors: 0,
+                    signups: 0,
+                    conversions: 0,
+                    revenue: 0,
+                },
+            },
+        ];
+        const experiment = {
+            id: experimentId,
+            ventureId: venture.id,
+            type: 'feature_gate',
+            hypothesis: `Testing impact of ${feature} on user engagement and conversion`,
+            variants,
+            createdAt: new Date(),
+            status: 'pending',
+        };
+        await this.kernel.getStateStore().saveExperiment(experiment);
+        return experiment;
+    }
+}

package/dist/index.js

@@ -0,0 +1,67 @@
+#!/usr/bin/env node
+import chalk from "chalk";
+import ora from "ora";
+import prompts from "prompts";
+import gradient from "gradient-string";
+import { GeminiProvider } from "./core/ai/GeminiProvider.js";
+import { LearningMemoryAgent } from "./core/agent/LearningMemoryAgent.js";
+import { AdaptivePlanner } from "./core/agent/AdaptivePlanner.js";
+import { MetaCognitionAgent } from "./core/agent/MetaCognitionAgent.js";
+import { PerformanceMonitor } from "./core/monitor/PerformanceMonitor.js";
+import { SwarmOrchestrator } from "./core/swarm/SwarmOrchestrator.js";
+import { ReasoningBus } from "./core/swarm/ReasoningBus.js";
+import dotenv from "dotenv";
+import { setupCLI as setupV5CLI } from "./cli.js";
+dotenv.config();
+const performance = new PerformanceMonitor();
+const bus = ReasoningBus.getInstance();
+// Subscribe to global reasoning bus for swarm telemetry
+bus.subscribe((event) => {
+    const icon = event.type === "error" ? "❌" : event.type === "result" ? "✅" : "💡";
+    console.log(chalk.dim(`    ${icon} [${event.role}] ${event.content}`));
+});
+const BASETREE_ASCII = `
+██████╗  █████╗ ███████╗███████╗████████╗██████╗ ███████╗███████╗
+██╔══██╗██╔══██╗██╔════╝██╔════╝╚══██╔══╝██╔══██╗██╔════╝██╔════╝
+██████╔╝███████║███████╗█████╗     ██║   ██████╔╝█████╗  █████╗  
+██╔══██╗██╔══██║╚════██║██╔══╝     ██║   ██╔══██╗██╔══╝  ██╔══╝  
+██████╔╝██║  ██║███████║███████╗   ██║   ██║  ██║███████╗███████╗
+╚═════╝ ╚═╝  ╚═╝╚══════╝╚══════╝   ╚═╝   ╚═╝  ╚═╝╚══════╝╚══════╝
+`;
+// V5/V6/V7 CLI (core commands)
+const program = setupV5CLI();
+// V4 chat command
+program
+    .command("chat")
+    .description("Start interactive session (V4)")
+    .action(async () => {
+    console.clear();
+    console.log(gradient.pastel.multiline(BASETREE_ASCII));
+    const ai = new GeminiProvider();
+    const memory = new LearningMemoryAgent(ai);
+    const planner = new AdaptivePlanner(ai, memory);
+    const orchestrator = new SwarmOrchestrator(ai, memory);
+    const meta = new MetaCognitionAgent(ai, memory);
+    while (true) {
+        const response = await prompts({
+            type: 'text',
+            name: 'value',
+            message: gradient.passion('➜ '),
+        });
+        if (!response.value)
+            break;
+        await runAutonomousEngine(response.value, ai, memory, planner, orchestrator, meta);
+    }
+    console.log(chalk.gray(performance.getSummary()));
+});
+async function runAutonomousEngine(input, ai, memory, planner, orchestrator, meta) {
+    const spinner = ora(chalk.blue("Swarm Strategy Planning...")).start();
+    const paths = await planner.createAdaptivePlan(input);
+    const bestPath = planner.selectBestPath(paths);
+    spinner.succeed(chalk.green(`Swarm Route Selected: ${bestPath.id} (Risk: ${bestPath.riskScore})`));
+    // Execute plan via swarm orchestrator
+    await orchestrator.executePlanParallel(bestPath.steps);
+    // Meta-cognition loop
+    await meta.critique(input, "Success", []);
+}
+program.parse();

package/dist/kernel/eventBus.js

@@ -0,0 +1,89 @@
+/**
+ * Event Bus for BASETREE V5
+ * Typed event bus for system events
+ */
+class EventBus {
+    handlers = new Map();
+    eventHistory = [];
+    maxHistorySize = 1000;
+    subscribe(eventType, handler) {
+        if (!this.handlers.has(eventType)) {
+            this.handlers.set(eventType, new Set());
+        }
+        this.handlers.get(eventType).add(handler);
+        // Return unsubscribe function
+        return () => {
+            const handlers = this.handlers.get(eventType);
+            if (handlers) {
+                handlers.delete(handler);
+            }
+        };
+    }
+    subscribeAll(handler) {
+        const unsubscribers = [];
+        const eventTypes = [
+            'IntrospectionCompleted',
+            'ProposalCreated',
+            'ProposalUpdated',
+            'GovernanceDecision',
+            'UpgradeStarted',
+            'UpgradeApplied',
+            'UpgradeFailed',
+            'RegressionStarted',
+            'RegressionCompleted',
+            'RegressionFailed',
+            'RollbackTriggered',
+            'RollbackCompleted',
+            'MetricRecorded',
+            'SnapshotCreated',
+            'AgentRegistered',
+            'AgentUnregistered',
+        ];
+        for (const eventType of eventTypes) {
+            const unsubscribe = this.subscribe(eventType, handler);
+            unsubscribers.push(unsubscribe);
+        }
+        return () => {
+            unsubscribers.forEach((unsub) => unsub());
+        };
+    }
+    async emit(event) {
+        // Add to history
+        this.eventHistory.push(event);
+        if (this.eventHistory.length > this.maxHistorySize) {
+            this.eventHistory.shift();
+        }
+        // Notify handlers
+        const handlers = this.handlers.get(event.type);
+        if (handlers) {
+            const promises = Array.from(handlers).map((handler) => {
+                try {
+                    return Promise.resolve(handler(event));
+                }
+                catch (error) {
+                    console.error(`Error in event handler for ${event.type}:`, error);
+                    return Promise.resolve();
+                }
+            });
+            await Promise.all(promises);
+        }
+    }
+    getHistory(eventType) {
+        if (eventType) {
+            return this.eventHistory.filter((e) => e.type === eventType);
+        }
+        return [...this.eventHistory];
+    }
+    clearHistory() {
+        this.eventHistory = [];
+    }
+}
+// Singleton instance
+let eventBusInstance = null;
+export function getEventBus() {
+    if (!eventBusInstance) {
+        eventBusInstance = new EventBus();
+    }
+    return eventBusInstance;
+}
+export { EventBus };

package/dist/kernel/kernel.js

@@ -0,0 +1,146 @@
+/**
+ * Core Kernel for BASETREE V5
+ * Immutable core kernel exposing stable API for agents, pipelines, events, and state
+ */
+import { getEventBus } from './eventBus.js';
+import { FileStateStore } from '../state/fileStateStore.js';
+import { getConfig } from '../config/config.js';
+export class Kernel {
+    agents = new Map();
+    pipelines = new Map();
+    stateStore;
+    eventBus = getEventBus();
+    config = getConfig();
+    initialized = false;
+    upgradeTransaction = { active: false };
+    constructor(stateStore) {
+        this.stateStore = stateStore || new FileStateStore();
+    }
+    async initialize() {
+        if (this.initialized) {
+            return;
+        }
+        // Initialize state store if needed
+        // Register core event handlers
+        this.eventBus.subscribe('AgentRegistered', (event) => {
+            console.log(`[Kernel] Agent registered: ${event.agentId}`);
+        });
+        this.initialized = true;
+    }
+    async shutdown() {
+        // Shutdown all agents
+        for (const agent of this.agents.values()) {
+            if (agent.shutdown) {
+                try {
+                    await agent.shutdown();
+                }
+                catch (error) {
+                    console.error(`Error shutting down agent ${agent.id}:`, error);
+                }
+            }
+        }
+        this.agents.clear();
+        this.pipelines.clear();
+        this.initialized = false;
+    }
+    // Agent registration
+    registerAgent(agent) {
+        if (this.agents.has(agent.id)) {
+            throw new Error(`Agent ${agent.id} is already registered`);
+        }
+        this.agents.set(agent.id, agent);
+        this.eventBus.emit({
+            type: 'AgentRegistered',
+            timestamp: new Date(),
+            agentId: agent.id,
+        });
+        // Initialize agent if kernel is already initialized
+        if (this.initialized && agent.initialize) {
+            agent.initialize().catch((error) => {
+                console.error(`Failed to initialize agent ${agent.id}:`, error);
+            });
+        }
+    }
+    unregisterAgent(agentId) {
+        const agent = this.agents.get(agentId);
+        if (agent) {
+            if (agent.shutdown) {
+                agent.shutdown().catch((error) => {
+                    console.error(`Error shutting down agent ${agentId}:`, error);
+                });
+            }
+            this.agents.delete(agentId);
+            this.eventBus.emit({
+                type: 'AgentUnregistered',
+                timestamp: new Date(),
+                agentId,
+            });
+        }
+    }
+    getAgent(agentId) {
+        return this.agents.get(agentId);
+    }
+    listAgents() {
+        return Array.from(this.agents.values());
+    }
+    // Pipeline registration
+    registerPipeline(pipeline) {
+        if (this.pipelines.has(pipeline.id)) {
+            throw new Error(`Pipeline ${pipeline.id} is already registered`);
+        }
+        this.pipelines.set(pipeline.id, pipeline);
+    }
+    getPipeline(id) {
+        return this.pipelines.get(id);
+    }
+    listPipelines() {
+        return Array.from(this.pipelines.values());
+    }
+    // State store access
+    getStateStore() {
+        return this.stateStore;
+    }
+    // Event bus access
+    getEventBus() {
+        return this.eventBus;
+    }
+    // Config access
+    getConfig() {
+        return this.config;
+    }
+    // Upgrade transaction management
+    beginUpgradeTransaction(proposalId, snapshotId) {
+        if (this.upgradeTransaction.active) {
+            throw new Error('Upgrade transaction already active');
+        }
+        this.upgradeTransaction = {
+            active: true,
+            proposalId,
+            snapshotId,
+        };
+    }
+    endUpgradeTransaction() {
+        this.upgradeTransaction = { active: false };
+    }
+    getUpgradeTransaction() {
+        return { ...this.upgradeTransaction };
+    }
+    // Protected kernel check - used by kernel guard
+    isKernelProtectedPath(filePath) {
+        const relativePath = filePath.replace(this.config.workspaceRoot, '').replace(/^[/\\]/, '');
+        return this.config.safety.protectedPaths.some((protectedPath) => {
+            return relativePath.startsWith(protectedPath);
+        });
+    }
+}
+// Singleton instance
+let kernelInstance = null;
+export function getKernel() {
+    if (!kernelInstance) {
+        kernelInstance = new Kernel();
+    }
+    return kernelInstance;
+}
+export function resetKernel() {
+    kernelInstance = null;
+}