@vishal_20/basetree 1.0.0

package/dist/state/distributedState.js

@@ -0,0 +1,241 @@
+/**
+ * Distributed State Store for BASETREE V7
+ * Sharded state across regions and zones
+ */
+import { FileStateStore } from './fileStateStore.js';
+/**
+ * Hash-based shard router
+ */
+export class HashShardRouter {
+    regions;
+    constructor(regions) {
+        this.regions = regions;
+    }
+    route(key) {
+        // Simple hash-based routing
+        let hash = 0;
+        for (let i = 0; i < key.length; i++) {
+            hash = ((hash << 5) - hash + key.charCodeAt(i)) | 0;
+        }
+        const index = Math.abs(hash) % this.regions.length;
+        return this.regions[index];
+    }
+}
+/**
+ * Distributed state store that routes to region-specific stores
+ */
+export class DistributedStateStore {
+    router;
+    regionStores = new Map();
+    constructor(router, regions) {
+        this.router = router;
+        // Initialize stores for each region
+        for (const regionId of regions) {
+            this.regionStores.set(regionId, new FileStateStore(`.basetree-v7/regions/${regionId}/state.json`));
+        }
+    }
+    getStore(key) {
+        const regionId = this.router.route(key);
+        const store = this.regionStores.get(regionId);
+        if (!store) {
+            throw new Error(`No store found for region ${regionId}`);
+        }
+        return store;
+    }
+    // Delegate all IStateStore methods to routed stores
+    async saveSnapshot(snapshot) {
+        return this.getStore(snapshot.id).saveSnapshot(snapshot);
+    }
+    async getSnapshot(id) {
+        // Try all regions (or use a global index in production)
+        for (const store of this.regionStores.values()) {
+            const snapshot = await store.getSnapshot(id);
+            if (snapshot) {
+                return snapshot;
+            }
+        }
+        return null;
+    }
+    async listSnapshots(limit) {
+        // Aggregate from all regions
+        const allSnapshots = [];
+        for (const store of this.regionStores.values()) {
+            const snapshots = await store.listSnapshots();
+            allSnapshots.push(...snapshots);
+        }
+        allSnapshots.sort((a, b) => b.timestamp.getTime() - a.timestamp.getTime());
+        return limit ? allSnapshots.slice(0, limit) : allSnapshots;
+    }
+    async getLatestSnapshot() {
+        const snapshots = await this.listSnapshots(1);
+        return snapshots[0] || null;
+    }
+    async saveProposal(proposal) {
+        return this.getStore(proposal.id).saveProposal(proposal);
+    }
+    async getProposal(id) {
+        for (const store of this.regionStores.values()) {
+            const proposal = await store.getProposal(id);
+            if (proposal) {
+                return proposal;
+            }
+        }
+        return null;
+    }
+    async listProposals(status, limit) {
+        const allProposals = [];
+        for (const store of this.regionStores.values()) {
+            const proposals = await store.listProposals(status);
+            allProposals.push(...proposals);
+        }
+        allProposals.sort((a, b) => b.createdAt.getTime() - a.createdAt.getTime());
+        return limit ? allProposals.slice(0, limit) : allProposals;
+    }
+    async updateProposal(id, updates) {
+        // Find which region has this proposal
+        for (const store of this.regionStores.values()) {
+            const proposal = await store.getProposal(id);
+            if (proposal) {
+                return store.updateProposal(id, updates);
+            }
+        }
+        throw new Error(`Proposal ${id} not found`);
+    }
+    async saveRun(run) {
+        return this.getStore(run.id).saveRun(run);
+    }
+    async getRun(id) {
+        for (const store of this.regionStores.values()) {
+            const run = await store.getRun(id);
+            if (run) {
+                return run;
+            }
+        }
+        return null;
+    }
+    async listRuns(proposalId, limit) {
+        const allRuns = [];
+        for (const store of this.regionStores.values()) {
+            const runs = await store.listRuns(proposalId);
+            allRuns.push(...runs);
+        }
+        allRuns.sort((a, b) => b.timestamp.getTime() - a.timestamp.getTime());
+        return limit ? allRuns.slice(0, limit) : allRuns;
+    }
+    async updateRun(id, updates) {
+        for (const store of this.regionStores.values()) {
+            const run = await store.getRun(id);
+            if (run) {
+                return store.updateRun(id, updates);
+            }
+        }
+        throw new Error(`Run ${id} not found`);
+    }
+    async saveMetric(metric) {
+        return this.getStore(metric.id).saveMetric(metric);
+    }
+    async getMetric(id) {
+        for (const store of this.regionStores.values()) {
+            const metric = await store.getMetric(id);
+            if (metric) {
+                return metric;
+            }
+        }
+        return null;
+    }
+    async listMetrics(name, tags, limit) {
+        const allMetrics = [];
+        for (const store of this.regionStores.values()) {
+            const metrics = await store.listMetrics(name, tags);
+            allMetrics.push(...metrics);
+        }
+        allMetrics.sort((a, b) => b.timestamp.getTime() - a.timestamp.getTime());
+        return limit ? allMetrics.slice(0, limit) : allMetrics;
+    }
+    async aggregateMetrics(name, startTime, endTime) {
+        const allMetrics = [];
+        for (const store of this.regionStores.values()) {
+            const metrics = await store.aggregateMetrics(name, startTime, endTime);
+            allMetrics.push(...metrics);
+        }
+        return allMetrics;
+    }
+    // V6 Venture methods
+    async saveVenture(venture) {
+        return this.getStore(venture.id).saveVenture(venture);
+    }
+    async getVenture(id) {
+        for (const store of this.regionStores.values()) {
+            const venture = await store.getVenture(id);
+            if (venture) {
+                return venture;
+            }
+        }
+        return null;
+    }
+    async listVentures(stage, limit) {
+        const allVentures = [];
+        for (const store of this.regionStores.values()) {
+            const ventures = await store.listVentures(stage);
+            allVentures.push(...ventures);
+        }
+        allVentures.sort((a, b) => b.createdAt.getTime() - a.createdAt.getTime());
+        return limit ? allVentures.slice(0, limit) : allVentures;
+    }
+    async updateVenture(id, updates) {
+        for (const store of this.regionStores.values()) {
+            const venture = await store.getVenture(id);
+            if (venture) {
+                return store.updateVenture(id, updates);
+            }
+        }
+        throw new Error(`Venture ${id} not found`);
+    }
+    async saveExperiment(experiment) {
+        return this.getStore(experiment.id).saveExperiment(experiment);
+    }
+    async getExperiment(id) {
+        for (const store of this.regionStores.values()) {
+            const experiment = await store.getExperiment(id);
+            if (experiment) {
+                return experiment;
+            }
+        }
+        return null;
+    }
+    async listExperiments(ventureId, limit) {
+        const allExperiments = [];
+        for (const store of this.regionStores.values()) {
+            const experiments = await store.listExperiments(ventureId);
+            allExperiments.push(...experiments);
+        }
+        allExperiments.sort((a, b) => b.createdAt.getTime() - a.createdAt.getTime());
+        return limit ? allExperiments.slice(0, limit) : allExperiments;
+    }
+    async updateExperiment(id, updates) {
+        for (const store of this.regionStores.values()) {
+            const experiment = await store.getExperiment(id);
+            if (experiment) {
+                return store.updateExperiment(id, updates);
+            }
+        }
+        throw new Error(`Experiment ${id} not found`);
+    }
+    async saveVentureMemory(record) {
+        return this.getStore(record.id).saveVentureMemory(record);
+    }
+    async listVentureMemory(options) {
+        const allRecords = [];
+        for (const store of this.regionStores.values()) {
+            const records = await store.listVentureMemory(options);
+            allRecords.push(...records);
+        }
+        allRecords.sort((a, b) => b.createdAt.getTime() - a.createdAt.getTime());
+        return options?.limit ? allRecords.slice(0, options.limit) : allRecords;
+    }
+    async cleanup(olderThan) {
+        for (const store of this.regionStores.values()) {
+            await store.cleanup(olderThan);
+        }
+    }
+}

