@vishal_20/basetree 1.0.0

package/dist/observability/reportRenderer.js

@@ -0,0 +1,100 @@
+/**
+ * Report Renderer for BASETREE V5
+ * Renders human-readable reports (CLI tables, JSON, optionally web-friendly JSON)
+ */
+import chalk from 'chalk';
+export class ReportRenderer {
+    /**
+     * Render introspection report
+     */
+    renderIntrospection(report, format = 'both') {
+        if (format === 'json' || format === 'both') {
+            console.log(JSON.stringify(report, null, 2));
+        }
+        if (format === 'cli' || format === 'both') {
+            console.log(chalk.blue('\n📊 Introspection Report\n'));
+            console.log(`Modules: ${report.metrics.totalModules}`);
+            console.log(`LOC: ${report.metrics.totalLinesOfCode}`);
+            console.log(`Avg Complexity: ${report.metrics.averageComplexity.toFixed(2)}`);
+            console.log(`Bottlenecks: ${report.bottlenecks.length}`);
+            console.log(`Proposals: ${report.upgradeProposals.length}\n`);
+        }
+    }
+    /**
+     * Render cognitive metrics
+     */
+    renderCognitiveMetrics(drift, entropy, velocity, format = 'both') {
+        if (format === 'json' || format === 'both') {
+            console.log(JSON.stringify({
+                drift,
+                entropy,
+                velocity,
+            }, null, 2));
+        }
+        if (format === 'cli' || format === 'both') {
+            console.log(chalk.blue('\n🧠 Cognitive Metrics\n'));
+            console.log(chalk.yellow('Cognitive Drift:'));
+            console.log(`  Score: ${(drift.driftScore * 100).toFixed(1)}%`);
+            console.log(`  Complexity Change: ${(drift.factors.complexityChange * 100).toFixed(1)}%`);
+            console.log(`  Coupling Change: ${(drift.factors.couplingChange * 100).toFixed(1)}%\n`);
+            console.log(chalk.yellow('Architectural Entropy:'));
+            console.log(`  Entropy: ${entropy.entropy.toFixed(2)}`);
+            console.log(`  Normalized: ${(entropy.normalizedEntropy * 100).toFixed(1)}%`);
+            console.log(`  Dependency Complexity: ${(entropy.factors.dependencyComplexity * 100).toFixed(1)}%\n`);
+            console.log(chalk.yellow('Learning Velocity:'));
+            console.log(`  Velocity: ${velocity.velocity.toFixed(2)} improvements/day`);
+            console.log(`  Trend: ${velocity.trend}`);
+            console.log(`  Success Rate: ${(velocity.metrics.successRate * 100).toFixed(1)}%\n`);
+        }
+    }
+    /**
+     * Render failure surface
+     */
+    renderFailureSurface(surface, format = 'both') {
+        if (format === 'json' || format === 'both') {
+            console.log(JSON.stringify(surface, null, 2));
+        }
+        if (format === 'cli' || format === 'both') {
+            console.log(chalk.blue('\n🛡️  Failure Surface Map\n'));
+            if (surface.hotspots.length > 0) {
+                console.log(chalk.yellow('Hotspots:'));
+                for (const hotspot of surface.hotspots.slice(0, 5)) {
+                    console.log(`  ${hotspot.location}: ${hotspot.failureCount} failures (risk: ${(hotspot.riskScore * 100).toFixed(0)}%)`);
+                }
+                console.log('');
+            }
+            if (surface.patterns.length > 0) {
+                console.log(chalk.yellow('Common Patterns:'));
+                for (const pattern of surface.patterns.slice(0, 5)) {
+                    console.log(`  ${pattern.pattern}: ${pattern.frequency} occurrences`);
+                }
+                console.log('');
+            }
+        }
+    }
+    /**
+     * Render metrics dashboard
+     */
+    renderMetrics(metrics, format = 'both') {
+        if (format === 'json' || format === 'both') {
+            console.log(JSON.stringify(metrics, null, 2));
+        }
+        if (format === 'cli' || format === 'both') {
+            console.log(chalk.blue('\n📈 Metrics Dashboard\n'));
+            // Group by name
+            const grouped = new Map();
+            for (const metric of metrics) {
+                if (!grouped.has(metric.name)) {
+                    grouped.set(metric.name, []);
+                }
+                grouped.get(metric.name).push(metric);
+            }
+            for (const [name, values] of grouped.entries()) {
+                const avg = values.reduce((sum, m) => sum + m.value, 0) / values.length;
+                const unit = values[0].unit || '';
+                console.log(`${name}: ${avg.toFixed(2)} ${unit} (${values.length} samples)`);
+            }
+            console.log('');
+        }
+    }
+}

