@vishal_20/basetree 1.0.0

package/dist/cognitiveGraph/graphStore.js

@@ -0,0 +1,81 @@
+/**
+ * Graph Persistence Layer for BASETREE V7
+ * Persists graph snapshots and event logs
+ */
+import { getKernel } from '../kernel/kernel.js';
+import * as fs from 'fs-extra';
+import * as path from 'path';
+export class GraphStore {
+    graphEngine;
+    kernel = getKernel();
+    storageDir;
+    constructor(graphEngine, storageDir = '.basetree-v7/graphs') {
+        this.graphEngine = graphEngine;
+        this.storageDir = storageDir;
+        fs.ensureDirSync(this.storageDir);
+    }
+    /**
+     * Save a snapshot to disk
+     */
+    async saveSnapshot(snapshot) {
+        const filePath = path.join(this.storageDir, `snapshot_${snapshot.runId}.json`);
+        await fs.writeJSON(filePath, snapshot, { spaces: 2 });
+    }
+    /**
+     * Load a snapshot from disk
+     */
+    async loadSnapshot(runId) {
+        const filePath = path.join(this.storageDir, `snapshot_${runId}.json`);
+        if (await fs.pathExists(filePath)) {
+            return await fs.readJSON(filePath);
+        }
+        return null;
+    }
+    /**
+     * Load all snapshots for a goal
+     */
+    async loadSnapshotsForGoal(goalId) {
+        const files = await fs.readdir(this.storageDir);
+        const snapshots = [];
+        for (const file of files) {
+            if (file.startsWith('snapshot_') && file.endsWith('.json')) {
+                const snapshot = await fs.readJSON(path.join(this.storageDir, file));
+                if (snapshot.goalId === goalId) {
+                    snapshots.push(snapshot);
+                }
+            }
+        }
+        snapshots.sort((a, b) => a.timestamp.getTime() - b.timestamp.getTime());
+        return snapshots;
+    }
+    /**
+     * Load a run's graph state
+     */
+    async loadRun(runId) {
+        // Try to load from disk first
+        const snapshot = await this.loadSnapshot(runId);
+        if (snapshot) {
+            return snapshot;
+        }
+        // Fallback to in-memory graph engine
+        return this.graphEngine.getSnapshot(runId) || null;
+    }
+    /**
+     * List all stored runs
+     */
+    async listRuns() {
+        const files = await fs.readdir(this.storageDir);
+        return files
+            .filter((f) => f.startsWith('snapshot_') && f.endsWith('.json'))
+            .map((f) => f.replace('snapshot_', '').replace('.json', ''));
+    }
+    /**
+     * Delete a snapshot
+     */
+    async deleteSnapshot(runId) {
+        const filePath = path.join(this.storageDir, `snapshot_${runId}.json`);
+        if (await fs.pathExists(filePath)) {
+            await fs.remove(filePath);
+        }
+    }
+}

package/dist/cognitiveGraph/reasoningStreamBus.js

