@vishal_20/basetree 1.0.0

package/dist/safety/planetaryKernel.js

@@ -0,0 +1,92 @@
+/**
+ * Planetary Safety Kernel for BASETREE V7
+ * Defines hard safety invariants for planetary-scale operations
+ */
+import { getKernel } from '../kernel/kernel.js';
+export class PlanetaryKernel {
+    kernel = getKernel();
+    invariants = [];
+    constructor() {
+        this.setupInvariants();
+    }
+    /**
+     * Setup hard safety invariants
+     */
+    setupInvariants() {
+        // Invariant 1: Protected zones cannot be edited
+        this.invariants.push({
+            id: 'protected-zones',
+            description: 'Protected zones cannot be modified',
+            check: () => {
+                // Check kernel protected paths
+                const protectedPaths = [
+                    'src/kernel/',
+                    'src/safety/',
+                    'src/planet/controlPlane.ts',
+                ];
+                // This is a simplified check - in production would verify no changes to protected paths
+                return true;
+            },
+        });
+        // Invariant 2: Maximum blast radius across regions
+        this.invariants.push({
+            id: 'max-blast-radius',
+            description: 'Changes cannot affect more than 3 regions simultaneously',
+            check: () => {
+                // Simplified check - would verify change scope
+                return true;
+            },
+        });
+        // Invariant 3: Critical operations require governance approval
+        this.invariants.push({
+            id: 'governance-approval',
+            description: 'Critical operations require governance council approval',
+            check: () => {
+                // Would check governance state
+                return true;
+            },
+        });
+    }
+    /**
+     * Verify all invariants
+     */
+    async verifyInvariants() {
+        const violations = [];
+        for (const invariant of this.invariants) {
+            try {
+                const passed = await Promise.resolve(invariant.check());
+                if (!passed) {
+                    violations.push(invariant.description);
+                }
+            }
+            catch (error) {
+                violations.push(`${invariant.description}: ${error.message}`);
+            }
+        }
+        return {
+            passed: violations.length === 0,
+            violations,
+        };
+    }
+    /**
+     * Check if a region can be modified
+     */
+    canModifyRegion(regionId) {
+        // Check if region is in protected list
+        const protectedRegions = []; // Could be configured
+        return !protectedRegions.includes(regionId);
+    }
+    /**
+     * Check if an operation exceeds max blast radius
+     */
+    checkBlastRadius(affectedRegions) {
+        const maxBlastRadius = 3;
+        return affectedRegions.length <= maxBlastRadius;
+    }
+    /**
+     * Register a new invariant
+     */
+    registerInvariant(invariant) {
+        this.invariants.push(invariant);
+    }
+}

package/dist/safety/policyEngine.js