package/dist/performance/memoryProfiler.js

@@ -0,0 +1,107 @@
+/**
+ * Memory Profiler for BASETREE V5
+ * Tracks memory usage, leaks, and high-allocation paths
+ */
+import { performance } from 'perf_hooks';
+export class MemoryProfiler {
+    snapshots = [];
+    intervalId = null;
+    maxSnapshots = 1000;
+    /**
+     * Take a memory snapshot
+     */
+    snapshot() {
+        const memUsage = process.memoryUsage();
+        const snapshot = {
+            timestamp: performance.now(),
+            heapUsed: memUsage.heapUsed,
+            heapTotal: memUsage.heapTotal,
+            external: memUsage.external,
+            rss: memUsage.rss,
+        };
+        this.snapshots.push(snapshot);
+        if (this.snapshots.length > this.maxSnapshots) {
+            this.snapshots.shift();
+        }
+        return snapshot;
+    }
+    /**
+     * Start continuous monitoring
+     */
+    startMonitoring(intervalMs = 1000) {
+        if (this.intervalId) {
+            this.stopMonitoring();
+        }
+        this.intervalId = setInterval(() => {
+            this.snapshot();
+        }, intervalMs);
+    }
+    /**
+     * Stop continuous monitoring
+     */
+    stopMonitoring() {
+        if (this.intervalId) {
+            clearInterval(this.intervalId);
+            this.intervalId = null;
+        }
+    }
+    /**
+     * Get current memory usage
+     */
+    getCurrentMemory() {
+        return this.snapshot();
+    }
+    /**
+     * Detect potential memory leaks
+     */
+    detectLeaks(thresholdBytesPerSecond = 1024 * 1024) {
+        if (this.snapshots.length < 2) {
+            return {
+                detected: false,
+                growthRate: 0,
+                threshold: thresholdBytesPerSecond,
+                snapshots: [],
+            };
+        }
+        const recent = this.snapshots.slice(-10); // Last 10 snapshots
+        const first = recent[0];
+        const last = recent[recent.length - 1];
+        const timeDelta = (last.timestamp - first.timestamp) / 1000; // seconds
+        const memoryDelta = last.heapUsed - first.heapUsed;
+        const growthRate = timeDelta > 0 ? memoryDelta / timeDelta : 0;
+        return {
+            detected: growthRate > thresholdBytesPerSecond,
+            growthRate,
+            threshold: thresholdBytesPerSecond,
+            snapshots: recent,
+        };
+    }
+    /**
+     * Get memory statistics
+     */
+    getStatistics() {
+        const current = this.getCurrentMemory();
+        const peak = this.snapshots.reduce((max, snap) => (snap.heapUsed > max.heapUsed ? snap : max), this.snapshots[0] || current);
+        const averages = this.snapshots.reduce((acc, snap) => ({
+            heapUsed: acc.heapUsed + snap.heapUsed,
+            heapTotal: acc.heapTotal + snap.heapTotal,
+            rss: acc.rss + snap.rss,
+        }), { heapUsed: 0, heapTotal: 0, rss: 0 });
+        const count = this.snapshots.length || 1;
+        return {
+            current,
+            peak: this.snapshots.length > 0 ? peak : null,
+            average: {
+                heapUsed: averages.heapUsed / count,
+                heapTotal: averages.heapTotal / count,
+                rss: averages.rss / count,
+            },
+        };
+    }
+    /**
+     * Clear snapshots
+     */
+    clear() {
+        this.snapshots = [];
+    }
+}

