@vishal_20/basetree 1.0.0

package/.env.example

@@ -0,0 +1,10 @@
+# Required: your Gemini API key (get one at https://aistudio.google.com/apikey)
+GEMINI_API_KEY=AIzaSyCKZLHXtSXgfwv8mDWa9aAub1fVD0Km9yY
+
+# Optional: model for chat/generation. If empty or unset, ListModels is called
+# and an available default (e.g. gemini-2.0-flash, gemini-1.5-flash) is used.
+# Embedding model is also chosen from ListModels when not specified.
+# GEMINI_MODEL=
+
+BASE_DIRECTORY=.
+DEBUG=false

package/README.md

@@ -0,0 +1,369 @@
+# 🌳 BASETREE V6: Autonomous Startup Builder Intelligence
+
+BASETREE V6 extends V5's self-evolution capabilities into a full-stack autonomous venture creation system. It can ideate, validate, build, launch, grow, and monetize startups autonomously.
+
+**BASETREE is no longer just building software — it now builds companies.**
+
+## 🚀 V6: Autonomous Startup Builder
+
+### Venture Intelligence Layer
+- **Ideation Agent**: Generates startup ideas based on market gaps
+- **Market Research Agent**: Competitive analysis, TAM/SAM/SOM estimation
+- **Validation Agent**: Landing pages, surveys, A/B testing
+- **Business Model Agent**: Pricing, monetization, unit economics
+- **Product Agent**: MVP definition & roadmap
+- **Growth Agent**: SEO, funnels, virality loops
+- **Revenue Agent**: Monetization experiments
+- **Legal Agent**: Compliance, privacy, ToS generation
+- **Investor Agent**: Pitch decks, financial projections
+
+### Autonomous Venture Loop
+The complete startup lifecycle:
+1. **Ideation**: Generate and refine startup ideas
+2. **Market Research**: Analyze market size and competition
+3. **Validation**: Create landing pages and run experiments
+4. **MVP Build**: Define and build minimum viable product
+5. **Launch**: Deploy and go live
+6. **Growth**: Run growth experiments and optimize
+7. **Monetization**: Test pricing and revenue models
+8. **Evolution**: Continuous iteration and learning
+
+### Venture Memory System
+- Stores market patterns across ventures
+- Records failure lessons for future reference
+- Captures successful traction models
+- Enables cross-venture learning
+
+### Experimentation Engine
+- Landing page generation with A/B testing
+- Pricing elasticity experiments
+- Feature gate testing
+- Conversion funnel optimization
+
+### Business Observability
+- **MRR Tracking**: Monthly recurring revenue
+- **CAC/LTV Analysis**: Customer acquisition cost and lifetime value
+- **Retention Metrics**: User retention tracking
+- **Activation Funnels**: Conversion funnel analysis
+- **Growth Velocity**: Growth rate tracking
+- **Experiment Success Rates**: A/B test outcomes
+
+## 📖 V6 Usage
+
+### Create a New Venture
+```bash
+basetree startup "AI tutor for rural students"
+```
+
+This will:
+1. Generate a structured startup idea
+2. Research the market (TAM/SAM/SOM)
+3. Design business model and pricing
+4. Define MVP features
+5. Create validation experiments
+6. Set up venture structure
+
+### Validate Your Venture
+```bash
+basetree validate <venture-id>
+```
+
+Creates landing page variants and validation experiments.
+
+### Launch Your Venture
+```bash
+basetree launch <venture-id>
+```
+
+Builds and deploys the MVP.
+
+### Grow Your Venture
+```bash
+basetree grow <venture-id>
+```
+
+Runs growth experiments, SEO optimization, and funnel design.
+
+### Monetize Your Venture
+```bash
+basetree monetize <venture-id>
+```
+
+Tests pricing models and optimizes revenue.
+
+### View Business Metrics
+```bash
+basetree metrics --venture <venture-id>
+```
+
+Shows MRR, CAC/LTV, retention, funnels, and experiment results.
+
+### Shutdown a Venture
+```bash
+basetree shutdown <venture-id> --reason "Market conditions"
+```
+
+Gracefully shuts down and records lessons learned.
+
+---
+
+## 🧬 V5: Self-Architecting Engineering Intelligence
+
+BASETREE V5 is a self-evolving engineering intelligence system that can design, evolve, refactor, and optimize its own internal architecture, reasoning systems, and execution strategies autonomously.
+
+**BASETREE V5 builds and evolves itself.**
+
+## 🧬 Core Features
+
+### Self-Architecture Engine
+- **System Introspection Agent**: Analyzes BASETREE's internal modules, agent flows, performance bottlenecks
+- **Upgrade Proposals**: Generates architectural upgrade proposals based on introspection
+- **Self-Modification**: Can propose and implement PRs to its own codebase
+
+### Continuous Self-Refactoring
+- **Automatic Code Quality Audits**: ESLint/TypeScript integration, cyclomatic complexity checks
+- **Performance Profiling**: Runtime hotspot detection, memory leak detection
+- **Token Efficiency Tuning**: Analyzes and optimizes LLM token usage
+
+### Meta-Agent Governance
+- **Policy Agent**: Enforces high-level policies (kernel protection, risk thresholds)
+- **Stability Agent**: Ensures system stability (blast radius, dependency analysis)
+- **Alignment Agent**: Checks alignment with project objectives and safety constraints
+- **Risk Evaluation Agent**: Assigns risk scores based on impact, uncertainty, historical failures
+- **Governance Orchestrator**: Coordinates all governance agents for final decisions
+
+### Self-Safety Framework
+- **Immutable Core Kernel**: Protected kernel modules cannot be modified
+- **Sandboxed Execution**: All upgrades run in isolated sandbox workspaces
+- **Cryptographic Integrity**: Hash-based verification of code changes
+- **Rollback System**: Automatic rollback on regression failures
+
+### Cognitive Evolution Layer
+- **Reasoning Optimizer**: Adjusts reasoning depth and strategies based on performance
+- **Strategy Mutation**: A/B testing of execution strategies
+- **Prompt Genome**: Evolves prompt templates using reinforcement learning
+- **Reinforcement Learner**: Learns from execution outcomes to improve decisions
+
+### Self-Observability Plane
+- **Cognitive Drift Metrics**: Tracks architectural changes over time
+- **Architectural Entropy**: Measures system complexity and organization
+- **Learning Velocity**: Tracks improvement rate and success trends
+- **Failure Surface Mapping**: Identifies failure hotspots and patterns
+
+## 🚀 Installation
+
+1. Clone the repository:
+   ```bash
+   git clone <repo-url>
+   cd Basetree
+   ```
+
+2. Install dependencies:
+   ```bash
+   npm install
+   ```
+
+3. Build the project:
+   ```bash
+   npm run build
+   ```
+
+### Install as global CLI (npm)
+
+Once published to npm, you (or other users) can install BASETREE as a global CLI:
+
+```bash
+npm install -g basetree    # or your final npm package name
+basetree --help
+basetree chat
+basetree ui
+```
+
+## 📖 Usage
+
+### Self-Evolution Pipeline
+
+Run the full self-evolution cycle:
+```bash
+npm run evolve
+# or
+basetree evolve
+```
+
+This will:
+1. Snapshot current system state
+2. Run system introspection
+3. Generate upgrade proposals
+4. Evaluate proposals through governance
+5. Apply approved upgrades in sandbox
+6. Run regression tests
+7. Apply to main workspace if tests pass
+
+### Dry Run Mode
+
+See what would be done without applying changes:
+```bash
+basetree evolve --dry-run
+```
+
+### System Introspection
+
+Run introspection alone to see system analysis:
+```bash
+basetree introspect
+# or with JSON output
+basetree introspect --output json
+```
+
+### Governance Review
+
+Review and evaluate proposals:
+```bash
+# Review all pending proposals
+basetree govern --all-pending
+
+# Review specific proposal
+basetree govern --proposal-id <id>
+```
+
+### Metrics Dashboard
+
+View observability metrics:
+```bash
+basetree metrics
+# or JSON format
+basetree metrics --format json
+```
+
+## 🏗️ Architecture
+
+### V6 Venture Structure
+
+Each venture is a self-contained project in `ventures/<slug>/`:
+```
+ventures/
+  <slug>/
+    package.json          # Project dependencies
+    src/                  # Source code
+    landing/              # Landing page variants
+    experiments/          # Experiment configs
+    README.md             # Venture documentation
+```
+
+### Core Components
+
+- **Kernel**: Immutable core runtime with event bus, agent registry, state store
+- **Event Bus**: Typed event system for system-wide communication
+- **State Store**: Versioned storage for snapshots, proposals, runs, metrics, ventures, experiments
+- **Safety Layer**: Sandbox, kernel guard, integrity checker, rollback manager
+- **Venture Memory**: Cross-venture learning and pattern storage
+
+### Agents
+
+- **System Introspection Agent**: Analyzes codebase architecture
+- **Governance Agents**: Policy, Stability, Alignment, Risk evaluation
+- **Upgrade Agents**: Planner and Executor for implementing changes
+- **Regression Agent**: Runs tests and validates upgrades
+- **Cognitive Evolution Agents**: Reasoning optimizer, strategy mutation, prompt genome, RL learner
+
+### Pipelines
+
+- **Evolve Pipeline**: Full self-evolution cycle
+- **Introspect Pipeline**: System analysis and reporting
+- **Governance Review Pipeline**: Proposal evaluation
+
+## 🛡️ Safety Guarantees
+
+1. **Kernel Protection**: Core kernel modules are immutable and cannot be modified
+2. **Sandboxed Execution**: All upgrades run in isolated workspaces
+3. **Governance Approval**: All changes require approval from meta-agents
+4. **Regression Testing**: Full test suite runs before applying changes
+5. **Automatic Rollback**: Failed upgrades are automatically rolled back
+6. **Integrity Verification**: Cryptographic hashes verify code integrity
+
+## 📊 Observability
+
+BASETREE V5 provides comprehensive observability:
+
+- **Cognitive Drift**: Track how architecture evolves over time
+- **Architectural Entropy**: Measure system complexity and organization
+- **Learning Velocity**: Monitor improvement rate and success trends
+- **Failure Surface**: Identify failure hotspots and common patterns
+- **Metrics Dashboard**: Real-time metrics on all system operations
+
+## 🔧 Configuration
+
+Create `basetree-v5.config.json` in your workspace root:
+
+```json
+{
+  "safety": {
+    "kernelGuardEnabled": true,
+    "protectedPaths": ["src/kernel", "src/safety"],
+    "maxRiskLevel": "medium",
+    "requireGovernanceApproval": true
+  },
+  "thresholds": {
+    "maxComplexity": 50,
+    "maxBlastRadius": 10,
+    "maxRiskScore": 0.7,
+    "minStabilityScore": 0.6,
+    "minAlignmentScore": 0.7
+  }
+}
+```
+
+## 🧪 Testing
+
+Run the test suite:
+```bash
+npm test
+```
+
+## 📝 Development
+
+### Project Structure
+
+```
+src/
+├── agents/          # All agent implementations
+├── kernel/          # Core kernel and event bus
+├── safety/          # Safety framework
+├── state/           # State store and snapshotter
+├── pipelines/       # Pipeline implementations
+├── observability/   # Metrics and reporting
+├── quality/         # Code quality analyzers
+├── performance/     # Performance profilers
+├── llm/             # LLM optimization
+├── types/           # TypeScript type definitions
+├── config/          # Configuration loader
+├── cli.ts           # CLI interface
+├── bootstrap.ts     # System bootstrap
+└── index.ts         # Main entry point
+```
+
+## 🎯 How It Works
+
+1. **Introspection**: System analyzes its own codebase, identifying bottlenecks and improvement opportunities
+2. **Proposal Generation**: Creates structured upgrade proposals with risk assessments
+3. **Governance Review**: Meta-agents evaluate proposals for safety, stability, alignment, and risk
+4. **Sandboxed Execution**: Approved proposals are applied in isolated sandbox workspaces
+5. **Regression Testing**: Full test suite validates that upgrades don't break functionality
+6. **Safe Application**: If tests pass, upgrades are applied to main workspace
+7. **Rollback on Failure**: Any failures trigger automatic rollback to previous state
+8. **Learning**: System learns from outcomes to improve future proposals
+
+## 🔮 Future Enhancements
+
+- Web-based dashboard for observability metrics
+- Integration with external LLM providers for code generation
+- Advanced AST-based code transformations
+- Multi-agent collaboration for complex refactorings
+- Continuous monitoring and auto-evolution
+
+---
+
+Built with ❤️ by the BASETREE team
+
+**Version**: 6.0.0  
+**Status**: Self-Evolving 🧬 | Building Companies 🚀