@@ -0,0 +1,190 @@
+/**
+ * Reasoning Stream Bus for BASETREE V7
+ * Bridges global events to cognitive graph updates and WebSocket clients
+ */
+export class ReasoningStreamBus {
+    globalBus;
+    graphEngine;
+    subscribers = new Set();
+    constructor(globalBus, graphEngine) {
+        this.globalBus = globalBus;
+        this.graphEngine = graphEngine;
+        this.setupEventHandlers();
+    }
+    /**
+     * Subscribe to stream updates
+     */
+    subscribe(handler) {
+        this.subscribers.add(handler);
+        return () => {
+            this.subscribers.delete(handler);
+        };
+    }
+    /**
+     * Emit update to all subscribers
+     */
+    emit(update) {
+        for (const handler of this.subscribers) {
+            try {
+                handler(update);
+            }
+            catch (error) {
+                console.error('Error in stream subscriber:', error);
+            }
+        }
+    }
+    /**
+     * Setup event handlers to update graph
+     */
+    setupEventHandlers() {
+        // Subscribe to global events
+        this.globalBus.subscribe('global.goal', async (payload) => {
+            await this.handleGoalEvent(payload);
+        });
+        this.globalBus.subscribe('global.decision', async (payload) => {
+            await this.handleDecisionEvent(payload);
+        });
+        this.globalBus.subscribe('global.risk', async (payload) => {
+            await this.handleRiskEvent(payload);
+        });
+        this.globalBus.subscribe('region.*', async (payload) => {
+            await this.handleRegionalEvent(payload);
+        });
+    }
+    async handleGoalEvent(payload) {
+        const event = payload;
+        if (event.goal) {
+            const goalId = this.graphEngine.startRun(event.goal);
+            const node = this.graphEngine.getNode(goalId);
+            if (node) {
+                this.emit({
+                    type: 'node_added',
+                    data: node,
+                    timestamp: new Date(),
+                });
+            }
+        }
+    }
+    async handleDecisionEvent(payload) {
+        const event = payload;
+        if (event.decision && event.goalId) {
+            const decisionNode = {
+                id: `decision_${Date.now()}`,
+                type: 'decision',
+                label: event.decision.type || 'Decision',
+                attributes: {
+                    reasoning: event.decision.reasoning,
+                    outcome: event.decision.outcome,
+                },
+                createdAt: new Date(),
+                updatedAt: new Date(),
+            };
+            this.graphEngine.addNode(decisionNode);
+            // Link to goal
+            const edge = {
+                id: `${event.goalId}_handled-by_${decisionNode.id}`,
+                type: 'handled-by',
+                source: event.goalId,
+                target: decisionNode.id,
+                attributes: {},
+                createdAt: new Date(),
+            };
+            this.graphEngine.addEdge(edge);
+            this.emit({
+                type: 'node_added',
+                data: decisionNode,
+                timestamp: new Date(),
+            });
+            this.emit({
+                type: 'edge_added',
+                data: edge,
+                timestamp: new Date(),
+            });
+        }
+    }
+    async handleRiskEvent(payload) {
+        const event = payload;
+        if (event.risk && event.goalId) {
+            const riskNode = {
+                id: `risk_${Date.now()}`,
+                type: 'risk',
+                label: event.risk.level || 'Risk',
+                attributes: {
+                    level: event.risk.level,
+                    description: event.risk.description,
+                },
+                createdAt: new Date(),
+                updatedAt: new Date(),
+            };
+            this.graphEngine.addNode(riskNode);
+            // Link to goal
+            const edge = {
+                id: `${event.goalId}_causes_${riskNode.id}`,
+                type: 'causes',
+                source: event.goalId,
+                target: riskNode.id,
+                attributes: {},
+                createdAt: new Date(),
+            };
+            this.graphEngine.addEdge(edge);
+            this.emit({
+                type: 'node_added',
+                data: riskNode,
+                timestamp: new Date(),
+            });
+            this.emit({
+                type: 'edge_added',
+                data: edge,
+                timestamp: new Date(),
+            });
+        }
+    }
+    async handleRegionalEvent(payload) {
+        const event = payload;
+        if (event.task && event.goalId) {
+            const taskNode = {
+                id: event.task.id || `task_${Date.now()}`,
+                type: 'task',
+                label: event.task.type || 'Task',
+                attributes: {
+                    regionId: event.task.regionId,
+                    status: event.task.status,
+                },
+                createdAt: new Date(),
+                updatedAt: new Date(),
+            };
+            this.graphEngine.addNode(taskNode);
+            // Link to goal
+            const edge = {
+                id: `${event.goalId}_depends-on_${taskNode.id}`,
+                type: 'depends-on',
+                source: event.goalId,
+                target: taskNode.id,
+                attributes: {},
+                createdAt: new Date(),
+            };
+            this.graphEngine.addEdge(edge);
+            this.emit({
+                type: 'node_added',
+                data: taskNode,
+                timestamp: new Date(),
+            });
+            this.emit({
+                type: 'edge_added',
+                data: edge,
+                timestamp: new Date(),
+            });
+        }
+    }
+    /**
+     * Create snapshot and emit
+     */
+    createSnapshot(runId) {
+        const snapshot = this.graphEngine.snapshot(runId);
+        this.emit({
+            type: 'snapshot',
+            data: { snapshot },
+            timestamp: new Date(),
+        });
+    }
+}

package/dist/config/config.js

