@vishal_20/basetree 1.0.0

package/dist/pipelines/venture/launchPipeline.js

@@ -0,0 +1,55 @@
+/**
+ * Launch Pipeline for BASETREE V6
+ * Orchestrates MVP deployment
+ */
+import { getKernel } from '../../kernel/kernel.js';
+import { FileTools } from '../../tools/FileTools.js';
+import { execa } from 'execa';
+import { join } from 'path';
+import chalk from 'chalk';
+import ora from 'ora';
+export class LaunchPipeline {
+    kernel = getKernel();
+    async run(ventureId) {
+        const spinner = ora(`Launching venture ${ventureId}...`).start();
+        try {
+            const venture = await this.kernel.getStateStore().getVenture(ventureId);
+            if (!venture) {
+                throw new Error(`Venture ${ventureId} not found`);
+            }
+            const venturePath = join('ventures', venture.slug);
+            // Build project
+            spinner.text = 'Building project...';
+            try {
+                await execa('npm', ['install'], {
+                    cwd: venturePath,
+                    reject: false,
+                });
+            }
+            catch (error) {
+                console.warn(chalk.yellow('Build warnings:'), error.message);
+            }
+            // Create launch script
+            spinner.text = 'Setting up launch configuration...';
+            await FileTools.writeFile(join(venturePath, 'launch.json'), JSON.stringify({
+                ventureId: venture.id,
+                launchedAt: new Date().toISOString(),
+                status: 'launched',
+            }, null, 2));
+            // Update venture stage
+            await this.kernel.getStateStore().updateVenture(ventureId, {
+                stage: 'launched',
+            });
+            spinner.succeed('Venture launched successfully!');
+            console.log(chalk.green(`\nVenture "${venture.idea}" is now live!`));
+            console.log(chalk.blue(`\nLocation: ${venturePath}`));
+            console.log(chalk.blue(`\nNext steps:`));
+            console.log(chalk.blue(`1. Run: basetree grow ${ventureId}`));
+            console.log(chalk.blue(`2. Monitor metrics: basetree metrics --venture ${ventureId}`));
+        }
+        catch (error) {
+            spinner.fail(`Launch failed: ${error.message}`);
+            throw error;
+        }
+    }
+}

package/dist/pipelines/venture/monetizePipeline.js

@@ -0,0 +1,46 @@
+/**
+ * Monetize Pipeline for BASETREE V6
+ * Orchestrates revenue optimization
+ */
+import { getKernel } from '../../kernel/kernel.js';
+import { RevenueAgent } from '../../agents/venture/revenueAgent.js';
+import { ExperimentationEngine } from '../../experiments/experimentationEngine.js';
+import chalk from 'chalk';
+import ora from 'ora';
+export class MonetizePipeline {
+    kernel = getKernel();
+    revenueAgent = new RevenueAgent();
+    experimentationEngine = new ExperimentationEngine();
+    async run(ventureId) {
+        const spinner = ora(`Monetizing venture ${ventureId}...`).start();
+        try {
+            const venture = await this.kernel.getStateStore().getVenture(ventureId);
+            if (!venture) {
+                throw new Error(`Venture ${ventureId} not found`);
+            }
+            if (!venture.businessModel) {
+                throw new Error('Business model not defined. Run startup pipeline first.');
+            }
+            // Create pricing experiment
+            spinner.text = 'Creating pricing experiment...';
+            const pricingExperiment = await this.revenueAgent.createRevenueExperiment(ventureId, venture.businessModel.pricePoints);
+            spinner.succeed('Pricing experiment created');
+            // Update venture stage
+            await this.kernel.getStateStore().updateVenture(ventureId, {
+                stage: 'monetizing',
+                experimentIds: [...venture.experimentIds, pricingExperiment.id],
+            });
+            spinner.succeed('Monetization pipeline initiated!');
+            console.log(chalk.green(`\nPricing experiment for "${venture.idea}"`));
+            console.log(chalk.blue(`\nTesting price points: $${venture.businessModel.pricePoints.join(', $')}`));
+            console.log(chalk.blue(`Experiment ID: ${pricingExperiment.id}`));
+            console.log(chalk.blue(`\nNext steps:`));
+            console.log(chalk.blue(`1. Track conversion metrics`));
+            console.log(chalk.blue(`2. Analyze results: basetree metrics --venture ${ventureId}`));
+        }
+        catch (error) {
+            spinner.fail(`Monetization pipeline failed: ${error.message}`);
+            throw error;
+        }
+    }
+}