package/dist/agents/alignmentAgent.js

@@ -0,0 +1,68 @@
+/**
+ * Alignment Agent for BASETREE V5
+ * Checks that proposals align with project objectives and safety constraints
+ */
+import { getConfig } from '../config/config.js';
+import { KernelGuard } from '../safety/kernelGuard.js';
+export class AlignmentAgent {
+    config = getConfig();
+    kernelGuard = new KernelGuard();
+    /**
+     * Evaluate alignment of a proposal
+     */
+    async evaluate(proposal) {
+        const constraints = [];
+        // Check kernel protection alignment
+        const kernelCheck = this.kernelGuard.checkProposal(proposal);
+        constraints.push({
+            name: 'kernel_protection',
+            passed: kernelCheck.allowed,
+            message: kernelCheck.allowed
+                ? 'Proposal respects kernel protection boundaries'
+                : kernelCheck.reason || 'Kernel protection violation',
+        });
+        // Check risk level alignment
+        const riskOrder = {
+            safe: 0,
+            low: 1,
+            medium: 2,
+            high: 3,
+            critical: 4,
+        };
+        const proposalRisk = riskOrder[proposal.riskLevel] || 0;
+        const maxRisk = riskOrder[this.config.safety.maxRiskLevel] || 2;
+        constraints.push({
+            name: 'risk_threshold',
+            passed: proposalRisk <= maxRisk,
+            message: proposalRisk <= maxRisk
+                ? `Risk level ${proposal.riskLevel} is within acceptable range`
+                : `Risk level ${proposal.riskLevel} exceeds maximum ${this.config.safety.maxRiskLevel}`,
+        });
+        // Check that proposal has clear objectives
+        constraints.push({
+            name: 'clear_objectives',
+            passed: proposal.description.length > 20 && proposal.title.length > 5,
+            message: proposal.description.length > 20 && proposal.title.length > 5
+                ? 'Proposal has clear objectives'
+                : 'Proposal lacks clear objectives',
+        });
+        // Check safety compliance
+        const safetyCompliant = constraints.every((c) => c.name === 'kernel_protection' || c.passed);
+        const alignsWithObjectives = constraints.filter((c) => c.passed).length >= constraints.length * 0.7;
+        // Calculate alignment score
+        const passedConstraints = constraints.filter((c) => c.passed).length;
+        const alignmentScore = constraints.length > 0 ? passedConstraints / constraints.length : 0;
+        return {
+            alignsWithObjectives,
+            safetyCompliant,
+            constraints,
+            alignmentScore,
+        };
+    }
+    /**
+     * Get agent ID
+     */
+    getId() {
+        return 'alignment-agent';
+    }
+}

