@ebowwa/glm-daemon 0.3.2 → 0.4.0

package/src/daemon.ts

@@ -111,6 +111,13 @@ export class GLMDaemon {
         branchCreated: false,
         currentCommit: "",
       },
+      reflection: {
+        toolCount: 0,
+        totalToolCount: 0,
+        checkpointCount: 0,
+        lastReflection: null,
+        summaries: [],
+      },
     };
   }
 
@@ -181,7 +188,7 @@ Iteration: ${this.state.iteration}
   }
 
   /**
-   * Main daemon loop (SLAM pattern)
+   * Main daemon loop (SLAM pattern with reflection checkpoints)
    */
   private async runLoop(): Promise<void> {
     while (this.running) {
@@ -201,6 +208,12 @@ Iteration: ${this.state.iteration}
         break;
       }
 
+      // Check for reflection checkpoint (tool limit hit)
+      if (this.state.slam.phase === "reflecting") {
+        await this.executePhase();
+        continue;
+      }
+
       // Run iteration start hook
       await this.hooks.execute("onIterationStart", this.state.iteration);
 
@@ -232,6 +245,9 @@ Iteration: ${this.state.iteration}
       case "executing":
         await this.phaseExecuting();
         break;
+      case "reflecting":
+        await this.phaseReflecting();
+        break;
       case "paranoid":
         await this.phaseParanoid();
         break;
@@ -320,6 +336,130 @@ Focus on code changes, testing, and verification.
     }
   }
 
+  /**
+   * Reflecting phase - TL;DR checkpoint after N tools
+   * Pauses, summarizes progress, saves state, continues
+   */
+  private async phaseReflecting(): Promise<void> {
+    const reflectionConfig = this.config.reflection || {
+      enabled: true,
+      toolLimit: 50,
+      autoContinue: true,
+    };
+
+    console.log(`[GLMDaemon] Phase: Reflecting (checkpoint #${this.state.reflection.checkpointCount + 1})`);
+    console.log(`[GLMDaemon] Tools used this chunk: ${this.state.reflection.toolCount}`);
+
+    const previousPhase = this.state.slam.previousPhase || "executing";
+
+    const prompt = `REFLECTION CHECKPOINT #${this.state.reflection.checkpointCount + 1}
+
+You have used ${this.state.reflection.toolCount} tools. Pause and reflect.
+
+Task: ${this.state.prompt}
+Current Phase (before reflection): ${previousPhase}
+Iteration: ${this.state.iteration}
+Subtasks: ${this.state.slam.completedSubtasks.length}/${this.state.slam.subtasks.length} complete
+
+Files changed: ${this.state.filesChanged.length > 0 ? this.state.filesChanged.join(", ") : "none"}
+
+Generate a TL;DR summary in this JSON format:
+{
+  "summary": "1-2 sentence summary of progress",
+  "accomplishments": ["what was done"],
+  "nextSteps": ["what needs to be done next"],
+  "issues": ["any blockers or problems"]
+}
+
+Be concise. Focus on what matters for continuing the task.
+`;
+
+    const response = await this.agent.execute(prompt);
+    const summary = this.parseReflectionSummary(response, previousPhase);
+
+    // Update reflection state
+    this.state.reflection.checkpointCount++;
+    this.state.reflection.lastReflection = new Date().toISOString();
+    this.state.reflection.toolCount = 0; // Reset for next chunk
+    this.state.reflection.summaries.push(summary);
+
+    // Log the reflection
+    console.log(`[GLMDaemon] TL;DR: ${summary.summary}`);
+    console.log(`[GLMDaemon] Accomplishments: ${summary.accomplishments.join(", ")}`);
+    console.log(`[GLMDaemon] Next: ${summary.nextSteps.join(", ")}`);
+
+    // Run reflection hook
+    await this.hooks.execute("onReflection", this.state, summary);
+
+    // Save state
+    await this.stateManager.save(this.state);
+
+    // Return to previous phase (or continue executing)
+    if (reflectionConfig.autoContinue) {
+      this.state.slam.phase = previousPhase;
+      console.log(`[GLMDaemon] Continuing in phase: ${previousPhase}`);
+    }
+  }
+
+  /**
+   * Parse reflection summary from agent response
+   */
+  private parseReflectionSummary(response: string, phase: string): import("./types.js").GLMReflectionSummary {
+    try {
+      const jsonMatch = response.match(/\{[\s\S]*\}/);
+      if (jsonMatch) {
+        const parsed = JSON.parse(jsonMatch[0]);
+        return {
+          checkpoint: this.state.reflection.checkpointCount + 1,
+          timestamp: new Date().toISOString(),
+          toolsUsed: this.state.reflection.toolCount,
+          phase: phase as import("./types.js").GLMPhase,
+          summary: parsed.summary || "Progress made",
+          accomplishments: parsed.accomplishments || [],
+          nextSteps: parsed.nextSteps || [],
+          issues: parsed.issues || [],
+        };
+      }
+    } catch {
+      // Fallback
+    }
+
+    return {
+      checkpoint: this.state.reflection.checkpointCount + 1,
+      timestamp: new Date().toISOString(),
+      toolsUsed: this.state.reflection.toolCount,
+      phase: phase as import("./types.js").GLMPhase,
+      summary: response.substring(0, 200),
+      accomplishments: [],
+      nextSteps: [],
+      issues: [],
+    };
+  }
+
+  /**
+   * Increment tool count and check for reflection trigger
+   */
+  incrementToolCount(): boolean {
+    const reflectionConfig = this.config.reflection || {
+      enabled: true,
+      toolLimit: 50,
+      autoContinue: true,
+    };
+
+    this.state.reflection.toolCount++;
+    this.state.reflection.totalToolCount++;
+
+    // Check if we hit the limit
+    if (reflectionConfig.enabled && this.state.reflection.toolCount >= reflectionConfig.toolLimit) {
+      // Store current phase to return after reflection
+      this.state.slam.previousPhase = this.state.slam.phase;
+      this.state.slam.phase = "reflecting";
+      return true; // Reflection triggered
+    }
+
+    return false;
+  }
+
   /**
    * Paranoid phase - quality check after every edit
    */