@@ -0,0 +1,129 @@
+/**
+ * Policy Engine for BASETREE V5
+ * Central evaluator for policies used by governance agents
+ */
+import { getConfig } from '../config/config.js';
+import { KernelGuard } from './kernelGuard.js';
+export class PolicyEngine {
+    config = getConfig();
+    kernelGuard = new KernelGuard();
+    rules = [];
+    constructor() {
+        this.initializeDefaultRules();
+    }
+    /**
+     * Initialize default policy rules
+     */
+    initializeDefaultRules() {
+        // Rule 1: Kernel protection
+        this.rules.push({
+            id: 'kernel_protection',
+            name: 'Kernel Protection',
+            description: 'Proposals cannot modify protected kernel files',
+            severity: 'block',
+            evaluator: (proposal) => {
+                const guardResult = this.kernelGuard.checkProposal(proposal);
+                if (!guardResult.allowed) {
+                    return {
+                        passed: false,
+                        severity: 'block',
+                        message: guardResult.reason || 'Kernel protection violation',
+                        details: { blockedFiles: guardResult.blockedFiles },
+                    };
+                }
+                return {
+                    passed: true,
+                    severity: 'info',
+                    message: 'No kernel protection violations',
+                };
+            },
+        });
+        // Rule 2: Risk level threshold
+        this.rules.push({
+            id: 'risk_threshold',
+            name: 'Risk Threshold',
+            description: `Proposals must not exceed risk level: ${this.config.safety.maxRiskLevel}`,
+            severity: 'error',
+            evaluator: (proposal) => {
+                const riskOrder = {
+                    safe: 0,
+                    low: 1,
+                    medium: 2,
+                    high: 3,
+                    critical: 4,
+                };
+                const proposalRisk = riskOrder[proposal.riskLevel];
+                const maxRisk = riskOrder[this.config.safety.maxRiskLevel];
+                if (proposalRisk > maxRisk) {
+                    return {
+                        passed: false,
+                        severity: 'error',
+                        message: `Proposal risk level ${proposal.riskLevel} exceeds maximum allowed ${this.config.safety.maxRiskLevel}`,
+                    };
+                }
+                return {
+                    passed: true,
+                    severity: 'info',
+                    message: 'Risk level within acceptable range',
+                };
+            },
+        });
+        // Rule 3: Blast radius limit
+        this.rules.push({
+            id: 'blast_radius',
+            name: 'Blast Radius Limit',
+            description: `Proposals must not affect more than ${this.config.thresholds.maxBlastRadius} modules`,
+            severity: 'warning',
+            evaluator: (proposal) => {
+                const affectedModules = new Set();
+                for (const change of proposal.changes) {
+                    // Extract module from file path (simplified)
+                    const module = change.filePath.split('/')[0] || change.filePath.split('\\')[0];
+                    affectedModules.add(module);
+                }
+                if (affectedModules.size > this.config.thresholds.maxBlastRadius) {
+                    return {
+                        passed: false,
+                        severity: 'warning',
+                        message: `Proposal affects ${affectedModules.size} modules, exceeding limit of ${this.config.thresholds.maxBlastRadius}`,
+                        details: { affectedModules: Array.from(affectedModules) },
+                    };
+                }
+                return {
+                    passed: true,
+                    severity: 'info',
+                    message: `Blast radius acceptable: ${affectedModules.size} modules`,
+                };
+            },
+        });
+    }
+    /**
+     * Register a custom policy rule
+     */
+    registerRule(rule) {
+        this.rules.push(rule);
+    }
+    /**
+     * Evaluate a proposal against all policies
+     */
+    evaluate(proposal) {
+        return this.rules.map((rule) => rule.evaluator(proposal));
+    }
+    /**
+     * Check if proposal passes all blocking policies
+     */
+    isAllowed(proposal) {
+        const evaluations = this.evaluate(proposal);
+        const blockingFailures = evaluations.filter((e) => !e.passed && (e.severity === 'block' || e.severity === 'error'));
+        return {
+            allowed: blockingFailures.length === 0,
+            evaluations,
+        };
+    }
+    /**
+     * Get all registered rules
+     */
+    getRules() {
+        return [...this.rules];
+    }
+}

package/dist/safety/rollbackManager.js

