@thoughtflow/core 0.1.2

package/dist/libs/decoder-registry.class.d.ts

@@ -0,0 +1,43 @@
+/**
+ * DecoderRegistry — Auto-selects the best StructuralDecoder for each file.
+ *
+ * Priority:
+ *   1. TypeScriptDecoder (ts-morph) for .ts/.tsx/.js/.jsx
+ *   2. FallbackDecoder (regex) for Python/Java/Go/Rust/C#/Ruby/PHP
+ *   3. null for unsupported files
+ *
+ * Caches decoder instances. Thread-safe for single-threaded Node.
+ */
+import type { StructuralDecoder, StructuralSnapshot, DecoderRegistryConfig } from "../contracts/structural-decoder.types";
+export declare class DecoderRegistry {
+    private decoders;
+    private readonly config;
+    constructor(config: DecoderRegistryConfig);
+    /**
+     * Find the best decoder for a file, or null if unsupported.
+     */
+    getDecoder(filePath: string, content?: string): StructuralDecoder | null;
+    /**
+     * Decode a file using the best available decoder.
+     * Returns null if no decoder handles this file type.
+     */
+    decode(filePath: string, content: string): StructuralSnapshot | null;
+    /**
+     * Decode a file from disk.
+     */
+    decodeFile(relativeFilePath: string): StructuralSnapshot | null;
+    /**
+     * List all decoder names and their supported extensions.
+     */
+    listDecoders(): Array<{
+        name: string;
+        extensions: string[];
+    }>;
+    /**
+     * Dispose all decoder resources.
+     */
+    dispose(): void;
+    private initDecoders;
+    private findTsConfig;
+}
+//# sourceMappingURL=decoder-registry.class.d.ts.map

package/dist/libs/decoder-registry.class.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"decoder-registry.class.d.ts","sourceRoot":"","sources":["../../src/libs/decoder-registry.class.ts"],"names":[],"mappings":"AAAA;;;;;;;;;GASG;AAIH,OAAO,KAAK,EACV,iBAAiB,EACjB,kBAAkB,EAClB,qBAAqB,EACtB,MAAM,uCAAuC,CAAC;AAK/C,qBAAa,eAAe;IAC1B,OAAO,CAAC,QAAQ,CAA2B;IAC3C,OAAO,CAAC,QAAQ,CAAC,MAAM,CAAwB;gBAEnC,MAAM,EAAE,qBAAqB;IAKzC;;OAEG;IACH,UAAU,CAAC,QAAQ,EAAE,MAAM,EAAE,OAAO,CAAC,EAAE,MAAM,GAAG,iBAAiB,GAAG,IAAI;IAOxE;;;OAGG;IACH,MAAM,CAAC,QAAQ,EAAE,MAAM,EAAE,OAAO,EAAE,MAAM,GAAG,kBAAkB,GAAG,IAAI;IAMpE;;OAEG;IACH,UAAU,CAAC,gBAAgB,EAAE,MAAM,GAAG,kBAAkB,GAAG,IAAI;IAO/D;;OAEG;IACH,YAAY,IAAI,KAAK,CAAC;QAAE,IAAI,EAAE,MAAM,CAAC;QAAC,UAAU,EAAE,MAAM,EAAE,CAAA;KAAE,CAAC;IAO7D;;OAEG;IACH,OAAO,IAAI,IAAI;IASf,OAAO,CAAC,YAAY;IAiBpB,OAAO,CAAC,YAAY;CAYrB"}

package/dist/libs/decoder-registry.class.js