package/dist/performance/profiler.js

@@ -0,0 +1,130 @@
+/**
+ * Performance Profiler for BASETREE V5
+ * Hooks into Node performance APIs to measure runtime hotspots
+ */
+import { performance, PerformanceObserver } from 'perf_hooks';
+export class Profiler {
+    measurements = new Map();
+    observer = null;
+    constructor() {
+        this.setupObserver();
+    }
+    setupObserver() {
+        this.observer = new PerformanceObserver((list) => {
+            for (const entry of list.getEntries()) {
+                const name = entry.name;
+                const duration = entry.duration;
+                const startTime = entry.startTime;
+                if (!this.measurements.has(name)) {
+                    this.measurements.set(name, []);
+                }
+                this.measurements.get(name).push({
+                    name,
+                    duration,
+                    startTime,
+                    endTime: startTime + duration,
+                });
+            }
+        });
+        this.observer.observe({ entryTypes: ['measure', 'function'] });
+    }
+    /**
+     * Start a performance mark
+     */
+    mark(name) {
+        performance.mark(`${name}-start`);
+    }
+    /**
+     * End a performance mark and measure
+     */
+    measure(name, details) {
+        const startMark = `${name}-start`;
+        const endMark = `${name}-end`;
+        performance.mark(endMark);
+        performance.measure(name, startMark, endMark);
+        const entries = performance.getEntriesByName(name, 'measure');
+        const entry = entries[entries.length - 1];
+        const measurement = {
+            name,
+            duration: entry.duration,
+            startTime: entry.startTime,
+            endTime: entry.startTime + entry.duration,
+            details,
+        };
+        if (!this.measurements.has(name)) {
+            this.measurements.set(name, []);
+        }
+        this.measurements.get(name).push(measurement);
+        // Cleanup marks
+        performance.clearMarks(startMark);
+        performance.clearMarks(endMark);
+        performance.clearMeasures(name);
+        return measurement;
+    }
+    /**
+     * Measure async function execution
+     */
+    async measureAsync(name, fn, details) {
+        this.mark(name);
+        try {
+            const result = await fn();
+            this.measure(name, details);
+            return result;
+        }
+        catch (error) {
+            this.measure(name, { ...details, error: String(error) });
+            throw error;
+        }
+    }
+    /**
+     * Get measurements for a specific name
+     */
+    getMeasurements(name) {
+        return this.measurements.get(name) || [];
+    }
+    /**
+     * Get all measurements
+     */
+    getAllMeasurements() {
+        return new Map(this.measurements);
+    }
+    /**
+     * Get statistics for a measurement name
+     */
+    getStatistics(name) {
+        const measurements = this.getMeasurements(name);
+        if (measurements.length === 0) {
+            return null;
+        }
+        const durations = measurements.map((m) => m.duration);
+        const total = durations.reduce((sum, d) => sum + d, 0);
+        const average = total / durations.length;
+        const min = Math.min(...durations);
+        const max = Math.max(...durations);
+        return {
+            count: measurements.length,
+            total,
+            average,
+            min,
+            max,
+        };
+    }
+    /**
+     * Clear all measurements
+     */
+    clear() {
+        this.measurements.clear();
+        performance.clearMarks();
+        performance.clearMeasures();
+    }
+    /**
+     * Cleanup
+     */
+    destroy() {
+        if (this.observer) {
+            this.observer.disconnect();
+            this.observer = null;
+        }
+        this.clear();
+    }
+}

package/dist/pipelines/evolvePipeline.js

