@ebowwa/glm-daemon 0.3.2 → 0.4.0

package/src/types.js

@@ -0,0 +1,21 @@
+"use strict";
+/**
+ * GLM Daemon - Core Types
+ *
+ * Autonomous AI daemon powered by GLM 4.7 with hooks, tools, and teammates.
+ * Based on Ralph Iterative's SLAM pattern (State → Loop → Action → Memory).
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.GLM_PHASES = void 0;
+/**
+ * GLM Daemon state phases (SLAM pattern)
+ */
+exports.GLM_PHASES = {
+    planning: "planning",
+    executing: "executing",
+    paranoid: "paranoid",
+    reviewing: "reviewing",
+    fixing: "fixing",
+    committing: "committing",
+    complete: "complete",
+};

package/src/types.ts

@@ -13,6 +13,7 @@ import type { Team } from "@ebowwa/teammates";
 export const GLM_PHASES = {
   planning: "planning",
   executing: "executing",
+  reflecting: "reflecting", // Checkpoint after N tools
   paranoid: "paranoid",
   reviewing: "reviewing",
   fixing: "fixing",
@@ -58,6 +59,9 @@ export interface GLMDaemonConfig {
 
   /** Tools configuration */
   tools?: GLMToolsConfig;
+
+  /** Reflection checkpoint configuration */
+  reflection?: GLMReflectionConfig;
 }
 
 /**
@@ -106,6 +110,8 @@ export interface GLMDaemonState {
   slam: {
     enabled: boolean;
     phase: GLMPhase;
+    /** Previous phase (used to return after reflection) */
+    previousPhase?: GLMPhase;
     state: {
       currentTask: string;
       beliefs: Record<string, unknown>;
@@ -133,6 +139,20 @@ export interface GLMDaemonState {
     currentCommit: string;
   };
 
+  /** Reflection checkpoint state */
+  reflection: {
+    /** Current tool call count in this chunk */
+    toolCount: number;
+    /** Total tool calls across all chunks */
+    totalToolCount: number;
+    /** Number of reflection checkpoints completed */
+    checkpointCount: number;
+    /** Timestamp of last reflection */
+    lastReflection: string | null;
+    /** Accumulated TL;DR summaries */
+    summaries: GLMReflectionSummary[];
+  };
+
   /** Machine info */
   machine?: {
     cpu: { count: number; model: string; tier: string };
@@ -169,6 +189,8 @@ export interface GLMHooksConfig {
   onSubagentStop?: (subagentId: string, result: unknown) => Promise<void>;
   onIterationStart?: (iteration: number) => Promise<void>;
   onIterationEnd?: (iteration: number, result: unknown) => Promise<void>;
+  /** Called at each reflection checkpoint */
+  onReflection?: (state: GLMDaemonState, summary: GLMReflectionSummary) => Promise<void>;
 }
 
 /**
@@ -191,6 +213,24 @@ export interface GLMToolsConfig {
   maxRetries?: number;
 }
 
+/**
+ * Reflection checkpoint configuration
+ * Triggers TL;DR summary after N tool calls
+ */
+export interface GLMReflectionConfig {
+  /** Enable reflection checkpoints */
+  enabled: boolean;
+
+  /** Number of tools before reflection (default: 50) */
+  toolLimit: number;
+
+  /** Auto-continue after reflection (default: true) */
+  autoContinue: boolean;
+
+  /** Save reflection summaries to file */
+  saveToFile?: string;
+}
+
 /**
  * GLM Agent (individual GLM-powered agent)
  */
@@ -230,6 +270,28 @@ export interface GLMToolResult {
   duration: number;
 }
 
+/**
+ * Reflection summary generated at checkpoint
+ */
+export interface GLMReflectionSummary {
+  /** Checkpoint number */
+  checkpoint: number;
+  /** Timestamp */
+  timestamp: string;
+  /** Tools used in this chunk */
+  toolsUsed: number;
+  /** Phase when reflection occurred */
+  phase: GLMPhase;
+  /** TL;DR summary */
+  summary: string;
+  /** Key accomplishments */
+  accomplishments: string[];
+  /** Next steps identified */
+  nextSteps: string[];
+  /** Issues/blockers found */
+  issues: string[];
+}
+
 /**
  * GLM Daemon status
  */

package/src/worktree.js

@@ -0,0 +1,195 @@
+"use strict";
+/**
+ * GLM Daemon - Worktree Manager
+ *
+ * Handles git worktree isolation for parallel task execution.
+ */
+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 = void 0;
+var child_process_1 = require("child_process");
+var util_1 = require("util");
+var path_1 = require("path");
+var execAsync = (0, util_1.promisify)(child_process_1.exec);
+var WorktreeManager = /** @class */ (function () {
+    function WorktreeManager(config) {
+        this.worktreePath = null;
+        this.config = config;
+    }
+    /**
+     * Create a new worktree for isolation
+     */
+    WorktreeManager.prototype.createWorktree = function () {
+        return __awaiter(this, void 0, void 0, function () {
+            var timestamp, worktreeName;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        if (!this.config.enableWorktree) {
+                            return [2 /*return*/, this.config.cwd];
+                        }
+                        timestamp = Date.now();
+                        worktreeName = "glm-".concat(timestamp);
+                        this.worktreePath = (0, path_1.join)(this.config.cwd, "worktrees", worktreeName);
+                        // Create worktrees directory
+                        return [4 /*yield*/, execAsync("mkdir -p ".concat((0, path_1.join)(this.config.cwd, "worktrees")))];
+                    case 1:
+                        // Create worktrees directory
+                        _a.sent();
+                        // Create worktree
+                        return [4 /*yield*/, execAsync("git worktree add -b ".concat(worktreeName, " ").concat(this.worktreePath))];
+                    case 2:
+                        // Create worktree
+                        _a.sent();
+                        return [2 /*return*/, this.worktreePath];
+                }
+            });
+        });
+    };
+    /**
+     * Create a feature branch in the worktree
+     */
+    WorktreeManager.prototype.createBranch = function () {
+        return __awaiter(this, void 0, void 0, function () {
+            var branchName;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        if (!this.worktreePath) {
+                            throw new Error("No worktree created");
+                        }
+                        branchName = "feat/glm-".concat(Date.now());
+                        return [4 /*yield*/, execAsync("cd ".concat(this.worktreePath, " && git checkout -b ").concat(branchName))];
+                    case 1:
+                        _a.sent();
+                        return [2 /*return*/, branchName];
+                }
+            });
+        });
+    };
+    /**
+     * Commit changes in the worktree
+     */
+    WorktreeManager.prototype.commitChanges = function (options) {
+        return __awaiter(this, void 0, void 0, function () {
+            var cwd, _i, _a, file, stdout;
+            return __generator(this, function (_b) {
+                switch (_b.label) {
+                    case 0:
+                        cwd = this.worktreePath || this.config.cwd;
+                        _i = 0, _a = options.files;
+                        _b.label = 1;
+                    case 1:
+                        if (!(_i < _a.length)) return [3 /*break*/, 4];
+                        file = _a[_i];
+                        return [4 /*yield*/, execAsync("cd ".concat(cwd, " && git add ").concat(file))];
+                    case 2:
+                        _b.sent();
+                        _b.label = 3;
+                    case 3:
+                        _i++;
+                        return [3 /*break*/, 1];
+                    case 4: return [4 /*yield*/, execAsync("cd ".concat(cwd, " && git commit -m \"").concat(options.message, "\""))];
+                    case 5:
+                        stdout = (_b.sent()).stdout;
+                        return [2 /*return*/, stdout.trim()];
+                }
+            });
+        });
+    };
+    /**
+     * Create a pull request
+     */
+    WorktreeManager.prototype.createPullRequest = function (options) {
+        return __awaiter(this, void 0, void 0, function () {
+            var cwd;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        cwd = this.worktreePath || this.config.cwd;
+                        // Push branch
+                        return [4 /*yield*/, execAsync("cd ".concat(cwd, " && git push -u origin HEAD"))];
+                    case 1:
+                        // Push branch
+                        _a.sent();
+                        // Create PR using gh CLI
+                        return [4 /*yield*/, execAsync("cd ".concat(cwd, " && gh pr create --title \"").concat(options.title, "\" --body \"").concat(options.body, "\""))];
+                    case 2:
+                        // Create PR using gh CLI
+                        _a.sent();
+                        return [2 /*return*/];
+                }
+            });
+        });
+    };
+    /**
+     * Clean up worktree
+     */
+    WorktreeManager.prototype.cleanup = function () {
+        return __awaiter(this, void 0, void 0, function () {
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        if (!this.worktreePath) {
+                            return [2 /*return*/];
+                        }
+                        // Remove worktree
+                        return [4 /*yield*/, execAsync("git worktree remove ".concat(this.worktreePath))];
+                    case 1:
+                        // Remove worktree
+                        _a.sent();
+                        // Delete directory
+                        return [4 /*yield*/, execAsync("rm -rf ".concat(this.worktreePath))];
+                    case 2:
+                        // Delete directory
+                        _a.sent();
+                        this.worktreePath = null;
+                        return [2 /*return*/];
+                }
+            });
+        });
+    };
+    /**
+     * Get worktree path
+     */
+    WorktreeManager.prototype.getPath = function () {
+        return this.worktreePath;
+    };
+    return WorktreeManager;
+}());
+exports.WorktreeManager = WorktreeManager;