@@ -0,0 +1,138 @@
+"use strict";
+/**
+ * DecoderRegistry — Auto-selects the best StructuralDecoder for each file.
+ *
+ * Priority:
+ *   1. TypeScriptDecoder (ts-morph) for .ts/.tsx/.js/.jsx
+ *   2. FallbackDecoder (regex) for Python/Java/Go/Rust/C#/Ruby/PHP
+ *   3. null for unsupported files
+ *
+ * Caches decoder instances. Thread-safe for single-threaded Node.
+ */
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DecoderRegistry = void 0;
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+const typescript_decoder_class_1 = require("./typescript-decoder.class");
+const fallback_decoder_class_1 = require("./fallback-decoder.class");
+const resource_decoder_class_1 = require("./resource-decoder.class");
+class DecoderRegistry {
+    decoders = [];
+    config;
+    constructor(config) {
+        this.config = config;
+        this.initDecoders();
+    }
+    /**
+     * Find the best decoder for a file, or null if unsupported.
+     */
+    getDecoder(filePath, content) {
+        for (const decoder of this.decoders) {
+            if (decoder.canDecode(filePath, content))
+                return decoder;
+        }
+        return null;
+    }
+    /**
+     * Decode a file using the best available decoder.
+     * Returns null if no decoder handles this file type.
+     */
+    decode(filePath, content) {
+        const decoder = this.getDecoder(filePath, content);
+        if (!decoder)
+            return null;
+        return decoder.decode(filePath, content, this.config.projectRoot);
+    }
+    /**
+     * Decode a file from disk.
+     */
+    decodeFile(relativeFilePath) {
+        const absPath = path.join(this.config.projectRoot, relativeFilePath);
+        if (!fs.existsSync(absPath))
+            return null;
+        const content = fs.readFileSync(absPath, "utf-8");
+        return this.decode(relativeFilePath, content);
+    }
+    /**
+     * List all decoder names and their supported extensions.
+     */
+    listDecoders() {
+        return this.decoders.map((d) => ({
+            name: d.name,
+            extensions: d.supportedExtensions,
+        }));
+    }
+    /**
+     * Dispose all decoder resources.
+     */
+    dispose() {
+        for (const decoder of this.decoders) {
+            decoder.dispose?.();
+        }
+        this.decoders = [];
+    }
+    // ── Initialization ────────────────────────────────────────────────────
+    initDecoders() {
+        // TypeScript decoder (highest priority for TS/JS files)
+        // Always add unless explicitly disabled — works without tsconfig via in-memory parsing
+        if (this.config.enableTypeScript !== false) {
+            const tsconfigPath = this.findTsConfig();
+            this.decoders.push(new typescript_decoder_class_1.TypeScriptDecoder(tsconfigPath ?? undefined));
+        }
+        // Resource decoder (SQL, Prisma, Docker, GraphQL, Proto, YAML, etc.)
+        this.decoders.push(new resource_decoder_class_1.ResourceDecoder());
+        // Fallback decoder (regex-based, for everything else)
+        if (this.config.enableTreeSitter !== false) {
+            this.decoders.push(new fallback_decoder_class_1.FallbackDecoder());
+        }
+    }
+    findTsConfig() {
+        if (this.config.tsconfigPath) {
+            if (fs.existsSync(this.config.tsconfigPath))
+                return this.config.tsconfigPath;
+        }
+        // Auto-detect tsconfig.json in project root
+        const candidates = ["tsconfig.json", "tsconfig.build.json"];
+        for (const name of candidates) {
+            const p = path.join(this.config.projectRoot, name);
+            if (fs.existsSync(p))
+                return p;
+        }
+        return null;
+    }
+}
+exports.DecoderRegistry = DecoderRegistry;
+//# sourceMappingURL=decoder-registry.class.js.map

package/dist/libs/decoder-registry.class.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"decoder-registry.class.js","sourceRoot":"","sources":["../../src/libs/decoder-registry.class.ts"],"names":[],"mappings":"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"}

package/dist/libs/distributed-execution.d.ts