package/dist/state/fileStateStore.js

@@ -0,0 +1,264 @@
+/**
+ * File-based State Store implementation for BASETREE V5
+ * Uses JSON files for local development
+ */
+import { promises as fs } from 'fs';
+import { join, dirname } from 'path';
+import { existsSync, mkdirSync } from 'fs';
+import { getConfig } from '../config/config.js';
+export class FileStateStore {
+    dataPath;
+    data;
+    constructor(dataPath) {
+        const config = getConfig();
+        this.dataPath = dataPath || join(config.stateStorePath, 'state.json');
+        this.data = {
+            snapshots: {},
+            proposals: {},
+            runs: {},
+            metrics: {},
+            ventures: {},
+            experiments: {},
+            ventureMemory: {},
+        };
+        this.ensureDirectory();
+        this.load();
+    }
+    ensureDirectory() {
+        const dir = dirname(this.dataPath);
+        if (!existsSync(dir)) {
+            mkdirSync(dir, { recursive: true });
+        }
+    }
+    async load() {
+        try {
+            if (existsSync(this.dataPath)) {
+                const content = await fs.readFile(this.dataPath, 'utf-8');
+                this.data = JSON.parse(content);
+                // Convert date strings back to Date objects
+                this.normalizeDates();
+            }
+        }
+        catch (error) {
+            console.warn(`Failed to load state store from ${this.dataPath}:`, error);
+            this.data = {
+                snapshots: {},
+                proposals: {},
+                runs: {},
+                metrics: {},
+                ventures: {},
+                experiments: {},
+                ventureMemory: {},
+            };
+        }
+    }
+    normalizeDates() {
+        // Convert ISO date strings back to Date objects
+        const normalize = (obj) => {
+            if (obj === null || typeof obj !== 'object') {
+                return obj;
+            }
+            if (Array.isArray(obj)) {
+                return obj.map(normalize);
+            }
+            for (const key in obj) {
+                if (key === 'timestamp' || key === 'createdAt' || key === 'updatedAt') {
+                    obj[key] = new Date(obj[key]);
+                }
+                else if (typeof obj[key] === 'object') {
+                    obj[key] = normalize(obj[key]);
+                }
+            }
+            return obj;
+        };
+        this.data = normalize(this.data);
+    }
+    async save() {
+        try {
+            await fs.writeFile(this.dataPath, JSON.stringify(this.data, null, 2), 'utf-8');
+        }
+        catch (error) {
+            console.error(`Failed to save state store to ${this.dataPath}:`, error);
+            throw error;
+        }
+    }
+    // Snapshots
+    async saveSnapshot(snapshot) {
+        this.data.snapshots[snapshot.id] = snapshot;
+        await this.save();
+    }
+    async getSnapshot(id) {
+        return this.data.snapshots[id] || null;
+    }
+    async listSnapshots(limit) {
+        const snapshots = Object.values(this.data.snapshots);
+        snapshots.sort((a, b) => b.timestamp.getTime() - a.timestamp.getTime());
+        return limit ? snapshots.slice(0, limit) : snapshots;
+    }
+    async getLatestSnapshot() {
+        const snapshots = await this.listSnapshots(1);
+        return snapshots[0] || null;
+    }
+    // Proposals
+    async saveProposal(proposal) {
+        this.data.proposals[proposal.id] = proposal;
+        await this.save();
+    }
+    async getProposal(id) {
+        return this.data.proposals[id] || null;
+    }
+    async listProposals(status, limit) {
+        let proposals = Object.values(this.data.proposals);
+        if (status) {
+            proposals = proposals.filter((p) => p.governanceDecision === status);
+        }
+        proposals.sort((a, b) => b.createdAt.getTime() - a.createdAt.getTime());
+        return limit ? proposals.slice(0, limit) : proposals;
+    }
+    async updateProposal(id, updates) {
+        const proposal = this.data.proposals[id];
+        if (!proposal) {
+            throw new Error(`Proposal ${id} not found`);
+        }
+        Object.assign(proposal, updates);
+        proposal.updatedAt = new Date();
+        await this.save();
+    }
+    // Runs
+    async saveRun(run) {
+        this.data.runs[run.id] = run;
+        await this.save();
+    }
+    async getRun(id) {
+        return this.data.runs[id] || null;
+    }
+    async listRuns(proposalId, limit) {
+        let runs = Object.values(this.data.runs);
+        if (proposalId) {
+            runs = runs.filter((r) => r.proposalId === proposalId);
+        }
+        runs.sort((a, b) => b.timestamp.getTime() - a.timestamp.getTime());
+        return limit ? runs.slice(0, limit) : runs;
+    }
+    async updateRun(id, updates) {
+        const run = this.data.runs[id];
+        if (!run) {
+            throw new Error(`Run ${id} not found`);
+        }
+        Object.assign(run, updates);
+        await this.save();
+    }
+    // Metrics
+    async saveMetric(metric) {
+        this.data.metrics[metric.id] = metric;
+        await this.save();
+    }
+    async getMetric(id) {
+        return this.data.metrics[id] || null;
+    }
+    async listMetrics(name, tags, limit) {
+        let metrics = Object.values(this.data.metrics);
+        if (name) {
+            metrics = metrics.filter((m) => m.name === name);
+        }
+        if (tags) {
+            metrics = metrics.filter((m) => {
+                if (!m.tags)
+                    return false;
+                return Object.entries(tags).every(([key, value]) => m.tags[key] === value);
+            });
+        }
+        metrics.sort((a, b) => b.timestamp.getTime() - a.timestamp.getTime());
+        return limit ? metrics.slice(0, limit) : metrics;
+    }
+    async aggregateMetrics(name, startTime, endTime) {
+        const metrics = await this.listMetrics(name);
+        return metrics.filter((m) => m.timestamp >= startTime && m.timestamp <= endTime);
+    }
+    // Ventures
+    async saveVenture(venture) {
+        this.data.ventures[venture.id] = venture;
+        await this.save();
+    }
+    async getVenture(id) {
+        return this.data.ventures[id] || null;
+    }
+    async listVentures(stage, limit) {
+        let ventures = Object.values(this.data.ventures);
+        if (stage) {
+            ventures = ventures.filter((v) => v.stage === stage);
+        }
+        ventures.sort((a, b) => b.createdAt.getTime() - a.createdAt.getTime());
+        return limit ? ventures.slice(0, limit) : ventures;
+    }
+    async updateVenture(id, updates) {
+        const venture = this.data.ventures[id];
+        if (!venture) {
+            throw new Error(`Venture ${id} not found`);
+        }
+        Object.assign(venture, updates);
+        venture.updatedAt = new Date();
+        await this.save();
+    }
+    // Experiments
+    async saveExperiment(experiment) {
+        this.data.experiments[experiment.id] = experiment;
+        await this.save();
+    }
+    async getExperiment(id) {
+        return this.data.experiments[id] || null;
+    }
+    async listExperiments(ventureId, limit) {
+        let experiments = Object.values(this.data.experiments);
+        if (ventureId) {
+            experiments = experiments.filter((e) => e.ventureId === ventureId);
+        }
+        experiments.sort((a, b) => b.createdAt.getTime() - a.createdAt.getTime());
+        return limit ? experiments.slice(0, limit) : experiments;
+    }
+    async updateExperiment(id, updates) {
+        const experiment = this.data.experiments[id];
+        if (!experiment) {
+            throw new Error(`Experiment ${id} not found`);
+        }
+        Object.assign(experiment, updates);
+        await this.save();
+    }
+    // Venture memory
+    async saveVentureMemory(record) {
+        this.data.ventureMemory[record.id] = record;
+        await this.save();
+    }
+    async listVentureMemory(options) {
+        let records = Object.values(this.data.ventureMemory);
+        if (options?.ventureId) {
+            records = records.filter((r) => r.ventureId === options.ventureId);
+        }
+        if (options?.kind) {
+            records = records.filter((r) => r.kind === options.kind);
+        }
+        if (options?.tag) {
+            records = records.filter((r) => r.tags.includes(options.tag));
+        }
+        records.sort((a, b) => b.createdAt.getTime() - a.createdAt.getTime());
+        return options?.limit ? records.slice(0, options.limit) : records;
+    }
+    // Cleanup
+    async cleanup(olderThan) {
+        const cutoff = olderThan || new Date(Date.now() - 30 * 24 * 60 * 60 * 1000); // 30 days default
+        // Clean snapshots
+        for (const id in this.data.snapshots) {
+            if (this.data.snapshots[id].timestamp < cutoff) {
+                delete this.data.snapshots[id];
+            }
+        }
+        // Clean metrics
+        for (const id in this.data.metrics) {
+            if (this.data.metrics[id].timestamp < cutoff) {
+                delete this.data.metrics[id];
+            }
+        }
+        // Optionally prune old venture memory (keep lessons; do not delete by default)
+        await this.save();
+    }
+}