package/dist/agents/governanceOrchestrator.js

@@ -0,0 +1,152 @@
+/**
+ * Governance Orchestrator for BASETREE V5
+ * Orchestrates meta-agents to produce final governance decision
+ */
+import { GovernanceDecision } from '../types/core.js';
+import { PolicyAgent } from './policyAgent.js';
+import { StabilityAgent } from './stabilityAgent.js';
+import { AlignmentAgent } from './alignmentAgent.js';
+import { RiskEvaluationAgent } from './riskEvaluationAgent.js';
+import { getKernel } from '../kernel/kernel.js';
+import { getEventBus } from '../kernel/eventBus.js';
+import { getConfig } from '../config/config.js';
+export class GovernanceOrchestrator {
+    policyAgent;
+    stabilityAgent;
+    alignmentAgent;
+    riskAgent;
+    kernel = getKernel();
+    eventBus = getEventBus();
+    config = getConfig();
+    constructor() {
+        this.policyAgent = new PolicyAgent();
+        this.stabilityAgent = new StabilityAgent();
+        this.alignmentAgent = new AlignmentAgent();
+        this.riskAgent = new RiskEvaluationAgent();
+    }
+    /**
+     * Evaluate proposal through all governance agents
+     */
+    async evaluate(proposal) {
+        // Run all agents in parallel
+        const [policyResult, stabilityCheck, alignmentCheck, riskAssessment] = await Promise.all([
+            this.policyAgent.isAllowed(proposal),
+            this.stabilityAgent.evaluate(proposal),
+            this.alignmentAgent.evaluate(proposal),
+            this.riskAgent.evaluate(proposal),
+        ]);
+        // Determine decision
+        const decision = this.makeDecision({
+            policyResult,
+            stabilityCheck,
+            alignmentCheck,
+            riskAssessment,
+        });
+        // Generate rationale
+        const rationale = this.generateRationale({
+            policyResult,
+            stabilityCheck,
+            alignmentCheck,
+            riskAssessment,
+            decision,
+        });
+        // Check for conditions
+        const conditions = this.extractConditions({
+            policyResult,
+            stabilityCheck,
+            alignmentCheck,
+            riskAssessment,
+            decision,
+        });
+        const verdict = {
+            decision,
+            rationale,
+            agentDecisions: {
+                policy: policyResult.evaluations,
+                stability: stabilityCheck,
+                alignment: alignmentCheck,
+                risk: riskAssessment,
+            },
+            conditions: conditions.length > 0 ? conditions : undefined,
+            timestamp: new Date(),
+        };
+        // Emit event
+        await this.eventBus.emit({
+            type: 'GovernanceDecision',
+            timestamp: verdict.timestamp,
+            proposalId: proposal.id,
+            decision,
+        });
+        return verdict;
+    }
+    makeDecision(context) {
+        // Block if policy violations
+        if (!context.policyResult.allowed) {
+            const blockingViolations = context.policyResult.evaluations.filter((e) => !e.passed && (e.severity === 'block' || e.severity === 'error'));
+            if (blockingViolations.length > 0) {
+                return GovernanceDecision.REJECT;
+            }
+        }
+        // Check stability threshold
+        if (context.stabilityCheck.stabilityScore < this.config.thresholds.minStabilityScore) {
+            return GovernanceDecision.NEEDS_REVISION;
+        }
+        // Check alignment threshold
+        if (context.alignmentCheck.alignmentScore < this.config.thresholds.minAlignmentScore) {
+            return GovernanceDecision.NEEDS_REVISION;
+        }
+        // Check risk threshold
+        if (context.riskAssessment.riskScore > this.config.thresholds.maxRiskScore) {
+            return GovernanceDecision.NEEDS_REVISION;
+        }
+        // Check if risk level exceeds config
+        const riskOrder = {
+            safe: 0,
+            low: 1,
+            medium: 2,
+            high: 3,
+            critical: 4,
+        };
+        const proposalRisk = riskOrder[context.riskAssessment.riskLevel] || 0;
+        const maxRisk = riskOrder[this.config.safety.maxRiskLevel] || 2;
+        if (proposalRisk > maxRisk) {
+            return GovernanceDecision.REJECT;
+        }
+        // All checks passed
+        return GovernanceDecision.APPROVE;
+    }
+    generateRationale(context) {
+        const parts = [];
+        parts.push(`Decision: ${context.decision}`);
+        if (!context.policyResult.allowed) {
+            const violations = context.policyResult.evaluations.filter((e) => !e.passed);
+            parts.push(`Policy violations: ${violations.length} issue(s) found`);
+        }
+        else {
+            parts.push('Policy checks passed');
+        }
+        parts.push(`Stability score: ${(context.stabilityCheck.stabilityScore * 100).toFixed(0)}% (blast radius: ${context.stabilityCheck.blastRadius})`);
+        parts.push(`Alignment score: ${(context.alignmentCheck.alignmentScore * 100).toFixed(0)}%`);
+        parts.push(`Risk assessment: ${context.riskAssessment.riskLevel} (score: ${(context.riskAssessment.riskScore * 100).toFixed(0)}%)`);
+        return parts.join('. ');
+    }
+    extractConditions(context) {
+        const conditions = [];
+        if (context.decision === GovernanceDecision.APPROVE) {
+            // Add conditions for approval
+            if (context.stabilityCheck.stabilityScore < 0.8) {
+                conditions.push('Monitor stability metrics closely after deployment');
+            }
+            if (context.riskAssessment.riskScore > 0.5) {
+                conditions.push('Require additional testing before production deployment');
+            }
+        }
+        return conditions;
+    }
+    /**
+     * Get agent ID
+     */
+    getId() {
+        return 'governance-orchestrator';
+    }
+}