@@ -0,0 +1,150 @@
+/**
+ * Evolve Pipeline for BASETREE V5
+ * Orchestrates the full self-evolution cycle
+ */
+import { getKernel } from '../kernel/kernel.js';
+import { SystemIntrospectionAgent } from '../agents/systemIntrospectionAgent.js';
+import { UpgradePlannerAgent } from '../agents/upgradePlannerAgent.js';
+import { GovernanceOrchestrator } from '../agents/governanceOrchestrator.js';
+import { UpgradeExecutorAgent } from '../agents/upgradeExecutorAgent.js';
+import { RegressionAgent } from '../agents/regressionAgent.js';
+import { RollbackAgent } from '../agents/rollbackAgent.js';
+import { Snapshotter } from '../state/snapshotter.js';
+import { Sandbox } from '../safety/sandbox.js';
+import { MetricsCollector } from '../observability/metricsCollector.js';
+import { getConfig } from '../config/config.js';
+import chalk from 'chalk';
+import ora from 'ora';
+export class EvolvePipeline {
+    kernel = getKernel();
+    config = getConfig();
+    introspectionAgent = new SystemIntrospectionAgent();
+    plannerAgent = new UpgradePlannerAgent();
+    governanceOrchestrator = new GovernanceOrchestrator();
+    executorAgent = new UpgradeExecutorAgent();
+    regressionAgent = new RegressionAgent();
+    rollbackAgent = new RollbackAgent();
+    snapshotter = new Snapshotter();
+    metricsCollector = new MetricsCollector();
+    async run(options = {}) {
+        const startTime = Date.now();
+        try {
+            // Step 1: Snapshot current system state
+            const snapshotSpinner = ora('Creating system snapshot...').start();
+            const baselineSnapshot = await this.snapshotter.createSnapshot();
+            snapshotSpinner.succeed('System snapshot created');
+            // Step 2: Run System Introspection Agent
+            const introspectSpinner = ora('Running system introspection...').start();
+            const introspectionReport = await this.introspectionAgent.introspect();
+            introspectSpinner.succeed(`Introspection complete: ${introspectionReport.bottlenecks.length} bottlenecks found`);
+            // Step 3: Generate upgrade proposals
+            const planSpinner = ora('Generating upgrade proposals...').start();
+            let proposals = await this.plannerAgent.planUpgrades(introspectionReport);
+            planSpinner.succeed(`Generated ${proposals.length} upgrade proposal(s)`);
+            // Filter by proposalId if specified
+            if (options.proposalId) {
+                proposals = proposals.filter((p) => p.id === options.proposalId);
+                if (proposals.length === 0) {
+                    console.error(chalk.red(`Proposal ${options.proposalId} not found`));
+                    return;
+                }
+            }
+            if (proposals.length === 0) {
+                console.log(chalk.yellow('No upgrade proposals generated'));
+                return;
+            }
+            // Step 4: Governance review for each proposal
+            const approvedProposals = [];
+            for (const proposal of proposals) {
+                const governSpinner = ora(`Evaluating proposal: ${proposal.title}...`).start();
+                const verdict = await this.governanceOrchestrator.evaluate(proposal);
+                // Save proposal with governance decision
+                await this.kernel.getStateStore().saveProposal({
+                    ...proposal,
+                    governanceDecision: verdict.decision,
+                    governanceRationale: verdict.rationale,
+                });
+                if (verdict.decision === 'approve') {
+                    governSpinner.succeed(`Proposal approved: ${proposal.title}`);
+                    approvedProposals.push(proposal);
+                }
+                else {
+                    governSpinner.fail(`Proposal ${verdict.decision}: ${proposal.title} - ${verdict.rationale}`);
+                }
+            }
+            if (approvedProposals.length === 0) {
+                console.log(chalk.yellow('No proposals approved by governance'));
+                return;
+            }
+            if (options.dryRun) {
+                console.log(chalk.blue('\n🔍 DRY RUN MODE - No changes will be applied\n'));
+                for (const proposal of approvedProposals) {
+                    console.log(chalk.green(`Would apply: ${proposal.title}`));
+                    console.log(`  Changes: ${proposal.changes.length} file(s)`);
+                }
+                return;
+            }
+            // Step 5: Execute approved proposals in sandbox
+            for (const proposal of approvedProposals) {
+                const sandbox = new Sandbox();
+                try {
+                    const sandboxSpinner = ora('Creating sandbox...').start();
+                    const sandboxPath = await sandbox.create();
+                    sandboxSpinner.succeed('Sandbox created');
+                    // Execute upgrade
+                    const execSpinner = ora(`Applying upgrade: ${proposal.title}...`).start();
+                    const execResult = await this.executorAgent.execute(proposal, sandboxPath);
+                    if (execResult.success) {
+                        execSpinner.succeed(`Upgrade applied: ${execResult.changesApplied} change(s)`);
+                    }
+                    else {
+                        execSpinner.fail(`Upgrade failed: ${execResult.errors.join('; ')}`);
+                        await sandbox.cleanupOnFailure();
+                        continue;
+                    }
+                    // Step 6: Run regression tests
+                    const regressionSpinner = ora('Running regression tests...').start();
+                    const regressionResult = await this.regressionAgent.runRegression(sandboxPath, baselineSnapshot);
+                    if (!regressionResult.passed) {
+                        regressionSpinner.fail('Regression tests failed');
+                        console.log(chalk.red(`Test failures: ${regressionResult.testResults.failed}`));
+                        await sandbox.cleanupOnFailure();
+                        continue;
+                    }
+                    regressionSpinner.succeed('Regression tests passed');
+                    // Step 7: Apply upgrade to main workspace
+                    const applySpinner = ora('Applying upgrade to main workspace...').start();
+                    const mainResult = await this.executorAgent.execute(proposal, this.config.workspaceRoot);
+                    if (mainResult.success) {
+                        applySpinner.succeed('Upgrade applied successfully');
+                    }
+                    else {
+                        applySpinner.fail(`Failed to apply: ${mainResult.errors.join('; ')}`);
+                        // Trigger rollback
+                        const rollbackPoint = this.rollbackAgent.getLatestRollbackPoint();
+                        if (rollbackPoint) {
+                            await this.rollbackAgent.rollback(rollbackPoint.id, 'Application to main workspace failed');
+                        }
+                        await sandbox.cleanupOnFailure();
+                        continue;
+                    }
+                    // Cleanup sandbox
+                    await sandbox.cleanupOnSuccess();
+                    // Record metrics
+                    const duration = Date.now() - startTime;
+                    await this.metricsCollector.recordUpgradeOutcome(proposal.id, true, duration);
+                }
+                catch (error) {
+                    console.error(chalk.red(`Error processing proposal ${proposal.id}:`), error);
+                    await sandbox.cleanupOnFailure();
+                }
+            }
+            const totalDuration = Date.now() - startTime;
+            console.log(chalk.green(`\n✅ Evolution complete in ${totalDuration}ms`));
+        }
+        catch (error) {
+            console.error(chalk.red('Evolution pipeline failed:'), error);
+            throw error;
+        }
+    }
+}