@@ -468,6 +608,53 @@ Test your fixes thoroughly.
     };
   }
 
+  /**
+   * Get reflection status and summaries
+   */
+  getReflectionStatus(): {
+    enabled: boolean;
+    toolLimit: number;
+    toolCount: number;
+    totalToolCount: number;
+    checkpointCount: number;
+    lastReflection: string | null;
+    summaries: import("./types.js").GLMReflectionSummary[];
+  } {
+    const config = this.config.reflection || {
+      enabled: true,
+      toolLimit: 50,
+    };
+
+    return {
+      enabled: config.enabled,
+      toolLimit: config.toolLimit,
+      toolCount: this.state.reflection.toolCount,
+      totalToolCount: this.state.reflection.totalToolCount,
+      checkpointCount: this.state.reflection.checkpointCount,
+      lastReflection: this.state.reflection.lastReflection,
+      summaries: this.state.reflection.summaries,
+    };
+  }
+
+  /**
+   * Force a reflection checkpoint now
+   */
+  async forceReflection(): Promise<import("./types.js").GLMReflectionSummary | null> {
+    if (!this.running) {
+      return null;
+    }
+
+    // Store current phase
+    this.state.slam.previousPhase = this.state.slam.phase;
+    this.state.slam.phase = "reflecting";
+
+    // Execute reflection
+    await this.phaseReflecting();
+
+    // Return the latest summary
+    return this.state.reflection.summaries[this.state.reflection.summaries.length - 1] || null;
+  }
+
   /**
    * Parse subtasks from agent response
    */

package/src/hooks.js

