@ebowwa/glm-daemon 0.1.0

package/src/hooks.ts

@@ -0,0 +1,94 @@
+/**
+ * GLM Daemon - Hook System
+ *
+ * Implements hook lifecycle for daemon events.
+ * Based on Claude Code's hook system.
+ */
+
+import type { GLMHooksConfig, GLMDaemonState } from "./types.js";
+
+type GLMHookHandler = (
+  ...args: unknown[]
+) => Promise<unknown> | unknown;
+
+export class HookSystem {
+  private hooks: Map<string, GLMHookHandler[]> = new Map();
+
+  constructor(config: GLMHooksConfig) {
+    // Register hooks from config
+    if (config.onSessionStart) {
+      this.register("onSessionStart", config.onSessionStart as GLMHookHandler);
+    }
+    if (config.onSessionEnd) {
+      this.register("onSessionEnd", config.onSessionEnd as GLMHookHandler);
+    }
+    if (config.onPreToolUse) {
+      this.register("onPreToolUse", config.onPreToolUse as GLMHookHandler);
+    }
+    if (config.onPostToolUse) {
+      this.register("onPostToolUse", config.onPostToolUse as GLMHookHandler);
+    }
+    if (config.onSubagentStart) {
+      this.register("onSubagentStart", config.onSubagentStart as GLMHookHandler);
+    }
+    if (config.onSubagentStop) {
+      this.register("onSubagentStop", config.onSubagentStop as GLMHookHandler);
+    }
+    if (config.onIterationStart) {
+      this.register("onIterationStart", config.onIterationStart as GLMHookHandler);
+    }
+    if (config.onIterationEnd) {
+      this.register("onIterationEnd", config.onIterationEnd as GLMHookHandler);
+    }
+  }
+
+  /**
+   * Register a hook handler
+   */
+  register(event: string, handler: GLMHookHandler): void {
+    if (!this.hooks.has(event)) {
+      this.hooks.set(event, []);
+    }
+    this.hooks.get(event)!.push(handler);
+  }
+
+  /**
+   * Execute all handlers for an event
+   */
+  async execute(event: string, ...args: unknown[]): Promise<void> {
+    const handlers = this.hooks.get(event);
+    if (!handlers) {
+      return;
+    }
+
+    for (const handler of handlers) {
+      try {
+        await handler(...args);
+      } catch (error) {
+        console.error(`[HookSystem] Error in ${event}:`, error);
+        // Continue executing other hooks even if one fails
+      }
+    }
+  }
+
+  /**
+   * Remove all handlers for an event
+   */
+  clear(event: string): void {
+    this.hooks.delete(event);
+  }
+
+  /**
+   * Remove all hooks
+   */
+  clearAll(): void {
+    this.hooks.clear();
+  }
+
+  /**
+   * Get registered events
+   */
+  getEvents(): string[] {
+    return Array.from(this.hooks.keys());
+  }
+}

package/src/index.js