@@ -0,0 +1,122 @@
+import EventEmitter from "events";
+export declare enum NodeStatus {
+    HEALTHY = "healthy",
+    DEGRADED = "degraded",
+    UNHEALTHY = "unhealthy",
+    OFFLINE = "offline"
+}
+export declare enum TaskStatus {
+    PENDING = "pending",
+    ASSIGNED = "assigned",
+    RUNNING = "running",
+    COMPLETED = "completed",
+    FAILED = "failed",
+    CANCELLED = "cancelled"
+}
+export declare enum ConsensusType {
+    QUORUM = "quorum",
+    MAJORITY = "majority",
+    UNANIMOUS = "unanimous",
+    LEADER = "leader"
+}
+export interface Node {
+    id: string;
+    address: string;
+    port: number;
+    status: NodeStatus;
+    lastHeartbeat: number;
+    capacity: number;
+    currentLoad: number;
+    cpuUsage: number;
+    memoryUsage: number;
+}
+export interface DistributedTask {
+    id: string;
+    nodeId?: string;
+    status: TaskStatus;
+    priority: number;
+    estimatedDuration: number;
+    timeout: number;
+    result?: object;
+    error?: string;
+    retries: number;
+    maxRetries: number;
+    createdAt: number;
+    startedAt?: number;
+    completedAt?: number;
+}
+export interface ConsensusResult {
+    agreed: boolean;
+    participantCount: number;
+    agreeCount: number;
+    disagreementReasons: string[];
+}
+export interface NodeMetrics {
+    nodeId: string;
+    totalTasks: number;
+    completedTasks: number;
+    failedTasks: number;
+    avgExecutionTime: number;
+    successRate: number;
+}
+export declare class Node {
+    id: string;
+    address: string;
+    port: number;
+    status: NodeStatus;
+    lastHeartbeat: number;
+    capacity: number;
+    currentLoad: number;
+    cpuUsage: number;
+    memoryUsage: number;
+    constructor(id: string, address: string, port: number, capacity: number);
+    isAvailable(): boolean;
+    getAvailableCapacity(): number;
+}
+export declare class DistributedExecutor extends EventEmitter {
+    private nodes;
+    private tasks;
+    private nodeMetrics;
+    private consensusRequirements;
+    private heartbeatInterval;
+    private heartbeatTimeout;
+    private taskQueue;
+    private maxQueueSize;
+    constructor();
+    addNode(id: string, address: string, port: number, capacity: number): Node;
+    removeNode(id: string): boolean;
+    getNode(id: string): Node | undefined;
+    getAllNodes(): Node[];
+    getHealthyNodes(): Node[];
+    createTask(id: string, priority?: number, estimatedDuration?: number, timeout?: number, maxRetries?: number): DistributedTask;
+    assignTask(taskId: string, nodeId: string): boolean;
+    completeTask(taskId: string, result?: object, error?: string): DistributedTask | undefined;
+    retryTask(taskId: string): boolean;
+    getTask(id: string): DistributedTask | undefined;
+    getAllTasks(): DistributedTask[];
+    getTasksByStatus(status: TaskStatus): DistributedTask[];
+    getQueuedTasks(limit?: number): DistributedTask[];
+    selectNodeForTask(task: DistributedTask): Node | undefined;
+    requestConsensus(taskId: string, consensusType?: ConsensusType, timeout?: number): Promise<ConsensusResult>;
+    distributeTask(taskId: string): boolean;
+    getNodeMetrics(nodeId: string): NodeMetrics | undefined;
+    getAllMetrics(): NodeMetrics[];
+    getAverageNodeMetrics(): {
+        avgTasksPerNode: number;
+        avgSuccessRate: number;
+        avgExecutionTime: number;
+    };
+    private startHeartbeatMonitor;
+    recordHeartbeat(nodeId: string): boolean;
+    updateNodeMetrics(nodeId: string, cpuUsage: number, memoryUsage: number): boolean;
+    clearCompletedTasks(olderThan?: number): number;
+    shutdown(): void;
+}
+export declare class DistributedExecutorBuilder {
+    private executor;
+    private nodeConfigs;
+    constructor();
+    addNode(id: string, address: string, port: number, capacity: number): this;
+    build(): DistributedExecutor;
+}
+//# sourceMappingURL=distributed-execution.d.ts.map

package/dist/libs/distributed-execution.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"distributed-execution.d.ts","sourceRoot":"","sources":["../../src/libs/distributed-execution.ts"],"names":[],"mappings":"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"}

package/dist/libs/distributed-execution.js