package/dist/pipelines/venture/shutdownPipeline.js

@@ -0,0 +1,40 @@
+/**
+ * Shutdown Pipeline for BASETREE V6
+ * Orchestrates graceful shutdown and learning
+ */
+import { getKernel } from '../../kernel/kernel.js';
+import { VentureMemory } from '../../venture/ventureMemory.js';
+import chalk from 'chalk';
+import ora from 'ora';
+export class ShutdownPipeline {
+    kernel = getKernel();
+    memory = new VentureMemory();
+    async run(ventureId, reason) {
+        const spinner = ora(`Shutting down venture ${ventureId}...`).start();
+        try {
+            const venture = await this.kernel.getStateStore().getVenture(ventureId);
+            if (!venture) {
+                throw new Error(`Venture ${ventureId} not found`);
+            }
+            // Record failure lesson
+            spinner.text = 'Recording lessons learned...';
+            await this.memory.recordFailureLesson(ventureId, `Shutdown: ${venture.idea}`, `Reason: ${reason}\nStage: ${venture.stage}\nMetrics: MRR $${venture.metrics.mrr}, CAC $${venture.metrics.cac}, LTV $${venture.metrics.ltv}`, ['shutdown', venture.stage, 'failure']);
+            // Extract learnings
+            if (venture.metrics.mrr > 0) {
+                await this.memory.recordTractionModel(ventureId, `Traction model: ${venture.idea}`, `Achieved MRR of $${venture.metrics.mrr} with CAC $${venture.metrics.cac}`, ['traction', 'success']);
+            }
+            // Update venture stage
+            await this.kernel.getStateStore().updateVenture(ventureId, {
+                stage: 'shutdown',
+            });
+            spinner.succeed('Venture shutdown completed');
+            console.log(chalk.yellow(`\nVenture "${venture.idea}" has been shut down`));
+            console.log(chalk.blue(`Reason: ${reason}`));
+            console.log(chalk.blue(`Lessons learned have been recorded for future ventures`));
+        }
+        catch (error) {
+            spinner.fail(`Shutdown failed: ${error.message}`);
+            throw error;
+        }
+    }
+}

package/dist/pipelines/venture/startupPipeline.js