@@ -0,0 +1,145 @@
+"use strict";
+/**
+ * GLM Daemon - Hook System
+ *
+ * Implements hook lifecycle for daemon events.
+ * Based on Claude Code's hook system.
+ */
+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.HookSystem = void 0;
+var HookSystem = /** @class */ (function () {
+    function HookSystem(config) {
+        this.hooks = new Map();
+        // Register hooks from config
+        if (config.onSessionStart) {
+            this.register("onSessionStart", config.onSessionStart);
+        }
+        if (config.onSessionEnd) {
+            this.register("onSessionEnd", config.onSessionEnd);
+        }
+        if (config.onPreToolUse) {
+            this.register("onPreToolUse", config.onPreToolUse);
+        }
+        if (config.onPostToolUse) {
+            this.register("onPostToolUse", config.onPostToolUse);
+        }
+        if (config.onSubagentStart) {
+            this.register("onSubagentStart", config.onSubagentStart);
+        }
+        if (config.onSubagentStop) {
+            this.register("onSubagentStop", config.onSubagentStop);
+        }
+        if (config.onIterationStart) {
+            this.register("onIterationStart", config.onIterationStart);
+        }
+        if (config.onIterationEnd) {
+            this.register("onIterationEnd", config.onIterationEnd);
+        }
+    }
+    /**
+     * Register a hook handler
+     */
+    HookSystem.prototype.register = function (event, handler) {
+        if (!this.hooks.has(event)) {
+            this.hooks.set(event, []);
+        }
+        this.hooks.get(event).push(handler);
+    };
+    /**
+     * Execute all handlers for an event
+     */
+    HookSystem.prototype.execute = function (event) {
+        var args = [];
+        for (var _i = 1; _i < arguments.length; _i++) {
+            args[_i - 1] = arguments[_i];
+        }
+        return __awaiter(this, void 0, void 0, function () {
+            var handlers, _a, handlers_1, handler, error_1;
+            return __generator(this, function (_b) {
+                switch (_b.label) {
+                    case 0:
+                        handlers = this.hooks.get(event);
+                        if (!handlers) {
+                            return [2 /*return*/];
+                        }
+                        _a = 0, handlers_1 = handlers;
+                        _b.label = 1;
+                    case 1:
+                        if (!(_a < handlers_1.length)) return [3 /*break*/, 6];
+                        handler = handlers_1[_a];
+                        _b.label = 2;
+                    case 2:
+                        _b.trys.push([2, 4, , 5]);
+                        return [4 /*yield*/, handler.apply(void 0, args)];
+                    case 3:
+                        _b.sent();
+                        return [3 /*break*/, 5];
+                    case 4:
+                        error_1 = _b.sent();
+                        console.error("[HookSystem] Error in ".concat(event, ":"), error_1);
+                        return [3 /*break*/, 5];
+                    case 5:
+                        _a++;
+                        return [3 /*break*/, 1];
+                    case 6: return [2 /*return*/];
+                }
+            });
+        });
+    };
+    /**
+     * Remove all handlers for an event
+     */
+    HookSystem.prototype.clear = function (event) {
+        this.hooks.delete(event);
+    };
+    /**
+     * Remove all hooks
+     */
+    HookSystem.prototype.clearAll = function () {
+        this.hooks.clear();
+    };
+    /**
+     * Get registered events
+     */
+    HookSystem.prototype.getEvents = function () {
+        return Array.from(this.hooks.keys());
+    };
+    return HookSystem;
+}());
+exports.HookSystem = HookSystem;

package/src/hooks.ts

@@ -40,6 +40,9 @@ export class HookSystem {
     if (config.onIterationEnd) {
       this.register("onIterationEnd", config.onIterationEnd as GLMHookHandler);
     }
+    if (config.onReflection) {
+      this.register("onReflection", config.onReflection as GLMHookHandler);
+    }
   }
 
   /**

package/src/index.js

@@ -0,0 +1,123 @@
+"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, multi-agent coordination, and communication channels.
+ *
+ * @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.ChannelRegistry = exports.DiscordChannel = exports.TelegramChannel = exports.BaseChannel = exports.StringConversationMemory = exports.NumericConversationMemory = exports.ConversationMemory = exports.executeBuiltinTool = exports.toGLMFormat = exports.getBuiltinToolNames = exports.getBuiltinTool = exports.BUILTIN_TOOLS = 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; } });
+// Built-in tools
+var builtin_tools_js_1 = require("./builtin-tools.js");
+Object.defineProperty(exports, "BUILTIN_TOOLS", { enumerable: true, get: function () { return builtin_tools_js_1.BUILTIN_TOOLS; } });
+Object.defineProperty(exports, "getBuiltinTool", { enumerable: true, get: function () { return builtin_tools_js_1.getBuiltinTool; } });
+Object.defineProperty(exports, "getBuiltinToolNames", { enumerable: true, get: function () { return builtin_tools_js_1.getBuiltinToolNames; } });
+Object.defineProperty(exports, "toGLMFormat", { enumerable: true, get: function () { return builtin_tools_js_1.toGLMFormat; } });
+Object.defineProperty(exports, "executeBuiltinTool", { enumerable: true, get: function () { return builtin_tools_js_1.executeBuiltinTool; } });
+// Memory systems
+var memory_js_1 = require("./memory.js");
+Object.defineProperty(exports, "ConversationMemory", { enumerable: true, get: function () { return memory_js_1.ConversationMemory; } });
+Object.defineProperty(exports, "NumericConversationMemory", { enumerable: true, get: function () { return memory_js_1.NumericConversationMemory; } });
+Object.defineProperty(exports, "StringConversationMemory", { enumerable: true, get: function () { return memory_js_1.StringConversationMemory; } });
+// Communication channels
+var index_js_1 = require("./channels/index.js");
+Object.defineProperty(exports, "BaseChannel", { enumerable: true, get: function () { return index_js_1.BaseChannel; } });
+Object.defineProperty(exports, "TelegramChannel", { enumerable: true, get: function () { return index_js_1.TelegramChannel; } });
+Object.defineProperty(exports, "DiscordChannel", { enumerable: true, get: function () { return index_js_1.DiscordChannel; } });
+Object.defineProperty(exports, "ChannelRegistry", { enumerable: true, get: function () { return index_js_1.ChannelRegistry; } });
+// 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()];
+            }
+        });
+    });
+}