@@ -0,0 +1,76 @@
+/**
+ * Configuration loader for BASETREE V5
+ * Loads configuration for paths, safety levels, sandbox strategies, thresholds
+ */
+import { readFileSync, existsSync } from 'fs';
+import { join } from 'path';
+const DEFAULT_CONFIG = {
+    workspaceRoot: process.cwd(),
+    srcPath: 'src',
+    testPath: 'test',
+    stateStorePath: '.basetree-v5',
+    safety: {
+        kernelGuardEnabled: true,
+        protectedPaths: [
+            'src/kernel',
+            'src/safety',
+            'src/config',
+            'src/types',
+        ],
+        maxRiskLevel: 'medium',
+        requireGovernanceApproval: true,
+        sandboxStrategy: 'temp_dir',
+        rollbackEnabled: true,
+    },
+    sandbox: {
+        strategy: 'temp_dir',
+        cleanupOnSuccess: true,
+        cleanupOnFailure: false, // keep for debugging
+    },
+    thresholds: {
+        maxComplexity: 50,
+        maxBlastRadius: 10,
+        maxRiskScore: 0.7,
+        minStabilityScore: 0.6,
+        minAlignmentScore: 0.7,
+        regressionFailureThreshold: 0.1, // 10% max failure rate
+    },
+    observability: {
+        metricsEnabled: true,
+        metricsStorePath: '.basetree-v5/metrics',
+        enableCognitiveMetrics: true,
+        enableFailureSurfaceMapping: true,
+        reportFormat: 'both',
+    },
+};
+let cachedConfig = null;
+export function loadConfig(configPath) {
+    if (cachedConfig) {
+        return cachedConfig;
+    }
+    const configFile = configPath || join(process.cwd(), 'basetree-v5.config.json');
+    if (existsSync(configFile)) {
+        try {
+            const fileContent = readFileSync(configFile, 'utf-8');
+            const userConfig = JSON.parse(fileContent);
+            cachedConfig = { ...DEFAULT_CONFIG, ...userConfig };
+        }
+        catch (error) {
+            console.warn(`Failed to load config from ${configFile}, using defaults:`, error);
+            cachedConfig = DEFAULT_CONFIG;
+        }
+    }
+    else {
+        cachedConfig = DEFAULT_CONFIG;
+    }
+    return cachedConfig;
+}
+export function getConfig() {
+    if (!cachedConfig) {
+        cachedConfig = loadConfig();
+    }
+    return cachedConfig;
+}
+export function resetConfig() {
+    cachedConfig = null;
+}

package/dist/core/agent/AdaptivePlanner.js

@@ -0,0 +1,49 @@
+export class AdaptivePlanner {
+    ai;
+    memory;
+    constructor(ai, memory) {
+        this.ai = ai;
+        this.memory = memory;
+    }
+    async createAdaptivePlan(request) {
+        const memoryContext = await this.memory.getContextualPatterns(request);
+        const prompt = `
+      You are the Adaptive Lead Engineer for BASETREE V3.
+      Request: "${request}"
+      
+      Historical Context:
+      ${memoryContext}
+      
+      GENERATE 2 POSSIBLE SOLUTION PATHS:
+      1. Path A: Most direct/performant.
+      2. Path B: Most robust/safe.
+      
+      For each path, provide a JSON object with steps. Each step MUST include:
+      - id: "T1", "T2", etc.
+      - description: What to do
+      - action: e.g. FILE_WRITE, SHELL_EXEC
+      - expectedResult: Success criteria
+      - agentRole: Assign to one of [Architect, Backend, Frontend, Infra, Security]
+      
+      Response Format:
+      {
+        "paths": [
+          { "id": "A", "riskScore": 0.3, "reasoning": "...", "steps": [...] },
+          { "id": "B", "riskScore": 0.1, "reasoning": "...", "steps": [...] }
+        ]
+      }
+    `;
+        const response = await this.ai.generateResponse(prompt);
+        try {
+            const jsonMatch = response.match(/{[\s\S]*}/);
+            const data = JSON.parse(jsonMatch ? jsonMatch[0] : response);
+            return data.paths;
+        }
+        catch (e) {
+            return [{ id: "A", riskScore: 0.5, reasoning: "Fallback path", steps: [] }];
+        }
+    }
+    selectBestPath(paths) {
+        return paths.sort((a, b) => a.riskScore - b.riskScore)[0];
+    }
+}

package/dist/core/agent/AutoFixEngine.js

@@ -0,0 +1,37 @@
+export class AutoFixEngine {
+    ai;
+    memory;
+    constructor(ai, memory) {
+        this.ai = ai;
+        this.memory = memory;
+    }
+    async analyzeAndFix(task, output) {
+        const historicalFixes = await this.memory.getContextualPatterns("error " + output.slice(0, 100));
+        const prompt = `
+      You are the Autonomous Debugger for BASETREE V3.
+      Task failed: ${task}
+      Output/Error: ${output.slice(0, 2000)}
+      
+      Historical context on similar issues:
+      ${historicalFixes}
+      
+      1. Analyze the stack trace / error message.
+      2. Infer the ROOT CAUSE.
+      3. Generate a precise FIX.
+      
+      Response format JSON:
+      {
+        "rootCause": "...",
+        "fix": "FILE_WRITE: ... or SHELL_EXEC: ..."
+      }
+    `;
+        const response = await this.ai.generateResponse(prompt);
+        try {
+            const jsonMatch = response.match(/{[\s\S]*}/);
+            return JSON.parse(jsonMatch ? jsonMatch[0] : response);
+        }
+        catch (e) {
+            return { rootCause: "Unknown", fix: "RETRY_WITH_MORE_LOGGING" };
+        }
+    }
+}