@@ -0,0 +1,360 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DistributedExecutorBuilder = exports.DistributedExecutor = exports.Node = exports.ConsensusType = exports.TaskStatus = exports.NodeStatus = void 0;
+const events_1 = __importDefault(require("events"));
+var NodeStatus;
+(function (NodeStatus) {
+    NodeStatus["HEALTHY"] = "healthy";
+    NodeStatus["DEGRADED"] = "degraded";
+    NodeStatus["UNHEALTHY"] = "unhealthy";
+    NodeStatus["OFFLINE"] = "offline";
+})(NodeStatus || (exports.NodeStatus = NodeStatus = {}));
+var TaskStatus;
+(function (TaskStatus) {
+    TaskStatus["PENDING"] = "pending";
+    TaskStatus["ASSIGNED"] = "assigned";
+    TaskStatus["RUNNING"] = "running";
+    TaskStatus["COMPLETED"] = "completed";
+    TaskStatus["FAILED"] = "failed";
+    TaskStatus["CANCELLED"] = "cancelled";
+})(TaskStatus || (exports.TaskStatus = TaskStatus = {}));
+var ConsensusType;
+(function (ConsensusType) {
+    ConsensusType["QUORUM"] = "quorum";
+    ConsensusType["MAJORITY"] = "majority";
+    ConsensusType["UNANIMOUS"] = "unanimous";
+    ConsensusType["LEADER"] = "leader";
+})(ConsensusType || (exports.ConsensusType = ConsensusType = {}));
+class Node {
+    id;
+    address;
+    port;
+    status = NodeStatus.HEALTHY;
+    lastHeartbeat = Date.now();
+    capacity;
+    currentLoad = 0;
+    cpuUsage = 0;
+    memoryUsage = 0;
+    constructor(id, address, port, capacity) {
+        this.id = id;
+        this.address = address;
+        this.port = port;
+        this.capacity = capacity;
+    }
+    isAvailable() {
+        return (this.status === NodeStatus.HEALTHY &&
+            this.currentLoad < this.capacity);
+    }
+    getAvailableCapacity() {
+        return Math.max(0, this.capacity - this.currentLoad);
+    }
+}
+exports.Node = Node;
+class DistributedExecutor extends events_1.default {
+    nodes = new Map();
+    tasks = new Map();
+    nodeMetrics = new Map();
+    consensusRequirements = new Map();
+    heartbeatInterval = 5000;
+    heartbeatTimeout = 15000;
+    taskQueue = [];
+    maxQueueSize = 10000;
+    constructor() {
+        super();
+        this.startHeartbeatMonitor();
+    }
+    addNode(id, address, port, capacity) {
+        const node = new Node(id, address, port, capacity);
+        this.nodes.set(id, node);
+        this.nodeMetrics.set(id, {
+            nodeId: id,
+            totalTasks: 0,
+            completedTasks: 0,
+            failedTasks: 0,
+            avgExecutionTime: 0,
+            successRate: 0,
+        });
+        this.emit("node:added", node);
+        return node;
+    }
+    removeNode(id) {
+        const result = this.nodes.delete(id);
+        if (result) {
+            this.nodeMetrics.delete(id);
+            this.emit("node:removed", id);
+        }
+        return result;
+    }
+    getNode(id) {
+        return this.nodes.get(id);
+    }
+    getAllNodes() {
+        return Array.from(this.nodes.values());
+    }
+    getHealthyNodes() {
+        return this.getAllNodes().filter((n) => n.isAvailable());
+    }
+    createTask(id, priority = 5, estimatedDuration = 5000, timeout = 30000, maxRetries = 3) {
+        const task = {
+            id,
+            status: TaskStatus.PENDING,
+            priority,
+            estimatedDuration,
+            timeout,
+            result: undefined,
+            error: undefined,
+            retries: 0,
+            maxRetries,
+            createdAt: Date.now(),
+        };
+        this.tasks.set(id, task);
+        if (this.taskQueue.length < this.maxQueueSize) {
+            this.taskQueue.push(task);
+            this.taskQueue.sort((a, b) => b.priority - a.priority);
+        }
+        this.emit("task:created", task);
+        return task;
+    }
+    assignTask(taskId, nodeId) {
+        const task = this.tasks.get(taskId);
+        const node = this.nodes.get(nodeId);
+        if (!task || !node || !node.isAvailable()) {
+            return false;
+        }
+        task.nodeId = nodeId;
+        task.status = TaskStatus.ASSIGNED;
+        task.startedAt = Date.now();
+        node.currentLoad += 1;
+        this.emit("task:assigned", { task, node });
+        return true;
+    }
+    completeTask(taskId, result, error) {
+        const task = this.tasks.get(taskId);
+        if (!task || !task.nodeId)
+            return undefined;
+        const node = this.nodes.get(task.nodeId);
+        if (node) {
+            node.currentLoad = Math.max(0, node.currentLoad - 1);
+        }
+        task.status = error ? TaskStatus.FAILED : TaskStatus.COMPLETED;
+        task.result = result;
+        task.error = error;
+        task.completedAt = Date.now();
+        const metrics = this.nodeMetrics.get(task.nodeId);
+        if (metrics) {
+            metrics.totalTasks += 1;
+            if (error) {
+                metrics.failedTasks += 1;
+            }
+            else {
+                metrics.completedTasks += 1;
+            }
+            metrics.successRate = metrics.completedTasks / metrics.totalTasks;
+            if (task.startedAt) {
+                const avgTime = metrics.avgExecutionTime;
+                const execTime = task.completedAt - task.startedAt;
+                metrics.avgExecutionTime =
+                    (avgTime * (metrics.totalTasks - 1) + execTime) / metrics.totalTasks;
+            }
+        }
+        this.emit(error ? "task:failed" : "task:completed", task);
+        return task;
+    }
+    retryTask(taskId) {
+        const task = this.tasks.get(taskId);
+        if (!task || task.retries >= task.maxRetries || task.status === TaskStatus.COMPLETED) {
+            return false;
+        }
+        task.retries += 1;
+        task.status = TaskStatus.PENDING;
+        task.nodeId = undefined;
+        task.error = undefined;
+        const node = this.nodes.get(task.nodeId || "");
+        if (node) {
+            node.currentLoad = Math.max(0, node.currentLoad - 1);
+        }
+        this.taskQueue.push(task);
+        this.taskQueue.sort((a, b) => b.priority - a.priority);
+        this.emit("task:retried", task);
+        return true;
+    }
+    getTask(id) {
+        return this.tasks.get(id);
+    }
+    getAllTasks() {
+        return Array.from(this.tasks.values());
+    }
+    getTasksByStatus(status) {
+        return this.getAllTasks().filter((t) => t.status === status);
+    }
+    getQueuedTasks(limit = 100) {
+        return this.taskQueue.slice(0, limit);
+    }
+    selectNodeForTask(task) {
+        const healthyNodes = this.getHealthyNodes();
+        if (healthyNodes.length === 0)
+            return undefined;
+        // Load balancing: select node with least load
+        return healthyNodes.reduce((a, b) => a.currentLoad < b.currentLoad ? a : b);
+    }
+    async requestConsensus(taskId, consensusType = ConsensusType.MAJORITY, timeout = 10000) {
+        const healthy = this.getHealthyNodes();
+        const participantCount = healthy.length;
+        if (participantCount === 0) {
+            return {
+                agreed: false,
+                participantCount: 0,
+                agreeCount: 0,
+                disagreementReasons: ["No healthy nodes available"],
+            };
+        }
+        let requiredVotes = 1;
+        if (consensusType === ConsensusType.UNANIMOUS) {
+            requiredVotes = participantCount;
+        }
+        else if (consensusType === ConsensusType.MAJORITY) {
+            requiredVotes = Math.floor(participantCount / 2) + 1;
+        }
+        else if (consensusType === ConsensusType.QUORUM) {
+            requiredVotes = Math.ceil(participantCount / 2);
+        }
+        // Simulate consensus voting
+        const votes = healthy.map((n) => {
+            const agreement = Math.random() > 0.1; // 90% agreement probability
+            return { nodeId: n.id, agreed: agreement };
+        });
+        const agreeCount = votes.filter((v) => v.agreed).length;
+        const agreed = agreeCount >= requiredVotes;
+        const result = {
+            agreed,
+            participantCount,
+            agreeCount,
+            disagreementReasons: votes
+                .filter((v) => !v.agreed)
+                .map((v) => `Node ${v.nodeId} disagreed`),
+        };
+        this.emit("consensus:complete", result);
+        return result;
+    }
+    distributeTask(taskId) {
+        const task = this.tasks.get(taskId);
+        if (!task)
+            return false;
+        const selectedNode = this.selectNodeForTask(task);
+        if (!selectedNode) {
+            return false;
+        }
+        return this.assignTask(taskId, selectedNode.id);
+    }
+    getNodeMetrics(nodeId) {
+        return this.nodeMetrics.get(nodeId);
+    }
+    getAllMetrics() {
+        return Array.from(this.nodeMetrics.values());
+    }
+    getAverageNodeMetrics() {
+        const metrics = this.getAllMetrics();
+        if (metrics.length === 0) {
+            return {
+                avgTasksPerNode: 0,
+                avgSuccessRate: 0,
+                avgExecutionTime: 0,
+            };
+        }
+        const avgTasks = metrics.reduce((sum, m) => sum + m.totalTasks, 0) / metrics.length;
+        const avgSuccess = metrics.reduce((sum, m) => sum + m.successRate, 0) / metrics.length;
+        const avgTime = metrics.reduce((sum, m) => sum + m.avgExecutionTime, 0) / metrics.length;
+        return {
+            avgTasksPerNode: avgTasks,
+            avgSuccessRate: avgSuccess,
+            avgExecutionTime: avgTime,
+        };
+    }
+    startHeartbeatMonitor() {
+        setInterval(() => {
+            const now = Date.now();
+            for (const [, node] of this.nodes) {
+                if (now - node.lastHeartbeat > this.heartbeatTimeout) {
+                    if (node.status !== NodeStatus.OFFLINE) {
+                        node.status = NodeStatus.OFFLINE;
+                        this.emit("node:offline", node);
+                    }
+                }
+            }
+        }, this.heartbeatInterval);
+    }
+    recordHeartbeat(nodeId) {
+        const node = this.nodes.get(nodeId);
+        if (!node)
+            return false;
+        const wasOffline = node.status === NodeStatus.OFFLINE;
+        node.lastHeartbeat = Date.now();
+        node.status = NodeStatus.HEALTHY;
+        if (wasOffline) {
+            this.emit("node:recovered", node);
+        }
+        return true;
+    }
+    updateNodeMetrics(nodeId, cpuUsage, memoryUsage) {
+        const node = this.nodes.get(nodeId);
+        if (!node)
+            return false;
+        node.cpuUsage = cpuUsage;
+        node.memoryUsage = memoryUsage;
+        if (cpuUsage > 85 || memoryUsage > 85) {
+            if (node.status === NodeStatus.HEALTHY) {
+                node.status = NodeStatus.DEGRADED;
+                this.emit("node:degraded", node);
+            }
+        }
+        else if (node.status === NodeStatus.DEGRADED) {
+            node.status = NodeStatus.HEALTHY;
+            this.emit("node:recovered", node);
+        }
+        return true;
+    }
+    clearCompletedTasks(olderThan = 3600000) {
+        const now = Date.now();
+        let cleared = 0;
+        for (const [id, task] of this.tasks) {
+            if (task.completedAt &&
+                now - task.completedAt > olderThan &&
+                (task.status === TaskStatus.COMPLETED ||
+                    task.status === TaskStatus.FAILED)) {
+                this.tasks.delete(id);
+                cleared++;
+            }
+        }
+        return cleared;
+    }
+    shutdown() {
+        this.tasks.clear();
+        this.nodes.clear();
+        this.nodeMetrics.clear();
+        this.taskQueue = [];
+        this.emit("executor:shutdown");
+    }
+}
+exports.DistributedExecutor = DistributedExecutor;
+class DistributedExecutorBuilder {
+    executor;
+    nodeConfigs = [];
+    constructor() {
+        this.executor = new DistributedExecutor();
+    }
+    addNode(id, address, port, capacity) {
+        this.nodeConfigs.push({ id, address, port, capacity });
+        return this;
+    }
+    build() {
+        for (const config of this.nodeConfigs) {
+            this.executor.addNode(config.id, config.address, config.port, config.capacity);
+        }
+        return this.executor;
+    }
+}
+exports.DistributedExecutorBuilder = DistributedExecutorBuilder;
+//# sourceMappingURL=distributed-execution.js.map