package/dist/state/snapshotter.js

@@ -0,0 +1,96 @@
+/**
+ * Snapshotter for BASETREE V5
+ * Logic to snapshot current system state (code hashes, config, metrics)
+ */
+import { createHash } from 'crypto';
+import { promises as fs } from 'fs';
+import { join } from 'path';
+import { globby } from 'globby';
+import { getConfig } from '../config/config.js';
+import { getEventBus } from '../kernel/eventBus.js';
+export class Snapshotter {
+    config = getConfig();
+    async createSnapshot() {
+        const snapshotId = `snapshot_${Date.now()}_${Math.random().toString(36).substr(2, 9)}`;
+        const timestamp = new Date();
+        // Compute code hashes
+        const codeHashes = await this.computeCodeHashes();
+        // Capture current config
+        const config = {
+            ...this.config,
+            // Don't include paths that change
+            workspaceRoot: this.config.workspaceRoot,
+        };
+        // Get current metrics (if any)
+        const metrics = [];
+        const snapshot = {
+            id: snapshotId,
+            timestamp,
+            codeHashes,
+            config: config,
+            metrics,
+            metadata: {
+                nodeVersion: process.version,
+                platform: process.platform,
+            },
+        };
+        // Emit event
+        const eventBus = getEventBus();
+        await eventBus.emit({
+            type: 'SnapshotCreated',
+            timestamp,
+            snapshotId,
+        });
+        return snapshot;
+    }
+    async computeCodeHashes() {
+        const hashes = {};
+        const srcPath = join(this.config.workspaceRoot, this.config.srcPath);
+        try {
+            // Find all TypeScript/JavaScript files
+            const files = await globby([
+                `${this.config.srcPath}/**/*.{ts,js,tsx,jsx}`,
+                `${this.config.testPath}/**/*.{ts,js,tsx,jsx}`,
+            ], {
+                cwd: this.config.workspaceRoot,
+                ignore: ['node_modules', 'dist', '.basetree-v5'],
+            });
+            for (const file of files) {
+                try {
+                    const fullPath = join(this.config.workspaceRoot, file);
+                    const content = await fs.readFile(fullPath, 'utf-8');
+                    const hash = createHash('sha256').update(content).digest('hex');
+                    hashes[file] = hash;
+                }
+                catch (error) {
+                    console.warn(`Failed to hash file ${file}:`, error);
+                }
+            }
+        }
+        catch (error) {
+            console.warn('Failed to compute code hashes:', error);
+        }
+        return hashes;
+    }
+    async compareSnapshots(before, after) {
+        const changed = [];
+        const added = [];
+        const removed = [];
+        // Find changed and removed files
+        for (const file in before.codeHashes) {
+            if (!after.codeHashes[file]) {
+                removed.push(file);
+            }
+            else if (before.codeHashes[file] !== after.codeHashes[file]) {
+                changed.push(file);
+            }
+        }
+        // Find added files
+        for (const file in after.codeHashes) {
+            if (!before.codeHashes[file]) {
+                added.push(file);
+            }
+        }
+        return { changed, added, removed };
+    }
+}