@@ -0,0 +1,145 @@
+/**
+ * Startup Pipeline for BASETREE V6
+ * Orchestrates: Idea generation → Market research → Validation → MVP build
+ */
+import { IdeationAgent } from '../../agents/venture/ideationAgent.js';
+import { MarketResearchAgent } from '../../agents/venture/marketResearchAgent.js';
+import { ValidationAgent } from '../../agents/venture/validationAgent.js';
+import { BusinessModelAgent } from '../../agents/venture/businessModelAgent.js';
+import { ProductAgent } from '../../agents/venture/productAgent.js';
+import { GeminiProvider } from '../../core/ai/GeminiProvider.js';
+import { LearningMemoryAgent } from '../../core/agent/LearningMemoryAgent.js';
+import { getKernel } from '../../kernel/kernel.js';
+import { FileTools } from '../../tools/FileTools.js';
+import { randomUUID } from 'crypto';
+import { join } from 'path';
+import chalk from 'chalk';
+import ora from 'ora';
+export class StartupPipeline {
+    kernel = getKernel();
+    ai = new GeminiProvider();
+    memory = new LearningMemoryAgent(this.ai);
+    ideationAgent = new IdeationAgent(this.ai);
+    marketResearchAgent = new MarketResearchAgent(this.ai);
+    validationAgent = new ValidationAgent();
+    businessModelAgent = new BusinessModelAgent(this.ai);
+    productAgent = new ProductAgent(this.ai);
+    async run(seedIdea) {
+        const spinner = ora('Creating new venture...').start();
+        try {
+            // Step 1: Generate idea
+            spinner.text = 'Generating startup idea...';
+            const idea = await this.ideationAgent.generateIdea(seedIdea);
+            spinner.succeed('Startup idea generated');
+            // Step 2: Market research
+            spinner.start('Researching market...');
+            const market = await this.marketResearchAgent.researchMarket(idea);
+            spinner.succeed('Market research completed');
+            // Step 3: Create venture record
+            const ventureId = `venture_${randomUUID()}`;
+            const slug = seedIdea
+                .toLowerCase()
+                .replace(/[^a-z0-9]+/g, '-')
+                .replace(/^-|-$/g, '');
+            const venture = {
+                id: ventureId,
+                slug,
+                idea: seedIdea,
+                generatedIdea: idea,
+                market,
+                stage: 'ideation',
+                createdAt: new Date(),
+                updatedAt: new Date(),
+                metrics: {
+                    mrr: 0,
+                    cac: 0,
+                    ltv: 0,
+                    activationRate: 0,
+                    retentionRate: 0,
+                    growthRate: 0,
+                },
+                experimentIds: [],
+            };
+            // Step 4: Business model
+            spinner.start('Designing business model...');
+            const businessModel = await this.businessModelAgent.designBusinessModel(venture);
+            venture.businessModel = businessModel;
+            spinner.succeed('Business model designed');
+            // Step 5: Product MVP definition
+            spinner.start('Defining MVP...');
+            const mvp = await this.productAgent.defineMVP(venture);
+            spinner.succeed('MVP defined');
+            // Step 6: Create validation experiment
+            spinner.start('Creating validation experiment...');
+            const validationExperiment = await this.validationAgent.createValidationExperiment(venture);
+            spinner.succeed('Validation experiment created');
+            // Step 7: Create venture directory structure
+            spinner.start('Setting up venture structure...');
+            await this.setupVentureStructure(venture, mvp);
+            spinner.succeed('Venture structure created');
+            // Step 8: Save venture
+            await this.kernel.getStateStore().saveVenture(venture);
+            spinner.succeed(`Venture "${venture.idea}" created successfully!`);
+            console.log(chalk.green(`\nVenture ID: ${venture.id}`));
+            console.log(chalk.green(`Slug: ${venture.slug}`));
+            console.log(chalk.green(`Location: ventures/${venture.slug}`));
+            console.log(chalk.blue(`\nNext steps:`));
+            console.log(chalk.blue(`1. Run: basetree validate ${venture.id}`));
+            console.log(chalk.blue(`2. Review landing pages in ventures/${venture.slug}/landing`));
+            return venture;
+        }
+        catch (error) {
+            spinner.fail(`Failed to create venture: ${error.message}`);
+            throw error;
+        }
+    }
+    async setupVentureStructure(venture, mvp) {
+        const venturePath = join('ventures', venture.slug);
+        // Create directory structure
+        await FileTools.writeFile(join(venturePath, 'package.json'), JSON.stringify({
+            name: venture.slug,
+            version: '0.1.0',
+            description: venture.idea,
+            main: 'src/index.js',
+            scripts: {
+                dev: 'node src/index.js',
+                build: 'echo "Build script"',
+                start: 'node src/index.js',
+            },
+            dependencies: {},
+        }, null, 2));
+        await FileTools.writeFile(join(venturePath, 'README.md'), `# ${venture.idea}
+
+## Problem
+${venture.generatedIdea.problem}
+
+## Solution
+${venture.generatedIdea.solution}
+
+## Target Customer
+${venture.generatedIdea.targetCustomer}
+
+## MVP Features
+${mvp.features.map((f) => `- ${f}`).join('\n')}
+
+## Business Model
+${venture.businessModel?.pricingModel || 'TBD'}
+
+## Market
+- TAM: $${venture.market?.tamEstimate.toLocaleString() || 'TBD'}
+- SAM: $${venture.market?.samEstimate.toLocaleString() || 'TBD'}
+- SOM: $${venture.market?.somEstimate.toLocaleString() || 'TBD'}
+
+## Next Steps
+1. Validate with landing page experiments
+2. Build MVP
+3. Launch and iterate
+`);
+        // Create basic source structure
+        await FileTools.writeFile(join(venturePath, 'src', 'index.js'), `// ${venture.idea}
+// MVP Implementation
+
+console.log('${venture.idea} - Coming soon!');
+`);
+    }
+}

