@vishal_20/basetree 1.0.0

package/dist/llm/tokenEfficiencyOptimizer.js

@@ -0,0 +1,91 @@
+/**
+ * Token Efficiency Optimizer for BASETREE V5
+ * Analyzes prompt/response lengths, compression strategies, and summarization heuristics
+ */
+export class TokenEfficiencyOptimizer {
+    usageHistory = [];
+    maxHistory = 1000;
+    /**
+     * Record token usage
+     */
+    recordUsage(usage) {
+        this.usageHistory.push({
+            ...usage,
+            timestamp: new Date(),
+        });
+        if (this.usageHistory.length > this.maxHistory) {
+            this.usageHistory.shift();
+        }
+    }
+    /**
+     * Estimate token count (rough approximation)
+     */
+    estimateTokens(text) {
+        // Rough approximation: ~4 characters per token
+        return Math.ceil(text.length / 4);
+    }
+    /**
+     * Analyze efficiency metrics
+     */
+    analyzeEfficiency(operation) {
+        const relevant = operation
+            ? this.usageHistory.filter((u) => u.operation === operation)
+            : this.usageHistory;
+        if (relevant.length === 0) {
+            return {
+                averagePromptLength: 0,
+                averageResponseLength: 0,
+                compressionRatio: 1,
+                efficiencyScore: 0,
+            };
+        }
+        const avgPrompt = relevant.reduce((sum, u) => sum + u.promptTokens, 0) / relevant.length;
+        const avgResponse = relevant.reduce((sum, u) => sum + u.responseTokens, 0) / relevant.length;
+        const avgTotal = relevant.reduce((sum, u) => sum + u.totalTokens, 0) / relevant.length;
+        // Compression ratio: how much response vs prompt
+        const compressionRatio = avgPrompt > 0 ? avgResponse / avgPrompt : 1;
+        // Efficiency score: inverse of total tokens (normalized)
+        // Lower total tokens = higher efficiency
+        const maxObserved = Math.max(...relevant.map((u) => u.totalTokens));
+        const efficiencyScore = maxObserved > 0 ? 1 - avgTotal / maxObserved : 1;
+        return {
+            averagePromptLength: avgPrompt,
+            averageResponseLength: avgResponse,
+            compressionRatio,
+            efficiencyScore,
+        };
+    }
+    /**
+     * Suggest optimizations
+     */
+    suggestOptimizations(operation) {
+        const metrics = this.analyzeEfficiency(operation);
+        const suggestions = [];
+        if (metrics.averagePromptLength > 10000) {
+            suggestions.push('Consider summarizing or chunking prompts to reduce token usage');
+        }
+        if (metrics.compressionRatio > 2) {
+            suggestions.push('Response length is significantly longer than prompts - consider response summarization');
+        }
+        if (metrics.efficiencyScore < 0.5) {
+            suggestions.push('Token efficiency is low - review prompt engineering strategies');
+        }
+        return suggestions;
+    }
+    /**
+     * Get usage history
+     */
+    getHistory(operation, limit) {
+        let history = operation
+            ? this.usageHistory.filter((u) => u.operation === operation)
+            : [...this.usageHistory];
+        history.sort((a, b) => b.timestamp.getTime() - a.timestamp.getTime());
+        return limit ? history.slice(0, limit) : history;
+    }
+    /**
+     * Clear history
+     */
+    clear() {
+        this.usageHistory = [];
+    }
+}

package/dist/memory/civilizationMemory.js