package/dist/agents/planet/climateAgent.js

@@ -0,0 +1,39 @@
+/**
+ * Climate Agent for BASETREE V7
+ * Handles climate-related simulations and optimization tasks
+ */
+import { getKernel } from '../../kernel/kernel.js';
+export class ClimateAgent {
+    id = 'climate-agent';
+    name = 'Climate Agent';
+    kernel = getKernel();
+    async handleGlobalEvent(event) {
+        // Monitor climate-related events
+        if (event.type.includes('climate') || event.type.includes('carbon')) {
+            await this.processClimateEvent(event);
+        }
+    }
+    async handleGoal(goal) {
+        // Check carbon constraints
+        if (goal.constraints.maxCarbon) {
+            // Validate carbon budget
+            return {
+                accepted: true,
+                reasoning: `Carbon constraint: ${goal.constraints.maxCarbon}kg CO2 maximum`,
+            };
+        }
+        return {
+            accepted: true,
+            reasoning: 'Climate agent will optimize for low-carbon execution',
+        };
+    }
+    async processClimateEvent(event) {
+        // Process climate events (carbon usage, optimization opportunities)
+    }
+    async initialize() {
+        // Initialize climate models
+    }
+    async shutdown() {
+        // Save climate data
+    }
+}

package/dist/agents/planet/diplomacyAgent.js