package/dist/pipelines/venture/validatePipeline.js

@@ -0,0 +1,40 @@
+/**
+ * Validate Pipeline for BASETREE V6
+ * Orchestrates validation experiments
+ */
+import { getKernel } from '../../kernel/kernel.js';
+import { ValidationAgent } from '../../agents/venture/validationAgent.js';
+import chalk from 'chalk';
+import ora from 'ora';
+export class ValidatePipeline {
+    kernel = getKernel();
+    validationAgent = new ValidationAgent();
+    async run(ventureId) {
+        const spinner = ora(`Validating venture ${ventureId}...`).start();
+        try {
+            const venture = await this.kernel.getStateStore().getVenture(ventureId);
+            if (!venture) {
+                throw new Error(`Venture ${ventureId} not found`);
+            }
+            spinner.text = 'Creating validation experiment...';
+            const experiment = await this.validationAgent.createValidationExperiment(venture);
+            spinner.succeed('Validation experiment created');
+            console.log(chalk.green(`\nExperiment ID: ${experiment.id}`));
+            console.log(chalk.green(`Variants: ${experiment.variants.length}`));
+            console.log(chalk.blue(`\nLanding pages created in: ventures/${venture.slug}/landing`));
+            console.log(chalk.blue(`\nTo test:`));
+            console.log(chalk.blue(`1. Open ventures/${venture.slug}/landing/variant-a.html`));
+            console.log(chalk.blue(`2. Open ventures/${venture.slug}/landing/variant-b.html`));
+            console.log(chalk.blue(`3. Track metrics and run: basetree launch ${ventureId}`));
+            // Update venture stage
+            await this.kernel.getStateStore().updateVenture(ventureId, {
+                stage: 'validation',
+            });
+            return experiment;
+        }
+        catch (error) {
+            spinner.fail(`Validation failed: ${error.message}`);
+            throw error;
+        }
+    }
+}

package/dist/planet/controlPlane.js