package/dist/core/agent/ExecutorAgent.js

@@ -0,0 +1,79 @@
+import { FileTools } from "../../tools/FileTools.js";
+import { ShellTools } from "../../tools/ShellTools.js";
+import { AutoFixEngine } from "./AutoFixEngine.js";
+import chalk from "chalk";
+export class ExecutorAgent {
+    ai;
+    memory;
+    constructor(ai, memory) {
+        this.ai = ai;
+        this.memory = memory;
+    }
+    async executeStep(description, actionRecommendation) {
+        const prompt = `
+      You are the Engineering Intelligence Agent (BASETREE V3).
+      Action: ${actionRecommendation}
+      Task Context: ${description}
+      
+      Execute with precision. If an error occurs, our self-correction loop will trigger.
+    `;
+        let attempts = 0;
+        const maxAttempts = 3;
+        let currentAction = actionRecommendation;
+        let finalResult = "";
+        while (attempts < maxAttempts) {
+            process.stdout.write(chalk.gray(`    ⚡ Attempt ${attempts + 1}: Executing... `));
+            let response = "";
+            for await (const chunk of this.ai.streamResponse(prompt, [])) {
+                response += chunk;
+            }
+            process.stdout.write("\n");
+            finalResult = await this.processTools(response);
+            if (finalResult.includes("STDERR") || finalResult.includes("exitCode: 1")) {
+                console.log(chalk.red(`    ❌ Execution failed. Initializing Auto-Fix Intelligence...`));
+                const autofix = await new AutoFixEngine(this.ai, this.memory).analyzeAndFix(description, finalResult);
+                console.log(chalk.yellow(`    💡 Root Cause: ${autofix.rootCause}`));
+                console.log(chalk.blue(`    🛠 Applying Fix...`));
+                // Execute the fix action
+                await this.processTools(autofix.fix);
+                attempts++;
+                continue;
+            }
+            break;
+        }
+        return finalResult;
+    }
+    async processTools(text) {
+        let result = text;
+        // Handle FILE_WRITE
+        if (text.includes("FILE_WRITE:")) {
+            const pathMatch = text.match(/FILE_WRITE:\s*([^\s\n]+)/);
+            const contentMatch = text.match(/CONTENT_START\n([\s\S]*?)\nCONTENT_END/);
+            if (pathMatch && contentMatch) {
+                const filePath = pathMatch[1];
+                const content = contentMatch[1];
+                await FileTools.writeFile(filePath, content);
+                result += `\n${chalk.green(`[System: File written to ${filePath}]`)}`;
+            }
+        }
+        // Handle SHELL_EXEC
+        if (text.includes("SHELL_EXEC:")) {
+            const cmdMatch = text.match(/SHELL_EXEC:\s*(.+)/);
+            if (cmdMatch) {
+                const command = cmdMatch[1];
+                const shellResult = await ShellTools.execute(command);
+                result += `\n${chalk.blue(`[System: Command executed: ${command}]`)}\nSTDOUT: ${shellResult.stdout}\nSTDERR: ${shellResult.stderr}`;
+            }
+        }
+        // Handle FILE_READ
+        if (text.includes("FILE_READ:")) {
+            const pathMatch = text.match(/FILE_READ:\s*([^\s\n]+)/);
+            if (pathMatch) {
+                const filePath = pathMatch[1];
+                const content = await FileTools.readFile(filePath);
+                result += `\n${chalk.yellow(`[System: File read from ${filePath}]`)}\n---CONTENT---\n${content}`;
+            }
+        }
+        return result;
+    }
+}

package/dist/core/agent/LearningMemoryAgent.js