@@ -0,0 +1,147 @@
+/**
+ * Civilization Memory for BASETREE V7
+ * Cross-agent, cross-region long-term memory for civilization-level learning
+ */
+import { getKernel } from '../kernel/kernel.js';
+import { GlobalVectorMemory } from './globalVectorMemory.js';
+import { GeminiProvider } from '../core/ai/GeminiProvider.js';
+import { randomUUID } from 'crypto';
+export class CivilizationMemory {
+    kernel = getKernel();
+    vectorMemory;
+    ai;
+    constructor(vectorMemory) {
+        this.vectorMemory = vectorMemory || new GlobalVectorMemory();
+        this.ai = new GeminiProvider();
+    }
+    /**
+     * Record a civilization-level memory
+     */
+    async record(kind, title, content, options = {}) {
+        const record = {
+            id: randomUUID(),
+            kind,
+            title,
+            content,
+            agentId: options.agentId,
+            goalId: options.goalId,
+            regionId: options.regionId,
+            tags: options.tags || [],
+            createdAt: new Date(),
+        };
+        // Generate embedding for semantic search
+        try {
+            const embedding = await this.ai.getEmbeddings(`${title}\n${content}`);
+            record.embedding = embedding;
+            await this.vectorMemory.storeEmbedding(embedding, {
+                id: record.id,
+                text: content,
+                agentId: options.agentId,
+                goalId: options.goalId,
+                regionId: options.regionId,
+                tags: options.tags || [],
+            });
+        }
+        catch (error) {
+            console.warn('Failed to generate embedding:', error);
+        }
+        // Also save to state store (for structured queries)
+        await this.kernel.getStateStore().saveVentureMemory({
+            id: record.id,
+            ventureId: options.goalId,
+            kind: kind,
+            title,
+            details: content,
+            tags: options.tags || [],
+            createdAt: record.createdAt,
+        });
+        return record;
+    }
+    /**
+     * Search for similar memories
+     */
+    async search(query, kind, topK = 10) {
+        try {
+            // Generate query embedding
+            const queryEmbedding = await this.ai.getEmbeddings(query);
+            // Search vector memory
+            const filters = {};
+            if (kind) {
+                // Filter by kind via tags
+                filters.tags = kind;
+            }
+            const results = await this.vectorMemory.search(queryEmbedding, topK, filters);
+            // Convert to CivilizationMemoryRecord format
+            return results.map((r) => ({
+                id: r.metadata.id,
+                kind: r.metadata.tags?.[0] || 'culture_pattern',
+                title: r.metadata.text?.substring(0, 100) || 'Untitled',
+                content: r.metadata.text || '',
+                agentId: r.metadata.agentId,
+                goalId: r.metadata.goalId,
+                regionId: r.metadata.regionId,
+                tags: r.metadata.tags || [],
+                embedding: r.vector,
+                createdAt: r.metadata.timestamp,
+            }));
+        }
+        catch (error) {
+            console.warn('Vector search failed, falling back to text search:', error);
+            // Fallback to text-based search via state store
+            const records = await this.kernel.getStateStore().listVentureMemory({
+                kind: kind,
+                limit: topK,
+            });
+            return records.map((r) => ({
+                id: r.id,
+                kind: r.kind,
+                title: r.title,
+                content: r.details,
+                tags: r.tags,
+                createdAt: r.createdAt,
+            }));
+        }
+    }
+    /**
+     * Record culture pattern
+     */
+    async recordCulturePattern(title, content, tags = []) {
+        return this.record('culture_pattern', title, content, { tags });
+    }
+    /**
+     * Record ethical decision
+     */
+    async recordEthicalDecision(title, content, agentId) {
+        return this.record('ethical_decision', title, content, {
+            agentId,
+            tags: ['ethics', 'governance'],
+        });
+    }
+    /**
+     * Record policy change
+     */
+    async recordPolicyChange(title, content, agentId) {
+        return this.record('policy_change', title, content, {
+            agentId,
+            tags: ['policy', 'governance'],
+        });
+    }
+    /**
+     * Record scientific discovery
+     */
+    async recordScientificDiscovery(title, content, goalId) {
+        return this.record('scientific_discovery', title, content, {
+            goalId,
+            tags: ['science', 'discovery'],
+        });
+    }
+    /**
+     * Record incident report
+     */
+    async recordIncident(title, content, regionId) {
+        return this.record('incident_report', title, content, {
+            regionId,
+            tags: ['incident', 'safety'],
+        });
+    }
+}

package/dist/memory/globalVectorMemory.js