@@ -0,0 +1,131 @@
+/**
+ * Planetary Control Plane for BASETREE V7
+ * Central orchestrator for regions, organizations, and global policies
+ */
+import { randomUUID } from 'crypto';
+import { getKernel } from '../kernel/kernel.js';
+export class ControlPlane {
+    regionManager;
+    globalBus;
+    kernel = getKernel();
+    goals = new Map();
+    runs = new Map();
+    organizations = new Map();
+    constructor(regionManager, globalBus) {
+        this.regionManager = regionManager;
+        this.globalBus = globalBus;
+    }
+    /**
+     * Initialize control plane with default regions
+     */
+    async initialize() {
+        // Register default regions for dev
+        this.regionManager.registerRegion({
+            id: 'us-east',
+            name: 'US East',
+            cloud: 'local',
+            locality: 'us-east',
+            capacity: {
+                maxConcurrentTasks: 100,
+                cpuUnits: 1000,
+                memoryGB: 100,
+            },
+            carbonIntensity: 0.5,
+            costPerHour: 1.0,
+            latency: {},
+        });
+        this.regionManager.registerRegion({
+            id: 'eu-west',
+            name: 'EU West',
+            cloud: 'local',
+            locality: 'eu-west',
+            capacity: {
+                maxConcurrentTasks: 100,
+                cpuUnits: 1000,
+                memoryGB: 100,
+            },
+            carbonIntensity: 0.3, // Lower carbon in EU
+            costPerHour: 1.2,
+            latency: {},
+        });
+        // Start default regions
+        await this.regionManager.startRegion('us-east');
+        await this.regionManager.startRegion('eu-west');
+        // Subscribe to global events
+        this.globalBus.subscribe('global.goal', async (event) => {
+            // Handle goal events
+        });
+    }
+    /**
+     * Register an organization
+     */
+    registerOrganization(org) {
+        this.organizations.set(org.id, org);
+    }
+    /**
+     * Submit a global goal
+     */
+    async submitGoal(goal) {
+        // Validate organization if specified
+        if (goal.orgId) {
+            const org = this.organizations.get(goal.orgId);
+            if (!org) {
+                throw new Error(`Organization ${goal.orgId} not found`);
+            }
+        }
+        // Create run
+        const runId = `run_${randomUUID()}`;
+        const run = {
+            id: runId,
+            goalId: goal.id,
+            status: 'pending',
+            assignedRegions: [],
+            taskIds: [],
+        };
+        this.goals.set(goal.id, goal);
+        this.runs.set(runId, run);
+        // Publish goal to global bus
+        await this.globalBus.publish('global.goal', {
+            goal,
+            runId,
+        });
+        // Route to execution engine (will be implemented)
+        run.status = 'running';
+        run.startedAt = new Date();
+        return runId;
+    }
+    /**
+     * Get run by ID
+     */
+    getRun(runId) {
+        return this.runs.get(runId);
+    }
+    /**
+     * Get goal by ID
+     */
+    getGoal(goalId) {
+        return this.goals.get(goalId);
+    }
+    /**
+     * List all runs
+     */
+    listRuns(status) {
+        let runs = Array.from(this.runs.values());
+        if (status) {
+            runs = runs.filter((r) => r.status === status);
+        }
+        return runs;
+    }
+    /**
+     * Get region manager
+     */
+    getRegionManager() {
+        return this.regionManager;
+    }
+    /**
+     * Get global bus
+     */
+    getGlobalBus() {
+        return this.globalBus;
+    }
+}

package/dist/planet/executionEngine.js