@@ -0,0 +1,52 @@
+/**
+ * Diplomacy Agent for BASETREE V7
+ * Handles cross-org negotiation using crossOrgProtocol
+ */
+import { getKernel } from '../../kernel/kernel.js';
+import { CrossOrgProtocol } from '../../mesh/crossOrgProtocol.js';
+export class DiplomacyAgent {
+    id = 'diplomacy-agent';
+    name = 'Diplomacy Agent';
+    kernel = getKernel();
+    crossOrgProtocol = new CrossOrgProtocol();
+    async handleGlobalEvent(event) {
+        // Monitor for cross-org events
+        if (event.type.includes('proposal') || event.type.includes('agreement')) {
+            await this.processDiplomaticEvent(event);
+        }
+    }
+    async handleGoal(goal) {
+        // If goal involves multiple orgs, coordinate negotiation
+        if (goal.orgId) {
+            // Check if goal requires cross-org collaboration
+            const requiresCollaboration = goal.description.toLowerCase().includes('collaborate') ||
+                goal.description.toLowerCase().includes('negotiate');
+            if (requiresCollaboration) {
+                return {
+                    accepted: true,
+                    reasoning: 'Goal requires cross-org collaboration - will initiate diplomatic protocol',
+                };
+            }
+        }
+        return {
+            accepted: true,
+            reasoning: 'Diplomacy agent monitoring for cross-org opportunities',
+        };
+    }
+    async processDiplomaticEvent(event) {
+        // Process diplomatic events (proposals, agreements, disputes)
+        const payload = event.payload;
+        if (payload?.type === 'proposal') {
+            // Handle proposal
+        }
+        else if (payload?.type === 'agreement') {
+            // Handle agreement
+        }
+    }
+    async initialize() {
+        // Initialize diplomatic protocols
+    }
+    async shutdown() {
+        // Save diplomatic state
+    }
+}