@@ -0,0 +1,141 @@
+/**
+ * Rollback Manager for BASETREE V5
+ * Stores rollback points and can restore previous code/state
+ */
+import { promises as fs } from 'fs';
+import { join } from 'path';
+import { copy, remove } from 'fs-extra';
+import { getConfig } from '../config/config.js';
+import { getKernel } from '../kernel/kernel.js';
+import { IntegrityChecker } from './integrityChecker.js';
+import { getEventBus } from '../kernel/eventBus.js';
+export class RollbackManager {
+    config = getConfig();
+    kernel = getKernel();
+    integrityChecker = new IntegrityChecker();
+    rollbackPoints = new Map();
+    /**
+     * Create a rollback point from a snapshot
+     */
+    async createRollbackPoint(snapshot, description) {
+        const rollbackId = `rollback_${Date.now()}_${Math.random().toString(36).substr(2, 9)}`;
+        const backupDir = join(this.config.workspaceRoot, '.basetree-v5', 'rollbacks', rollbackId);
+        await fs.mkdir(backupDir, { recursive: true });
+        const fileBackups = {};
+        const workspaceRoot = this.config.workspaceRoot;
+        // Backup all files in snapshot
+        for (const filePath of Object.keys(snapshot.codeHashes)) {
+            const sourcePath = join(workspaceRoot, filePath);
+            const backupPath = join(backupDir, filePath.replace(/[\/\\]/g, '_'));
+            try {
+                await fs.mkdir(join(backupPath, '..'), { recursive: true });
+                await copy(sourcePath, backupPath);
+                fileBackups[filePath] = backupPath;
+            }
+            catch (error) {
+                console.warn(`Failed to backup ${filePath}:`, error);
+            }
+        }
+        const rollbackPoint = {
+            id: rollbackId,
+            snapshotId: snapshot.id,
+            timestamp: new Date(),
+            description,
+            fileBackups,
+        };
+        this.rollbackPoints.set(rollbackId, rollbackPoint);
+        // Save rollback point metadata
+        await this.saveRollbackPoint(rollbackPoint);
+        return rollbackId;
+    }
+    /**
+     * Restore from a rollback point
+     */
+    async rollback(rollbackId) {
+        const rollbackPoint = this.rollbackPoints.get(rollbackId);
+        if (!rollbackPoint) {
+            // Try to load from disk
+            const loaded = await this.loadRollbackPoint(rollbackId);
+            if (!loaded) {
+                throw new Error(`Rollback point ${rollbackId} not found`);
+            }
+            this.rollbackPoints.set(rollbackId, loaded);
+        }
+        const point = this.rollbackPoints.get(rollbackId);
+        const workspaceRoot = this.config.workspaceRoot;
+        const eventBus = getEventBus();
+        await eventBus.emit({
+            type: 'RollbackTriggered',
+            timestamp: new Date(),
+            runId: rollbackId,
+            reason: point.description || 'Manual rollback',
+        });
+        // Restore files
+        for (const [filePath, backupPath] of Object.entries(point.fileBackups)) {
+            const targetPath = join(workspaceRoot, filePath);
+            try {
+                await fs.mkdir(join(targetPath, '..'), { recursive: true });
+                await copy(backupPath, targetPath);
+            }
+            catch (error) {
+                console.error(`Failed to restore ${filePath}:`, error);
+                throw error;
+            }
+        }
+        await eventBus.emit({
+            type: 'RollbackCompleted',
+            timestamp: new Date(),
+            runId: rollbackId,
+        });
+    }
+    /**
+     * List available rollback points
+     */
+    listRollbackPoints() {
+        return Array.from(this.rollbackPoints.values()).sort((a, b) => b.timestamp.getTime() - a.timestamp.getTime());
+    }
+    /**
+     * Get latest rollback point
+     */
+    getLatestRollbackPoint() {
+        const points = this.listRollbackPoints();
+        return points[0] || null;
+    }
+    /**
+     * Cleanup old rollback points
+     */
+    async cleanup(olderThanDays = 30) {
+        const cutoff = new Date(Date.now() - olderThanDays * 24 * 60 * 60 * 1000);
+        const rollbacksDir = join(this.config.workspaceRoot, '.basetree-v5', 'rollbacks');
+        for (const [id, point] of this.rollbackPoints.entries()) {
+            if (point.timestamp < cutoff) {
+                try {
+                    const backupDir = join(rollbacksDir, id);
+                    await remove(backupDir);
+                    this.rollbackPoints.delete(id);
+                }
+                catch (error) {
+                    console.warn(`Failed to cleanup rollback point ${id}:`, error);
+                }
+            }
+        }
+    }
+    async saveRollbackPoint(point) {
+        const rollbacksDir = join(this.config.workspaceRoot, '.basetree-v5', 'rollbacks', point.id);
+        await fs.mkdir(rollbacksDir, { recursive: true });
+        const metadataPath = join(rollbacksDir, 'metadata.json');
+        await fs.writeFile(metadataPath, JSON.stringify(point, null, 2), 'utf-8');
+    }
+    async loadRollbackPoint(id) {
+        const metadataPath = join(this.config.workspaceRoot, '.basetree-v5', 'rollbacks', id, 'metadata.json');
+        try {
+            const content = await fs.readFile(metadataPath, 'utf-8');
+            const point = JSON.parse(content);
+            point.timestamp = new Date(point.timestamp);
+            return point;
+        }
+        catch (error) {
+            return null;
+        }
+    }
+}