@@ -0,0 +1,87 @@
+/**
+ * Global Vector Memory for BASETREE V7
+ * Planet-scale vector memory abstraction for embeddings
+ */
+/**
+ * In-memory vector store (for dev)
+ * In production, would use Pinecone, FAISS, Qdrant, etc.
+ */
+export class InMemoryVectorStore {
+    vectors = new Map();
+    async store(vector, metadata) {
+        this.vectors.set(metadata.id, { vector, metadata });
+    }
+    async search(queryVector, topK, filters) {
+        const results = [];
+        for (const [id, { vector, metadata }] of this.vectors.entries()) {
+            // Apply filters
+            if (filters) {
+                let matches = true;
+                for (const [key, value] of Object.entries(filters)) {
+                    if (metadata[key] !== value) {
+                        matches = false;
+                        break;
+                    }
+                }
+                if (!matches)
+                    continue;
+            }
+            // Calculate cosine similarity
+            const similarity = this.cosineSimilarity(queryVector, vector);
+            results.push({
+                vector,
+                metadata,
+                similarity,
+            });
+        }
+        // Sort by similarity and return top K
+        results.sort((a, b) => b.similarity - a.similarity);
+        return results.slice(0, topK);
+    }
+    async delete(id) {
+        this.vectors.delete(id);
+    }
+    cosineSimilarity(a, b) {
+        if (a.length !== b.length) {
+            return 0;
+        }
+        let dotProduct = 0;
+        let normA = 0;
+        let normB = 0;
+        for (let i = 0; i < a.length; i++) {
+            dotProduct += a[i] * b[i];
+            normA += a[i] * a[i];
+            normB += b[i] * b[i];
+        }
+        const denominator = Math.sqrt(normA) * Math.sqrt(normB);
+        return denominator > 0 ? dotProduct / denominator : 0;
+    }
+}
+export class GlobalVectorMemory {
+    store;
+    constructor(store) {
+        this.store = store || new InMemoryVectorStore();
+    }
+    /**
+     * Store an embedding with metadata
+     */
+    async storeEmbedding(vector, metadata) {
+        const fullMetadata = {
+            ...metadata,
+            timestamp: new Date(),
+        };
+        await this.store.store(vector, fullMetadata);
+    }
+    /**
+     * Search for similar embeddings
+     */
+    async search(queryVector, topK = 10, filters) {
+        return this.store.search(queryVector, topK, filters);
+    }
+    /**
+     * Delete an embedding
+     */
+    async delete(id) {
+        await this.store.delete(id);
+    }
+}

package/dist/mesh/crossOrgProtocol.js

@@ -0,0 +1,110 @@
+/**
+ * Cross-Organization Protocol for BASETREE V7
+ * Coordination protocol for cross-organization collaboration
+ */
+export class CrossOrgProtocol {
+    proposals = new Map();
+    offers = new Map();
+    agreements = new Map();
+    disputes = new Map();
+    /**
+     * Create a proposal
+     */
+    createProposal(proposal) {
+        const id = `proposal_${Date.now()}_${Math.random().toString(36).substr(2, 9)}`;
+        const fullProposal = {
+            ...proposal,
+            id,
+            createdAt: new Date(),
+        };
+        this.proposals.set(id, fullProposal);
+        return fullProposal;
+    }
+    /**
+     * Create an offer in response to a proposal
+     */
+    createOffer(offer) {
+        const id = `offer_${Date.now()}_${Math.random().toString(36).substr(2, 9)}`;
+        const fullOffer = {
+            ...offer,
+            id,
+            createdAt: new Date(),
+        };
+        this.offers.set(id, fullOffer);
+        return fullOffer;
+    }
+    /**
+     * Create an agreement from proposal/offer
+     */
+    createAgreement(agreement) {
+        const id = `agreement_${Date.now()}_${Math.random().toString(36).substr(2, 9)}`;
+        const fullAgreement = {
+            ...agreement,
+            id,
+            status: 'pending',
+            createdAt: new Date(),
+        };
+        this.agreements.set(id, fullAgreement);
+        return fullAgreement;
+    }
+    /**
+     * Activate an agreement (CRDT-like: all parties must agree)
+     */
+    activateAgreement(agreementId, activatedBy) {
+        const agreement = this.agreements.get(agreementId);
+        if (!agreement) {
+            return false;
+        }
+        // Simple consensus: if all parties have activated (simplified)
+        if (agreement.status === 'pending') {
+            agreement.status = 'active';
+            agreement.activatedAt = new Date();
+            return true;
+        }
+        return false;
+    }
+    /**
+     * Raise a dispute
+     */
+    raiseDispute(dispute) {
+        const id = `dispute_${Date.now()}_${Math.random().toString(36).substr(2, 9)}`;
+        const fullDispute = {
+            ...dispute,
+            id,
+            createdAt: new Date(),
+        };
+        this.disputes.set(id, fullDispute);
+        // Mark agreement as disputed
+        const agreement = this.agreements.get(dispute.agreementId);
+        if (agreement) {
+            agreement.status = 'disputed';
+        }
+        return fullDispute;
+    }
+    /**
+     * Resolve a dispute
+     */
+    resolveDispute(disputeId, resolution) {
+        const dispute = this.disputes.get(disputeId);
+        if (dispute) {
+            dispute.resolution = resolution;
+            // Update agreement status based on resolution
+            const agreement = this.agreements.get(dispute.agreementId);
+            if (agreement) {
+                agreement.status = resolution.includes('cancel') ? 'cancelled' : 'active';
+            }
+        }
+    }
+    /**
+     * Get proposals for an org
+     */
+    getProposalsForOrg(orgId) {
+        return Array.from(this.proposals.values()).filter((p) => p.toOrg === orgId || p.fromOrg === orgId);
+    }
+    /**
+     * Get agreements for an org
+     */
+    getAgreementsForOrg(orgId) {
+        return Array.from(this.agreements.values()).filter((a) => a.parties.includes(orgId));
+    }
+}