@@ -0,0 +1,105 @@
+"use strict";
+/**
+ * GLM Daemon - Autonomous GLM 4.7 Agent Daemon
+ *
+ * A daemon for autonomous AI agents powered by GLM 4.7.
+ * Implements SLAM pattern (State → Loop → Action → Memory).
+ * Supports hooks, tools via MCP, and multi-agent coordination.
+ *
+ * @module @ebowwa/glm-daemon
+ */
+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 __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+var __generator = (this && this.__generator) || function (thisArg, body) {
+    var _ = { label: 0, sent: function() { if (t[0] & 1) throw t[1]; return t[1]; }, trys: [], ops: [] }, f, y, t, g = Object.create((typeof Iterator === "function" ? Iterator : Object).prototype);
+    return g.next = verb(0), g["throw"] = verb(1), g["return"] = verb(2), typeof Symbol === "function" && (g[Symbol.iterator] = function() { return this; }), g;
+    function verb(n) { return function (v) { return step([n, v]); }; }
+    function step(op) {
+        if (f) throw new TypeError("Generator is already executing.");
+        while (g && (g = 0, op[0] && (_ = 0)), _) try {
+            if (f = 1, y && (t = op[0] & 2 ? y["return"] : op[0] ? y["throw"] || ((t = y["return"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done) return t;
+            if (y = 0, t) op = [op[0] & 2, t.value];
+            switch (op[0]) {
+                case 0: case 1: t = op; break;
+                case 4: _.label++; return { value: op[1], done: false };
+                case 5: _.label++; y = op[1]; op = [0]; continue;
+                case 7: op = _.ops.pop(); _.trys.pop(); continue;
+                default:
+                    if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) { _ = 0; continue; }
+                    if (op[0] === 3 && (!t || (op[1] > t[0] && op[1] < t[3]))) { _.label = op[1]; break; }
+                    if (op[0] === 6 && _.label < t[1]) { _.label = t[1]; t = op; break; }
+                    if (t && _.label < t[2]) { _.label = t[2]; _.ops.push(op); break; }
+                    if (t[2]) _.ops.pop();
+                    _.trys.pop(); continue;
+            }
+            op = body.call(thisArg, _);
+        } catch (e) { op = [6, e]; y = 0; } finally { f = t = 0; }
+        if (op[0] & 5) throw op[1]; return { value: op[0] ? op[1] : void 0, done: true };
+    }
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.WorktreeManager = exports.StateManager = exports.ToolBridge = exports.HookSystem = exports.GLMAgent = exports.GLMDaemon = void 0;
+exports.createGLMDaemon = createGLMDaemon;
+exports.startGLMDaemon = startGLMDaemon;
+// Main daemon class
+var daemon_js_1 = require("./daemon.js");
+Object.defineProperty(exports, "GLMDaemon", { enumerable: true, get: function () { return daemon_js_1.GLMDaemon; } });
+// Agent class
+var agent_js_1 = require("./agent.js");
+Object.defineProperty(exports, "GLMAgent", { enumerable: true, get: function () { return agent_js_1.GLMAgent; } });
+// Supporting systems
+var hooks_js_1 = require("./hooks.js");
+Object.defineProperty(exports, "HookSystem", { enumerable: true, get: function () { return hooks_js_1.HookSystem; } });
+var tools_js_1 = require("./tools.js");
+Object.defineProperty(exports, "ToolBridge", { enumerable: true, get: function () { return tools_js_1.ToolBridge; } });
+var state_js_1 = require("./state.js");
+Object.defineProperty(exports, "StateManager", { enumerable: true, get: function () { return state_js_1.StateManager; } });
+var worktree_js_1 = require("./worktree.js");
+Object.defineProperty(exports, "WorktreeManager", { enumerable: true, get: function () { return worktree_js_1.WorktreeManager; } });
+// Types
+__exportStar(require("./types.js"), exports);
+// Convenience function to create and start a daemon
+var daemon_js_2 = require("./daemon.js");
+function createGLMDaemon(config) {
+    return __awaiter(this, void 0, void 0, function () {
+        var daemon;
+        return __generator(this, function (_a) {
+            daemon = new daemon_js_2.GLMDaemon(config);
+            return [2 /*return*/, daemon];
+        });
+    });
+}
+function startGLMDaemon(config, prompt) {
+    return __awaiter(this, void 0, void 0, function () {
+        var daemon;
+        return __generator(this, function (_a) {
+            switch (_a.label) {
+                case 0:
+                    daemon = new daemon_js_2.GLMDaemon(config);
+                    return [4 /*yield*/, daemon.start(prompt)];
+                case 1: return [2 /*return*/, _a.sent()];
+            }
+        });
+    });
+}

package/src/index.ts

@@ -0,0 +1,43 @@
+/**
+ * GLM Daemon - Autonomous GLM 4.7 Agent Daemon
+ *
+ * A daemon for autonomous AI agents powered by GLM 4.7.
+ * Implements SLAM pattern (State → Loop → Action → Memory).
+ * Supports hooks, tools via MCP, and multi-agent coordination.
+ *
+ * @module @ebowwa/glm-daemon
+ */
+
+// Main daemon class
+export { GLMDaemon } from "./daemon.js";
+
+// Agent class
+export { GLMAgent } from "./agent.js";
+
+// Supporting systems
+export { HookSystem } from "./hooks.js";
+export { ToolBridge } from "./tools.js";
+export { StateManager } from "./state.js";
+export { WorktreeManager } from "./worktree.js";
+
+// Types
+export * from "./types.js";
+
+// Convenience function to create and start a daemon
+import { GLMDaemon } from "./daemon.js";
+import type { GLMDaemonConfig } from "./types.js";
+
+export async function createGLMDaemon(
+  config: GLMDaemonConfig
+): Promise<GLMDaemon> {
+  const daemon = new GLMDaemon(config);
+  return daemon;
+}
+
+export async function startGLMDaemon(
+  config: GLMDaemonConfig,
+  prompt: string
+): Promise<string> {
+  const daemon = new GLMDaemon(config);
+  return await daemon.start(prompt);
+}

package/src/state.js

@@ -0,0 +1,168 @@
+"use strict";
+/**
+ * GLM Daemon - State Manager
+ *
+ * Manages SLAM state persistence to disk.
+ */
+var __assign = (this && this.__assign) || function () {
+    __assign = Object.assign || function(t) {
+        for (var s, i = 1, n = arguments.length; i < n; i++) {
+            s = arguments[i];
+            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
+                t[p] = s[p];
+        }
+        return t;
+    };
+    return __assign.apply(this, arguments);
+};
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+var __generator = (this && this.__generator) || function (thisArg, body) {
+    var _ = { label: 0, sent: function() { if (t[0] & 1) throw t[1]; return t[1]; }, trys: [], ops: [] }, f, y, t, g = Object.create((typeof Iterator === "function" ? Iterator : Object).prototype);
+    return g.next = verb(0), g["throw"] = verb(1), g["return"] = verb(2), typeof Symbol === "function" && (g[Symbol.iterator] = function() { return this; }), g;
+    function verb(n) { return function (v) { return step([n, v]); }; }
+    function step(op) {
+        if (f) throw new TypeError("Generator is already executing.");
+        while (g && (g = 0, op[0] && (_ = 0)), _) try {
+            if (f = 1, y && (t = op[0] & 2 ? y["return"] : op[0] ? y["throw"] || ((t = y["return"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done) return t;
+            if (y = 0, t) op = [op[0] & 2, t.value];
+            switch (op[0]) {
+                case 0: case 1: t = op; break;
+                case 4: _.label++; return { value: op[1], done: false };
+                case 5: _.label++; y = op[1]; op = [0]; continue;
+                case 7: op = _.ops.pop(); _.trys.pop(); continue;
+                default:
+                    if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) { _ = 0; continue; }
+                    if (op[0] === 3 && (!t || (op[1] > t[0] && op[1] < t[3]))) { _.label = op[1]; break; }
+                    if (op[0] === 6 && _.label < t[1]) { _.label = t[1]; t = op; break; }
+                    if (t && _.label < t[2]) { _.label = t[2]; _.ops.push(op); break; }
+                    if (t[2]) _.ops.pop();
+                    _.trys.pop(); continue;
+            }
+            op = body.call(thisArg, _);
+        } catch (e) { op = [6, e]; y = 0; } finally { f = t = 0; }
+        if (op[0] & 5) throw op[1]; return { value: op[0] ? op[1] : void 0, done: true };
+    }
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.StateManager = void 0;
+var fs_1 = require("fs");
+var StateManager = /** @class */ (function () {
+    function StateManager(statePath) {
+        this.statePath = statePath;
+    }
+    /**
+     * Load state from disk
+     */
+    StateManager.prototype.load = function () {
+        return __awaiter(this, void 0, void 0, function () {
+            var content, _a;
+            return __generator(this, function (_b) {
+                switch (_b.label) {
+                    case 0:
+                        _b.trys.push([0, 2, , 3]);
+                        return [4 /*yield*/, fs_1.promises.readFile(this.statePath, "utf-8")];
+                    case 1:
+                        content = _b.sent();
+                        return [2 /*return*/, JSON.parse(content)];
+                    case 2:
+                        _a = _b.sent();
+                        // File doesn't exist or invalid JSON
+                        return [2 /*return*/, null];
+                    case 3: return [2 /*return*/];
+                }
+            });
+        });
+    };
+    /**
+     * Save state to disk
+     */
+    StateManager.prototype.save = function (state) {
+        return __awaiter(this, void 0, void 0, function () {
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0: return [4 /*yield*/, fs_1.promises.writeFile(this.statePath, JSON.stringify(state, null, 2), "utf-8")];
+                    case 1:
+                        _a.sent();
+                        return [2 /*return*/];
+                }
+            });
+        });
+    };
+    /**
+     * Delete state file
+     */
+    StateManager.prototype.delete = function () {
+        return __awaiter(this, void 0, void 0, function () {
+            var _a;
+            return __generator(this, function (_b) {
+                switch (_b.label) {
+                    case 0:
+                        _b.trys.push([0, 2, , 3]);
+                        return [4 /*yield*/, fs_1.promises.unlink(this.statePath)];
+                    case 1:
+                        _b.sent();
+                        return [3 /*break*/, 3];
+                    case 2:
+                        _a = _b.sent();
+                        return [3 /*break*/, 3];
+                    case 3: return [2 /*return*/];
+                }
+            });
+        });
+    };
+    /**
+     * Check if state file exists
+     */
+    StateManager.prototype.exists = function () {
+        return __awaiter(this, void 0, void 0, function () {
+            var _a;
+            return __generator(this, function (_b) {
+                switch (_b.label) {
+                    case 0:
+                        _b.trys.push([0, 2, , 3]);
+                        return [4 /*yield*/, fs_1.promises.access(this.statePath)];
+                    case 1:
+                        _b.sent();
+                        return [2 /*return*/, true];
+                    case 2:
+                        _a = _b.sent();
+                        return [2 /*return*/, false];
+                    case 3: return [2 /*return*/];
+                }
+            });
+        });
+    };
+    /**
+     * Update a portion of state (merge)
+     */
+    StateManager.prototype.update = function (updates) {
+        return __awaiter(this, void 0, void 0, function () {
+            var current, updated;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0: return [4 /*yield*/, this.load()];
+                    case 1:
+                        current = _a.sent();
+                        if (!current) {
+                            throw new Error("No existing state to update");
+                        }
+                        updated = __assign(__assign({}, current), updates);
+                        return [4 /*yield*/, this.save(updated)];
+                    case 2:
+                        _a.sent();
+                        return [2 /*return*/, updated];
+                }
+            });
+        });
+    };
+    return StateManager;
+}());
+exports.StateManager = StateManager;

package/src/state.ts

@@ -0,0 +1,77 @@
+/**
+ * GLM Daemon - State Manager
+ *
+ * Manages SLAM state persistence to disk.
+ */
+
+import { promises as fsp } from "fs";
+import type { GLMDaemonState } from "./types.js";
+
+export class StateManager {
+  private statePath: string;
+
+  constructor(statePath: string) {
+    this.statePath = statePath;
+  }
+
+  /**
+   * Load state from disk
+   */
+  async load(): Promise<GLMDaemonState | null> {
+    try {
+      const content = await fsp.readFile(this.statePath, "utf-8");
+      return JSON.parse(content) as GLMDaemonState;
+    } catch {
+      // File doesn't exist or invalid JSON
+      return null;
+    }
+  }
+
+  /**
+   * Save state to disk
+   */
+  async save(state: GLMDaemonState): Promise<void> {
+    await fsp.writeFile(
+      this.statePath,
+      JSON.stringify(state, null, 2),
+      "utf-8"
+    );
+  }
+
+  /**
+   * Delete state file
+   */
+  async delete(): Promise<void> {
+    try {
+      await fsp.unlink(this.statePath);
+    } catch {
+      // File doesn't exist, ignore
+    }
+  }
+
+  /**
+   * Check if state file exists
+   */
+  async exists(): Promise<boolean> {
+    try {
+      await fsp.access(this.statePath);
+      return true;
+    } catch {
+      return false;
+    }
+  }
+
+  /**
+   * Update a portion of state (merge)
+   */
+  async update(updates: Partial<GLMDaemonState>): Promise<GLMDaemonState> {
+    const current = await this.load();
+    if (!current) {
+      throw new Error("No existing state to update");
+    }
+
+    const updated = { ...current, ...updates };
+    await this.save(updated);
+    return updated;
+  }
+}

package/src/tools.js

@@ -0,0 +1,192 @@
+"use strict";
+/**
+ * GLM Daemon - Tool Bridge
+ *
+ * Connects GLM agents to MCP servers for tool access.
+ */
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+var __generator = (this && this.__generator) || function (thisArg, body) {
+    var _ = { label: 0, sent: function() { if (t[0] & 1) throw t[1]; return t[1]; }, trys: [], ops: [] }, f, y, t, g = Object.create((typeof Iterator === "function" ? Iterator : Object).prototype);
+    return g.next = verb(0), g["throw"] = verb(1), g["return"] = verb(2), typeof Symbol === "function" && (g[Symbol.iterator] = function() { return this; }), g;
+    function verb(n) { return function (v) { return step([n, v]); }; }
+    function step(op) {
+        if (f) throw new TypeError("Generator is already executing.");
+        while (g && (g = 0, op[0] && (_ = 0)), _) try {
+            if (f = 1, y && (t = op[0] & 2 ? y["return"] : op[0] ? y["throw"] || ((t = y["return"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done) return t;
+            if (y = 0, t) op = [op[0] & 2, t.value];
+            switch (op[0]) {
+                case 0: case 1: t = op; break;
+                case 4: _.label++; return { value: op[1], done: false };
+                case 5: _.label++; y = op[1]; op = [0]; continue;
+                case 7: op = _.ops.pop(); _.trys.pop(); continue;
+                default:
+                    if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) { _ = 0; continue; }
+                    if (op[0] === 3 && (!t || (op[1] > t[0] && op[1] < t[3]))) { _.label = op[1]; break; }
+                    if (op[0] === 6 && _.label < t[1]) { _.label = t[1]; t = op; break; }
+                    if (t && _.label < t[2]) { _.label = t[2]; _.ops.push(op); break; }
+                    if (t[2]) _.ops.pop();
+                    _.trys.pop(); continue;
+            }
+            op = body.call(thisArg, _);
+        } catch (e) { op = [6, e]; y = 0; } finally { f = t = 0; }
+        if (op[0] & 5) throw op[1]; return { value: op[0] ? op[1] : void 0, done: true };
+    }
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ToolBridge = void 0;
+var ToolBridge = /** @class */ (function () {
+    function ToolBridge(config) {
+        if (config === void 0) { config = {}; }
+        this.availableTools = [];
+        this.config = config;
+        this.toolTimeout = config.toolTimeout || 30000;
+        this.maxRetries = config.maxRetries || 3;
+    }
+    /**
+     * Get list of available tools
+     */
+    ToolBridge.prototype.getAvailableTools = function () {
+        return this.availableTools;
+    };
+    /**
+     * Set available tools (from MCP discovery)
+     */
+    ToolBridge.prototype.setAvailableTools = function (tools) {
+        this.availableTools = tools;
+    };
+    /**
+     * Check if a tool is allowed
+     */
+    ToolBridge.prototype.isToolAllowed = function (toolName) {
+        var _a;
+        // Check blacklist first
+        if ((_a = this.config.blockedTools) === null || _a === void 0 ? void 0 : _a.includes(toolName)) {
+            return false;
+        }
+        // If whitelist exists, check it
+        if (this.config.allowedTools && this.config.allowedTools.length > 0) {
+            return this.config.allowedTools.includes(toolName);
+        }
+        // Default: allow if not blocked
+        return true;
+    };
+    /**
+     * Execute a tool with timeout and retry
+     */
+    ToolBridge.prototype.executeTool = function (toolName, args) {
+        return __awaiter(this, void 0, void 0, function () {
+            var lastError, _loop_1, this_1, attempt, state_1;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        if (!this.isToolAllowed(toolName)) {
+                            return [2 /*return*/, {
+                                    success: false,
+                                    error: "Tool not allowed: ".concat(toolName),
+                                }];
+                        }
+                        lastError = null;
+                        _loop_1 = function (attempt) {
+                            var result, error_1;
+                            return __generator(this, function (_b) {
+                                switch (_b.label) {
+                                    case 0:
+                                        _b.trys.push([0, 2, , 5]);
+                                        return [4 /*yield*/, this_1.executeWithTimeout(toolName, args)];
+                                    case 1:
+                                        result = _b.sent();
+                                        return [2 /*return*/, { value: { success: true, result: result } }];
+                                    case 2:
+                                        error_1 = _b.sent();
+                                        lastError = error_1;
+                                        if (!(attempt < this_1.maxRetries - 1)) return [3 /*break*/, 4];
+                                        return [4 /*yield*/, new Promise(function (resolve) {
+                                                return setTimeout(resolve, Math.pow(2, attempt) * 1000);
+                                            })];
+                                    case 3:
+                                        _b.sent();
+                                        _b.label = 4;
+                                    case 4: return [3 /*break*/, 5];
+                                    case 5: return [2 /*return*/];
+                                }
+                            });
+                        };
+                        this_1 = this;
+                        attempt = 0;
+                        _a.label = 1;
+                    case 1:
+                        if (!(attempt < this.maxRetries)) return [3 /*break*/, 4];
+                        return [5 /*yield**/, _loop_1(attempt)];
+                    case 2:
+                        state_1 = _a.sent();
+                        if (typeof state_1 === "object")
+                            return [2 /*return*/, state_1.value];
+                        _a.label = 3;
+                    case 3:
+                        attempt++;
+                        return [3 /*break*/, 1];
+                    case 4: return [2 /*return*/, {
+                            success: false,
+                            error: (lastError === null || lastError === void 0 ? void 0 : lastError.message) || "Unknown error",
+                        }];
+                }
+            });
+        });
+    };
+    /**
+     * Execute tool with timeout
+     */
+    ToolBridge.prototype.executeWithTimeout = function (toolName, args) {
+        return __awaiter(this, void 0, void 0, function () {
+            var _this = this;
+            return __generator(this, function (_a) {
+                return [2 /*return*/, new Promise(function (resolve, reject) {
+                        var timer = setTimeout(function () {
+                            reject(new Error("Tool timeout: ".concat(toolName)));
+                        }, _this.toolTimeout);
+                        // TODO: Actually call MCP tool here
+                        // For now, this is a placeholder
+                        setTimeout(function () {
+                            clearTimeout(timer);
+                            resolve("Executed ".concat(toolName, " with ").concat(JSON.stringify(args)));
+                        }, 100);
+                    })];
+            });
+        });
+    };
+    /**
+     * Discover tools from MCP servers
+     */
+    ToolBridge.prototype.discoverMCPTools = function () {
+        return __awaiter(this, void 0, void 0, function () {
+            var commonTools;
+            return __generator(this, function (_a) {
+                if (!this.config.enableMCP) {
+                    return [2 /*return*/];
+                }
+                commonTools = [
+                    "Read",
+                    "Write",
+                    "Edit",
+                    "Grep",
+                    "Glob",
+                    "Bash",
+                    "git_status",
+                    "git_commit",
+                ];
+                this.setAvailableTools(commonTools);
+                return [2 /*return*/];
+            });
+        });
+    };
+    return ToolBridge;
+}());
+exports.ToolBridge = ToolBridge;