package/dist/safety/sandbox.js

@@ -0,0 +1,143 @@
+/**
+ * Sandbox for BASETREE V5
+ * Runs upgrade executors and tests in isolated directories/processes
+ */
+import { promises as fs } from 'fs';
+import { join } from 'path';
+import { execa } from 'execa';
+import { copy, remove } from 'fs-extra';
+import { getConfig } from '../config/config.js';
+export class Sandbox {
+    config = getConfig();
+    sandboxPath = null;
+    async create(options = {}) {
+        const strategy = options.strategy || this.config.sandbox.strategy;
+        const workspaceRoot = this.config.workspaceRoot;
+        switch (strategy) {
+            case 'temp_dir': {
+                const tempDir = join(workspaceRoot, '.basetree-v5', 'sandbox', `sandbox_${Date.now()}_${Math.random().toString(36).substr(2, 9)}`);
+                await fs.mkdir(tempDir, { recursive: true });
+                // Copy workspace to sandbox
+                await this.copyWorkspace(workspaceRoot, tempDir);
+                this.sandboxPath = tempDir;
+                return tempDir;
+            }
+            case 'copy': {
+                const copyDir = join(workspaceRoot, '.basetree-v5', 'sandbox', `copy_${Date.now()}`);
+                await fs.mkdir(copyDir, { recursive: true });
+                await this.copyWorkspace(workspaceRoot, copyDir);
+                this.sandboxPath = copyDir;
+                return copyDir;
+            }
+            case 'git_worktree': {
+                // Try to use git worktree if available
+                try {
+                    const worktreePath = join(workspaceRoot, '.basetree-v5', 'sandbox', `worktree_${Date.now()}`);
+                    await execa('git', ['worktree', 'add', worktreePath, 'HEAD'], { cwd: workspaceRoot });
+                    this.sandboxPath = worktreePath;
+                    return worktreePath;
+                }
+                catch (error) {
+                    console.warn('Git worktree not available, falling back to temp_dir:', error);
+                    return this.create({ ...options, strategy: 'temp_dir' });
+                }
+            }
+            default:
+                throw new Error(`Unknown sandbox strategy: ${strategy}`);
+        }
+    }
+    async copyWorkspace(source, dest) {
+        // Copy essential directories and files
+        const itemsToCopy = [
+            'src',
+            'test',
+            'package.json',
+            'tsconfig.json',
+            'node_modules', // if exists
+        ];
+        for (const item of itemsToCopy) {
+            const sourcePath = join(source, item);
+            const destPath = join(dest, item);
+            try {
+                const stat = await fs.stat(sourcePath);
+                if (stat.isDirectory()) {
+                    await copy(sourcePath, destPath);
+                }
+                else {
+                    await fs.copyFile(sourcePath, destPath);
+                }
+            }
+            catch (error) {
+                // Skip if doesn't exist
+                continue;
+            }
+        }
+    }
+    getPath() {
+        if (!this.sandboxPath) {
+            throw new Error('Sandbox not created. Call create() first.');
+        }
+        return this.sandboxPath;
+    }
+    async execute(command, args = [], options = {}) {
+        if (!this.sandboxPath) {
+            throw new Error('Sandbox not created. Call create() first.');
+        }
+        const cwd = options.cwd || this.sandboxPath;
+        try {
+            const result = await execa(command, args, {
+                cwd,
+                env: { ...process.env, ...options.env },
+                shell: true,
+            });
+            return {
+                success: true,
+                output: result.stdout,
+                sandboxPath: this.sandboxPath,
+            };
+        }
+        catch (error) {
+            return {
+                success: false,
+                error: error.message || String(error),
+                output: error.stdout || error.stderr,
+                sandboxPath: this.sandboxPath,
+            };
+        }
+    }
+    async cleanup(options = {}) {
+        if (!this.sandboxPath) {
+            return;
+        }
+        const cleanupOnSuccess = options.cleanupOnSuccess ?? this.config.sandbox.cleanupOnSuccess;
+        const cleanupOnFailure = options.cleanupOnFailure ?? this.config.sandbox.cleanupOnFailure;
+        // Check if this is a git worktree
+        if (this.sandboxPath.includes('worktree_')) {
+            try {
+                await execa('git', ['worktree', 'remove', this.sandboxPath], {
+                    cwd: this.config.workspaceRoot,
+                });
+            }
+            catch (error) {
+                console.warn('Failed to remove git worktree:', error);
+                // Fall through to regular cleanup
+            }
+        }
+        // For temp_dir and copy strategies, or if git worktree removal failed
+        if (cleanupOnSuccess || cleanupOnFailure) {
+            try {
+                await remove(this.sandboxPath);
+            }
+            catch (error) {
+                console.warn(`Failed to cleanup sandbox at ${this.sandboxPath}:`, error);
+            }
+        }
+        this.sandboxPath = null;
+    }
+    async cleanupOnSuccess() {
+        await this.cleanup({ cleanupOnSuccess: true, cleanupOnFailure: false });
+    }
+    async cleanupOnFailure() {
+        await this.cleanup({ cleanupOnSuccess: false, cleanupOnFailure: true });
+    }
+}