@@ -0,0 +1,67 @@
+import path from "path";
+import fs from "fs-extra";
+export class LearningMemoryAgent {
+    ai;
+    entries = [];
+    memoryPath;
+    constructor(ai) {
+        this.ai = ai;
+        this.memoryPath = path.resolve(process.cwd(), ".basetree/memory.json");
+        this.loadMemory();
+    }
+    async loadMemory() {
+        if (await fs.pathExists(this.memoryPath)) {
+            this.entries = await fs.readJson(this.memoryPath);
+        }
+    }
+    async saveMemory() {
+        await fs.ensureDir(path.dirname(this.memoryPath));
+        await fs.writeJson(this.memoryPath, this.entries, { spaces: 2 });
+    }
+    async learn(type, content, metadata = {}) {
+        const embedding = await this.ai.getEmbeddings(content);
+        if (!embedding || embedding.length === 0) {
+            // If we couldn't obtain an embedding, skip persisting this memory entry.
+            return;
+        }
+        this.entries.push({
+            type,
+            content,
+            embedding,
+            metadata,
+            timestamp: Date.now(),
+        });
+        await this.saveMemory();
+    }
+    async recall(query, limit = 3) {
+        const queryEmbedding = await this.ai.getEmbeddings(query);
+        if (!queryEmbedding || queryEmbedding.length === 0) {
+            return [];
+        }
+        // Simple cosine similarity search
+        const results = this.entries.map(entry => ({
+            entry,
+            similarity: this.cosineSimilarity(queryEmbedding, entry.embedding)
+        }))
+            .sort((a, b) => b.similarity - a.similarity)
+            .slice(0, limit);
+        return results.map(r => r.entry);
+    }
+    cosineSimilarity(vecA, vecB) {
+        if (!vecA.length || !vecB.length || vecA.length !== vecB.length) {
+            return 0;
+        }
+        const dotProduct = vecA.reduce((sum, a, i) => sum + a * vecB[i], 0);
+        const magnitudeA = Math.sqrt(vecA.reduce((sum, a) => sum + a * a, 0));
+        const magnitudeB = Math.sqrt(vecB.reduce((sum, b) => sum + b * b, 0));
+        if (!magnitudeA || !magnitudeB)
+            return 0;
+        return dotProduct / (magnitudeA * magnitudeB);
+    }
+    async getContextualPatterns(query) {
+        const related = await this.recall(query);
+        if (related.length === 0)
+            return "No prior patterns found.";
+        return related.map(r => `[${r.type.toUpperCase()}] ${r.content}`).join("\n");
+    }
+}

package/dist/core/agent/MemoryAgent.js

@@ -0,0 +1,35 @@
+import { FileTools } from "../../tools/FileTools.js";
+export class MemoryAgent {
+    history = [];
+    patterns = [];
+    addMessage(role, content) {
+        this.history.push({ role, content });
+    }
+    storePattern(key, content) {
+        this.patterns.push({ key, content });
+    }
+    async findRelatedPatterns(query) {
+        // Basic implementation: substring/keyword match. 
+        // In V2.1, this would use Gemini embeddings.
+        return this.patterns
+            .filter(p => p.key.toLowerCase().includes(query.toLowerCase()) || p.content.toLowerCase().includes(query.toLowerCase()))
+            .map(p => p.content);
+    }
+    getHistory() {
+        return this.history;
+    }
+    async summarizeContext() {
+        const files = await FileTools.listFiles();
+        const relatedPatterns = await this.findRelatedPatterns("error");
+        const refactorPatterns = await this.findRelatedPatterns("refactor");
+        const allPatterns = [...relatedPatterns, ...refactorPatterns];
+        return `
+      Current Workspace: ${process.cwd()}
+      Files: ${files.join(", ")}
+      Known Patterns: ${allPatterns.length > 0 ? allPatterns.join("\n- ") : "None detected yet."}
+    `;
+    }
+    clear() {
+        this.history = [];
+    }
+}

package/dist/core/agent/MetaCognitionAgent.js

@@ -0,0 +1,38 @@
+import chalk from "chalk";
+export class MetaCognitionAgent {
+    ai;
+    memory;
+    constructor(ai, memory) {
+        this.ai = ai;
+        this.memory = memory;
+    }
+    async critique(task, result, history) {
+        const prompt = `
+      You are the Meta-Cognitive Architect for BASETREE. Analyze the task completion.
+      
+      Task: ${task}
+      Outcome: ${result.slice(0, 1000)}
+      
+      Questions to answer:
+      1. Did we achieve the goal with minimal hops?
+      2. What patterns led to success or failure?
+      3. How should our future instructions be modified to avoid mistakes made here?
+      
+      Output our "Learning Insight" which will be stored in our long-term memory.
+    `;
+        const insight = await this.ai.generateResponse(prompt, history);
+        console.log(chalk.magenta(`\n🧠 Self-Critique: ${insight.split('\n')[0]}...`));
+        // Identify if it was a success or failure for categorization
+        const type = result.toLowerCase().includes("error") || result.toLowerCase().includes("failed") ? "bug" : "success";
+        await this.memory.learn(type, insight, { task });
+    }
+    async getOptimizedSystemPrompt(basePrompt) {
+        const historyInsights = await this.memory.getContextualPatterns(basePrompt);
+        return `
+      ${basePrompt}
+      
+      CONSIDER PRIOR LEARNINGS:
+      ${historyInsights}
+    `;
+    }
+}