package/dist/pipelines/governanceReviewPipeline.js

@@ -0,0 +1,68 @@
+/**
+ * Governance Review Pipeline for BASETREE V5
+ * Review queued proposals, generate governance decisions, output rationales
+ */
+import { GovernanceOrchestrator } from '../agents/governanceOrchestrator.js';
+import { getKernel } from '../kernel/kernel.js';
+import chalk from 'chalk';
+export class GovernanceReviewPipeline {
+    kernel = getKernel();
+    governanceOrchestrator = new GovernanceOrchestrator();
+    async run(options = {}) {
+        const stateStore = this.kernel.getStateStore();
+        let proposals;
+        if (options.proposalId) {
+            const proposal = await stateStore.getProposal(options.proposalId);
+            if (!proposal) {
+                console.error(chalk.red(`Proposal ${options.proposalId} not found`));
+                return;
+            }
+            proposals = [proposal];
+        }
+        else if (options.allPending) {
+            proposals = await stateStore.listProposals('pending');
+        }
+        else {
+            // Get latest pending proposals
+            proposals = await stateStore.listProposals('pending', 10);
+        }
+        if (proposals.length === 0) {
+            console.log(chalk.yellow('No proposals to review'));
+            return;
+        }
+        console.log(chalk.blue(`\n⚖️  Reviewing ${proposals.length} proposal(s)\n`));
+        for (const proposal of proposals) {
+            console.log(chalk.cyan(`Proposal: ${proposal.title}`));
+            console.log(chalk.gray(`  ID: ${proposal.id}`));
+            console.log(chalk.gray(`  Risk Level: ${proposal.riskLevel}`));
+            console.log(chalk.gray(`  Changes: ${proposal.changes.length} file(s)\n`));
+            const verdict = await this.governanceOrchestrator.evaluate(proposal);
+            // Update proposal
+            await stateStore.updateProposal(proposal.id, {
+                governanceDecision: verdict.decision,
+                governanceRationale: verdict.rationale,
+            });
+            // Display decision
+            const decisionColor = verdict.decision === 'approve'
+                ? chalk.green
+                : verdict.decision === 'reject'
+                    ? chalk.red
+                    : chalk.yellow;
+            console.log(decisionColor(`Decision: ${verdict.decision.toUpperCase()}`));
+            console.log(chalk.gray(`Rationale: ${verdict.rationale}\n`));
+            if (verdict.conditions && verdict.conditions.length > 0) {
+                console.log(chalk.yellow('Conditions:'));
+                for (const condition of verdict.conditions) {
+                    console.log(`  - ${condition}`);
+                }
+                console.log('');
+            }
+            // Display agent decisions
+            console.log(chalk.gray('Agent Evaluations:'));
+            console.log(`  Policy: ${verdict.agentDecisions.policy.filter((e) => e.passed).length}/${verdict.agentDecisions.policy.length} passed`);
+            console.log(`  Stability: ${(verdict.agentDecisions.stability.stabilityScore * 100).toFixed(0)}%`);
+            console.log(`  Alignment: ${(verdict.agentDecisions.alignment.alignmentScore * 100).toFixed(0)}%`);
+            console.log(`  Risk: ${verdict.agentDecisions.risk.riskLevel}\n`);
+        }
+    }
+}