package/dist/server/mindmapServer.js

@@ -0,0 +1,102 @@
+/**
+ * Mindmap Server for BASETREE V7
+ * Express + WebSocket server for cognitive graph visualization
+ */
+import express from 'express';
+import { createServer } from 'http';
+import { WebSocketServer } from 'ws';
+export class MindmapServer {
+    app;
+    server;
+    wss;
+    graphEngine;
+    streamBus;
+    graphStore;
+    port;
+    constructor(graphEngine, streamBus, graphStore, port = 3000) {
+        this.app = express();
+        this.server = createServer(this.app);
+        this.wss = new WebSocketServer({ server: this.server });
+        this.graphEngine = graphEngine;
+        this.streamBus = streamBus;
+        this.graphStore = graphStore;
+        this.port = port;
+        this.setupRoutes();
+        this.setupWebSocket();
+    }
+    setupRoutes() {
+        this.app.use(express.json());
+        this.app.use(express.static('web/mindmap'));
+        // Get graph for a goal/run
+        this.app.get('/api/mindmap/:goalId', async (req, res) => {
+            try {
+                const goalId = req.params.goalId;
+                const graph = this.graphEngine.exportGraph(goalId);
+                res.json(graph);
+            }
+            catch (error) {
+                res.status(500).json({ error: error.message });
+            }
+        });
+        // Get replay data for a run
+        this.app.get('/api/runs/:runId/replay', async (req, res) => {
+            try {
+                const runId = req.params.runId;
+                const snapshot = await this.graphStore.loadRun(runId);
+                if (!snapshot) {
+                    res.status(404).json({ error: 'Run not found' });
+                    return;
+                }
+                res.json(snapshot);
+            }
+            catch (error) {
+                res.status(500).json({ error: error.message });
+            }
+        });
+        // List all runs
+        this.app.get('/api/runs', async (req, res) => {
+            try {
+                const runs = await this.graphStore.listRuns();
+                res.json(runs);
+            }
+            catch (error) {
+                res.status(500).json({ error: error.message });
+            }
+        });
+    }
+    setupWebSocket() {
+        this.wss.on('connection', (ws) => {
+            console.log('WebSocket client connected');
+            // Subscribe to stream updates
+            const unsubscribe = this.streamBus.subscribe((update) => {
+                if (ws.readyState === ws.OPEN) {
+                    ws.send(JSON.stringify(update));
+                }
+            });
+            ws.on('close', () => {
+                console.log('WebSocket client disconnected');
+                unsubscribe();
+            });
+            ws.on('error', (error) => {
+                console.error('WebSocket error:', error);
+            });
+        });
+    }
+    async start() {
+        return new Promise((resolve) => {
+            this.server.listen(this.port, () => {
+                console.log(`Mindmap server running on http://localhost:${this.port}`);
+                resolve();
+            });
+        });
+    }
+    async stop() {
+        return new Promise((resolve) => {
+            this.wss.close(() => {
+                this.server.close(() => {
+                    resolve();
+                });
+            });
+        });
+    }
+}