package/dist/state/stateStore.js

@@ -0,0 +1,5 @@
+/**
+ * State Store interface for BASETREE V5/V6
+ * Abstract interface for storing snapshots, proposals, runs, metrics and ventures
+ */
+export {};

package/dist/tools/FileTools.js

@@ -0,0 +1,25 @@
+import fs from "fs-extra";
+import path from "path";
+import { globby } from "globby";
+export class FileTools {
+    static async readFile(filePath) {
+        const absolutePath = path.resolve(process.cwd(), filePath);
+        return await fs.readFile(absolutePath, "utf-8");
+    }
+    static async writeFile(filePath, content) {
+        const absolutePath = path.resolve(process.cwd(), filePath);
+        await fs.ensureDir(path.dirname(absolutePath));
+        await fs.writeFile(absolutePath, content, "utf-8");
+    }
+    static async listFiles(pattern = "**/*", ignore = ["node_modules/**", "dist/**", ".git/**"]) {
+        return await globby(pattern, { ignore });
+    }
+    static async exists(filePath) {
+        const absolutePath = path.resolve(process.cwd(), filePath);
+        return await fs.pathExists(absolutePath);
+    }
+    static async deleteFile(filePath) {
+        const absolutePath = path.resolve(process.cwd(), filePath);
+        await fs.remove(absolutePath);
+    }
+}