package/dist/pipelines/introspectPipeline.js

@@ -0,0 +1,73 @@
+/**
+ * Introspect Pipeline for BASETREE V5
+ * Run introspection alone and print/save report
+ */
+import { SystemIntrospectionAgent } from '../agents/systemIntrospectionAgent.js';
+import { getKernel } from '../kernel/kernel.js';
+import chalk from 'chalk';
+export class IntrospectPipeline {
+    kernel = getKernel();
+    introspectionAgent = new SystemIntrospectionAgent();
+    async run(options = {}) {
+        const outputFormat = options.output || 'both';
+        const save = options.save || false;
+        try {
+            const report = await this.introspectionAgent.introspect();
+            if (save) {
+                // Save report to state store (simplified - would need report storage)
+                console.log(chalk.green('Report generated'));
+            }
+            if (outputFormat === 'json' || outputFormat === 'both') {
+                console.log(JSON.stringify(report, null, 2));
+            }
+            if (outputFormat === 'cli' || outputFormat === 'both') {
+                this.renderCLIReport(report);
+            }
+        }
+        catch (error) {
+            console.error(chalk.red('Introspection failed:'), error);
+            throw error;
+        }
+    }
+    renderCLIReport(report) {
+        console.log(chalk.blue('\n📊 System Introspection Report\n'));
+        console.log(chalk.gray(`Generated: ${report.timestamp.toISOString()}\n`));
+        // Metrics
+        console.log(chalk.yellow('Metrics:'));
+        console.log(`  Total Modules: ${report.metrics.totalModules}`);
+        console.log(`  Total LOC: ${report.metrics.totalLinesOfCode}`);
+        console.log(`  Avg Complexity: ${report.metrics.averageComplexity.toFixed(2)}`);
+        console.log(`  Max Complexity: ${report.metrics.maxComplexity}`);
+        console.log(`  Coupling Score: ${report.metrics.couplingScore.toFixed(2)}`);
+        console.log(`  Cohesion Score: ${report.metrics.cohesionScore.toFixed(2)}\n`);
+        // Bottlenecks
+        if (report.bottlenecks.length > 0) {
+            console.log(chalk.yellow(`Bottlenecks (${report.bottlenecks.length}):`));
+            for (const bottleneck of report.bottlenecks.slice(0, 10)) {
+                const severityColor = bottleneck.severity === 'critical'
+                    ? chalk.red
+                    : bottleneck.severity === 'high'
+                        ? chalk.yellow
+                        : chalk.gray;
+                console.log(`  ${severityColor(bottleneck.severity.toUpperCase())} ${bottleneck.type}: ${bottleneck.location.module}`);
+                console.log(`    ${bottleneck.description}`);
+            }
+            if (report.bottlenecks.length > 10) {
+                console.log(chalk.gray(`  ... and ${report.bottlenecks.length - 10} more`));
+            }
+            console.log('');
+        }
+        // Upgrade Proposals
+        if (report.upgradeProposals.length > 0) {
+            console.log(chalk.yellow(`Upgrade Proposals (${report.upgradeProposals.length}):`));
+            for (const proposal of report.upgradeProposals.slice(0, 5)) {
+                console.log(`  ${proposal.title}`);
+                console.log(`    Risk: ${proposal.riskLevel}`);
+                console.log(`    Changes: ${proposal.changes.length} file(s)`);
+            }
+            if (report.upgradeProposals.length > 5) {
+                console.log(chalk.gray(`  ... and ${report.upgradeProposals.length - 5} more`));
+            }
+        }
+    }
+}