package/dist/mesh/globalReasoningBus.js

@@ -0,0 +1,99 @@
+/**
+ * Global Reasoning Bus for BASETREE V7
+ * Multi-region reasoning mesh connecting regional buses
+ */
+import { ReasoningBus } from '../core/swarm/ReasoningBus.js';
+import { getEventBus } from '../kernel/eventBus.js';
+/**
+ * In-process message broker (for dev/K8s-ready)
+ */
+class InProcessMessageBroker {
+    subscriptions = new Map();
+    async publish(topic, payload) {
+        const handlers = this.subscriptions.get(topic);
+        if (handlers) {
+            for (const handler of handlers) {
+                try {
+                    await Promise.resolve(handler(payload));
+                }
+                catch (error) {
+                    console.error(`Error in handler for topic ${topic}:`, error);
+                }
+            }
+        }
+        // Also publish to wildcard subscribers
+        const wildcardHandlers = this.subscriptions.get('*');
+        if (wildcardHandlers) {
+            for (const handler of wildcardHandlers) {
+                try {
+                    await Promise.resolve(handler({ topic, payload }));
+                }
+                catch (error) {
+                    console.error(`Error in wildcard handler:`, error);
+                }
+            }
+        }
+    }
+    subscribe(topic, handler) {
+        if (!this.subscriptions.has(topic)) {
+            this.subscriptions.set(topic, new Set());
+        }
+        this.subscriptions.get(topic).add(handler);
+        return () => {
+            const handlers = this.subscriptions.get(topic);
+            if (handlers) {
+                handlers.delete(handler);
+            }
+        };
+    }
+}
+export class GlobalReasoningBus {
+    broker;
+    regionalBus;
+    eventBus = getEventBus();
+    constructor(broker) {
+        this.broker = broker || new InProcessMessageBroker();
+        this.regionalBus = ReasoningBus.getInstance();
+    }
+    /**
+     * Publish to global topic
+     */
+    async publish(topic, payload) {
+        // Publish to broker
+        await this.broker.publish(topic, payload);
+        // Also emit to local event bus
+        await this.eventBus.emit({
+            type: 'ProposalCreated', // Generic event type
+            timestamp: new Date(),
+            metadata: { topic, payload },
+        });
+    }
+    /**
+     * Subscribe to global topic
+     */
+    subscribe(topic, handler) {
+        return this.broker.subscribe(topic, handler);
+    }
+    /**
+     * Subscribe to regional events and forward to global mesh
+     */
+    connectRegionalBus() {
+        this.regionalBus.subscribe((event) => {
+            // Forward regional events to global topics
+            const topic = `region.${event.role || 'unknown'}`;
+            this.publish(topic, event).catch(console.error);
+        });
+    }
+    /**
+     * Initialize and connect regional bus
+     */
+    async initialize() {
+        this.connectRegionalBus();
+    }
+    /**
+     * Get underlying broker (for extensibility)
+     */
+    getBroker() {
+        return this.broker;
+    }
+}

package/dist/observability/businessDashboard.js