@@ -0,0 +1,142 @@
+/**
+ * Planetary Execution Engine for BASETREE V7
+ * Global task routing, multi-cloud orchestration, cost-aware and carbon-aware scheduling
+ */
+import { EconomicAgent } from '../agents/planet/economicAgent.js';
+import { ClimateAgent } from '../agents/planet/climateAgent.js';
+import { randomUUID } from 'crypto';
+export class PlanetaryExecutionEngine {
+    controlPlane;
+    economicAgent;
+    climateAgent;
+    scheduledTasks = new Map();
+    constructor(controlPlane) {
+        this.controlPlane = controlPlane;
+        this.economicAgent = new EconomicAgent();
+        this.climateAgent = new ClimateAgent();
+    }
+    /**
+     * Submit a global task/goal
+     */
+    async submitGlobalTask(goal) {
+        return this.controlPlane.submitGoal(goal);
+    }
+    /**
+     * Schedule a task to a region based on optimization criteria
+     */
+    async scheduleTask(task) {
+        // Get available regions
+        const regionManager = this.controlPlane.getRegionManager();
+        const regions = regionManager.listRegions();
+        // Find optimal region based on:
+        // 1. Capacity
+        // 2. Cost
+        // 3. Carbon intensity
+        // 4. Latency (if dependencies exist)
+        const optimalRegion = await this.selectOptimalRegion(task, regions.map((r) => r.id));
+        const scheduledTask = {
+            ...task,
+            assignedRegion: optimalRegion,
+            scheduledAt: new Date(),
+            status: 'scheduled',
+        };
+        this.scheduledTasks.set(task.id, scheduledTask);
+        // Route to regional kernel
+        const regionalKernel = regionManager.getRegion(optimalRegion);
+        if (regionalKernel) {
+            // In production, this would submit to regional execution queue
+            // For now, mark as running
+            scheduledTask.status = 'running';
+            scheduledTask.startedAt = new Date();
+        }
+        return scheduledTask;
+    }
+    /**
+     * Report task result
+     */
+    async reportTaskResult(taskId, result, error) {
+        const task = this.scheduledTasks.get(taskId);
+        if (!task) {
+            throw new Error(`Task ${taskId} not found`);
+        }
+        if (error) {
+            task.status = 'failed';
+        }
+        else {
+            task.status = 'completed';
+            task.result = result;
+        }
+        task.completedAt = new Date();
+        // If task failed, consider rescheduling to another region (self-healing)
+        if (error) {
+            await this.handleTaskFailure(task);
+        }
+    }
+    /**
+     * Select optimal region for a task
+     */
+    async selectOptimalRegion(task, availableRegions) {
+        const regionManager = this.controlPlane.getRegionManager();
+        let bestRegion = availableRegions[0];
+        let bestScore = -Infinity;
+        for (const regionId of availableRegions) {
+            const config = regionManager.getRegionConfig(regionId);
+            if (!config)
+                continue;
+            // Check capacity
+            const regionalKernel = regionManager.getRegion(regionId);
+            if (!regionalKernel || regionalKernel.status !== 'healthy') {
+                continue; // Skip unhealthy regions
+            }
+            // Calculate score: balance cost, carbon, latency
+            const costScore = 1 / (config.costPerHour + 0.01); // Lower cost = higher score
+            const carbonScore = 1 / (config.carbonIntensity + 0.01); // Lower carbon = higher score
+            const capacityScore = config.capacity.maxConcurrentTasks / 100; // Normalized capacity
+            // Weighted combination
+            let score = costScore * 0.4 + carbonScore * 0.3 + capacityScore * 0.3;
+            // Apply constraints
+            if (task.constraints.preferredRegion && task.constraints.preferredRegion === regionId) {
+                score += 0.5; // Boost preferred region
+            }
+            if (score > bestScore) {
+                bestScore = score;
+                bestRegion = regionId;
+            }
+        }
+        return bestRegion;
+    }
+    /**
+     * Handle task failure with self-healing
+     */
+    async handleTaskFailure(task) {
+        // Reschedule to a different region
+        const regionManager = this.controlPlane.getRegionManager();
+        const allRegions = regionManager.listRegions().map((r) => r.id);
+        const otherRegions = allRegions.filter((r) => r !== task.assignedRegion);
+        if (otherRegions.length > 0) {
+            console.warn(`Task ${task.id} failed in ${task.assignedRegion}, rescheduling to ${otherRegions[0]}`);
+            // Create new task descriptor
+            const newTask = {
+                ...task,
+                id: `retry_${task.id}_${randomUUID()}`,
+            };
+            await this.scheduleTask(newTask);
+        }
+    }
+    /**
+     * Get scheduled task
+     */
+    getScheduledTask(taskId) {
+        return this.scheduledTasks.get(taskId);
+    }
+    /**
+     * List scheduled tasks
+     */
+    listScheduledTasks(status) {
+        let tasks = Array.from(this.scheduledTasks.values());
+        if (status) {
+            tasks = tasks.filter((t) => t.status === status);
+        }
+        return tasks;
+    }
+}

package/dist/planet/globalTypes.js

@@ -0,0 +1,5 @@
+/**
+ * Global types for BASETREE V7
+ * Types for planetary-scale operations: goals, runs, regions, zones, organizations
+ */
+export {};