package/dist/pipelines/venture/growPipeline.js

@@ -0,0 +1,51 @@
+/**
+ * Grow Pipeline for BASETREE V6
+ * Orchestrates growth experiments and optimization
+ */
+import { getKernel } from '../../kernel/kernel.js';
+import { GrowthAgent } from '../../agents/venture/growthAgent.js';
+import { ExperimentationEngine } from '../../experiments/experimentationEngine.js';
+import { GeminiProvider } from '../../core/ai/GeminiProvider.js';
+import chalk from 'chalk';
+import ora from 'ora';
+export class GrowPipeline {
+    kernel = getKernel();
+    ai = new GeminiProvider();
+    growthAgent = new GrowthAgent(this.ai);
+    experimentationEngine = new ExperimentationEngine();
+    async run(ventureId) {
+        const spinner = ora(`Growing venture ${ventureId}...`).start();
+        try {
+            const venture = await this.kernel.getStateStore().getVenture(ventureId);
+            if (!venture) {
+                throw new Error(`Venture ${ventureId} not found`);
+            }
+            // Design growth strategy
+            spinner.text = 'Designing growth strategy...';
+            const growthStrategy = await this.growthAgent.designGrowthStrategy(venture);
+            spinner.succeed('Growth strategy designed');
+            // Create growth experiments
+            spinner.text = 'Creating growth experiments...';
+            const seoKeywords = growthStrategy.seo.map((s) => s.keyword);
+            const landingExperiment = await this.experimentationEngine.createLandingPageExperiment(venture, seoKeywords.slice(0, 3));
+            spinner.succeed('Growth experiments created');
+            // Update venture stage
+            await this.kernel.getStateStore().updateVenture(ventureId, {
+                stage: 'growing',
+                experimentIds: [...venture.experimentIds, landingExperiment.id],
+            });
+            spinner.succeed('Growth pipeline initiated!');
+            console.log(chalk.green(`\nGrowth strategy for "${venture.idea}"`));
+            console.log(chalk.blue(`\nSEO Keywords: ${seoKeywords.slice(0, 5).join(', ')}`));
+            console.log(chalk.blue(`Funnels: ${growthStrategy.funnels.length}`));
+            console.log(chalk.blue(`Virality mechanisms: ${growthStrategy.virality.join(', ')}`));
+            console.log(chalk.blue(`\nNext steps:`));
+            console.log(chalk.blue(`1. Monitor growth metrics`));
+            console.log(chalk.blue(`2. Run: basetree monetize ${ventureId}`));
+        }
+        catch (error) {
+            spinner.fail(`Growth pipeline failed: ${error.message}`);
+            throw error;
+        }
+    }
+}