@@ -0,0 +1,103 @@
+/**
+ * Business Dashboard for BASETREE V6
+ * Renders business metrics in CLI format
+ */
+import chalk from 'chalk';
+import { BusinessMetricsCalculator } from './businessMetrics.js';
+import { getKernel } from '../kernel/kernel.js';
+export class BusinessDashboard {
+    metricsCalculator = new BusinessMetricsCalculator();
+    kernel = getKernel();
+    async render(ventureId) {
+        if (ventureId) {
+            await this.renderVentureDashboard(ventureId);
+        }
+        else {
+            await this.renderOverview();
+        }
+    }
+    async renderVentureDashboard(ventureId) {
+        const venture = await this.kernel.getStateStore().getVenture(ventureId);
+        if (!venture) {
+            console.log(chalk.red(`Venture ${ventureId} not found`));
+            return;
+        }
+        console.log(chalk.blue(`\n📊 Business Dashboard: ${venture.idea}\n`));
+        console.log(chalk.gray(`Venture ID: ${venture.id}`));
+        console.log(chalk.gray(`Stage: ${venture.stage}`));
+        console.log(chalk.gray(`Created: ${venture.createdAt.toLocaleDateString()}\n`));
+        // MRR
+        const mrr = await this.metricsCalculator.calculateMRR(ventureId);
+        console.log(chalk.yellow('💰 Revenue Metrics:'));
+        console.log(`  MRR: $${mrr.toLocaleString()}`);
+        // CAC/LTV
+        const { cac, ltv, ratio } = await this.metricsCalculator.calculateCACLTV(ventureId);
+        console.log(`  CAC: $${cac.toLocaleString()}`);
+        console.log(`  LTV: $${ltv.toLocaleString()}`);
+        console.log(`  LTV/CAC Ratio: ${ratio.toFixed(2)}`);
+        if (ratio >= 3) {
+            console.log(chalk.green('  ✅ Healthy ratio (≥3)'));
+        }
+        else if (ratio >= 1) {
+            console.log(chalk.yellow('  ⚠️  Ratio below ideal (≥3 recommended)'));
+        }
+        else {
+            console.log(chalk.red('  ❌ Unhealthy ratio (<1)'));
+        }
+        // Retention
+        const retention = await this.metricsCalculator.calculateRetention(ventureId);
+        console.log(`\n${chalk.yellow('👥 User Metrics:')}`);
+        console.log(`  Retention Rate: ${(retention * 100).toFixed(1)}%`);
+        console.log(`  Activation Rate: ${(venture.metrics.activationRate * 100).toFixed(1)}%`);
+        // Growth
+        const growthVelocity = await this.metricsCalculator.calculateGrowthVelocity(ventureId);
+        console.log(`\n${chalk.yellow('📈 Growth Metrics:')}`);
+        console.log(`  Growth Rate: ${(growthVelocity * 100).toFixed(1)}%`);
+        // Activation Funnel
+        const funnel = await this.metricsCalculator.analyzeActivationFunnel(ventureId);
+        console.log(`\n${chalk.yellow('🔄 Activation Funnel:')}`);
+        console.log(`  Visitors: ${funnel.visitors.toLocaleString()}`);
+        console.log(`  Signups: ${funnel.signups.toLocaleString()} (${funnel.visitors > 0 ? ((funnel.signups / funnel.visitors) * 100).toFixed(1) : 0}%)`);
+        console.log(`  Conversions: ${funnel.conversions.toLocaleString()} (${funnel.signups > 0 ? ((funnel.conversions / funnel.signups) * 100).toFixed(1) : 0}%)`);
+        console.log(`  Activated: ${funnel.activated.toLocaleString()}`);
+        // Experiments
+        const experimentStats = await this.metricsCalculator.calculateExperimentSuccessRate(ventureId);
+        console.log(`\n${chalk.yellow('🧪 Experiments:')}`);
+        console.log(`  Total: ${experimentStats.total}`);
+        console.log(`  Completed: ${experimentStats.completed}`);
+        console.log(`  Success Rate: ${(experimentStats.successRate * 100).toFixed(1)}%`);
+        if (experimentStats.winners.length > 0) {
+            console.log(`\n  Winners:`);
+            for (const winner of experimentStats.winners.slice(0, 5)) {
+                console.log(`    - ${winner.experimentId}: ${winner.winner}`);
+            }
+        }
+        console.log('');
+    }
+    async renderOverview() {
+        const ventures = await this.kernel.getStateStore().listVentures();
+        console.log(chalk.blue(`\n📊 Business Overview\n`));
+        console.log(chalk.gray(`Total Ventures: ${ventures.length}\n`));
+        if (ventures.length === 0) {
+            console.log(chalk.yellow('No ventures found. Create one with: basetree startup <idea>'));
+            return;
+        }
+        // Group by stage
+        const byStage = {};
+        let totalMRR = 0;
+        for (const venture of ventures) {
+            byStage[venture.stage] = (byStage[venture.stage] || 0) + 1;
+            totalMRR += venture.metrics.mrr;
+        }
+        console.log(chalk.yellow('By Stage:'));
+        for (const [stage, count] of Object.entries(byStage)) {
+            console.log(`  ${stage}: ${count}`);
+        }
+        console.log(`\n${chalk.yellow('Total MRR:')} $${totalMRR.toLocaleString()}`);
+        console.log(`\n${chalk.yellow('Recent Ventures:')}`);
+        for (const venture of ventures.slice(0, 5)) {
+            console.log(`  ${venture.idea} (${venture.stage}) - MRR: $${venture.metrics.mrr.toLocaleString()}`);
+        }
+        console.log('');
+    }
+}