package/dist/tools/GitTools.js

@@ -0,0 +1,16 @@
+import { ShellTools } from "./ShellTools.js";
+export class GitTools {
+    static async getStatus() {
+        const result = await ShellTools.execute("git status --short");
+        return result.stdout;
+    }
+    static async commit(message) {
+        await ShellTools.execute("git add .");
+        const result = await ShellTools.execute(`git commit -m "${message}"`);
+        return result.stdout;
+    }
+    static async getDiff() {
+        const result = await ShellTools.execute("git diff");
+        return result.stdout;
+    }
+}

package/dist/tools/ShellTools.js

@@ -0,0 +1,24 @@
+import { execa } from "execa";
+export class ShellTools {
+    static async execute(command, args = []) {
+        try {
+            const result = await execa(command, args, {
+                shell: true,
+                all: true,
+                reject: false,
+            });
+            return {
+                stdout: result.stdout || "",
+                stderr: result.stderr || "",
+                exitCode: result.exitCode ?? 0
+            };
+        }
+        catch (error) {
+            return {
+                stdout: error.stdout || "",
+                stderr: error.stderr || error.message,
+                exitCode: error.exitCode ?? 1,
+            };
+        }
+    }
+}

package/dist/types/architecture.js

@@ -0,0 +1,5 @@
+/**
+ * Architecture types for BASETREE V5
+ * Types describing internal architecture graphs, modules, flows, and bottlenecks
+ */
+export {};