@ebowwa/glm-daemon 0.1.0

package/src/daemon.js

@@ -0,0 +1,591 @@
+"use strict";
+/**
+ * GLM Daemon - Core Daemon
+ *
+ * Main orchestrator for autonomous GLM 4.7 agents.
+ * Implements SLAM pattern: State → Loop → Action → Memory
+ */
+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.GLMDaemon = void 0;
+var path_1 = require("path");
+var agent_js_1 = require("./agent.js");
+var hooks_js_1 = require("./hooks.js");
+var tools_js_1 = require("./tools.js");
+var state_js_1 = require("./state.js");
+var worktree_js_1 = require("./worktree.js");
+var teammates_1 = require("@ebowwa/teammates");
+var client_1 = require("@codespaces/ai/client");
+var STATE_FILE = ".glm-daemon.json";
+var SETTINGS_FILE = ".claude/settings.local.json";
+var GLMDaemon = /** @class */ (function () {
+    function GLMDaemon(config) {
+        this.team = null;
+        this.subagents = new Map();
+        this.running = false;
+        this.config = config;
+        this.statePath = (0, path_1.join)(config.cwd, STATE_FILE);
+        this.client = new client_1.GLMClient();
+        // Initialize state
+        this.state = this.initializeState();
+        // Initialize components
+        this.hooks = new hooks_js_1.HookSystem(config.hooks || {});
+        this.tools = new tools_js_1.ToolBridge(config.tools || {});
+        this.stateManager = new state_js_1.StateManager(this.statePath);
+        this.worktreeManager = new worktree_js_1.WorktreeManager(config);
+        // Initialize main agent
+        this.agent = new agent_js_1.GLMAgent({
+            agentId: "glm-daemon",
+            name: "GLM Daemon",
+            prompt: this.buildSystemPrompt(),
+            model: config.model,
+            tools: this.tools.getAvailableTools(),
+        });
+    }
+    /**
+     * Initialize daemon state
+     */
+    GLMDaemon.prototype.initializeState = function () {
+        var now = new Date().toISOString();
+        return {
+            prompt: "", // Will be set when starting
+            promise: this.config.completionPromise || "TASK_COMPLETE",
+            iteration: 0,
+            maxIterations: this.config.maxIterations || 0,
+            startTime: now,
+            lastUpdate: now,
+            tokens: {
+                totalInput: 0,
+                totalOutput: 0,
+                byIteration: [],
+            },
+            filesChanged: [],
+            workMemory: {
+                completedFiles: [],
+                fileChecksums: {},
+            },
+            slam: {
+                enabled: true,
+                phase: "planning",
+                state: {
+                    currentTask: "",
+                    beliefs: {},
+                    goals: [this.config.completionPromise || "TASK_COMPLETE"],
+                },
+                subtasks: [],
+                currentSubtask: null,
+                completedSubtasks: [],
+                memory: {
+                    actionsTaken: [],
+                    outcomes: {},
+                    patterns: {},
+                },
+            },
+            git: {
+                enabled: this.config.autoCommit || this.config.autoPR || false,
+                autoCommit: this.config.autoCommit || false,
+                autoPR: this.config.autoPR || false,
+                baseBranch: this.config.baseBranch || "main",
+                useWorktree: this.config.enableWorktree || false,
+                branchName: "",
+                branchCreated: false,
+                currentCommit: "",
+            },
+        };
+    };
+    /**
+     * Build system prompt from config and state
+     */
+    GLMDaemon.prototype.buildSystemPrompt = function () {
+        return "You are an autonomous AI agent powered by GLM 4.7.\n\nYour task: ".concat(this.state.prompt, "\n\nYou work in SLAM phases:\n- Planning: Break down the task into subtasks\n- Executing: Work on the current subtask\n- Paranoid: Review your work for bugs and issues\n- Reviewing: Check quality of completed work\n- Fixing: Address any issues found\n- Committing: Commit your changes\n- Complete: Task is finished\n\nUse tools when available. Be thorough but efficient.\n\nCurrent phase: ").concat(this.state.slam.phase, "\nIteration: ").concat(this.state.iteration, "\n");
+    };
+    /**
+     * Start the daemon with a prompt
+     */
+    GLMDaemon.prototype.start = function (prompt) {
+        return __awaiter(this, void 0, void 0, function () {
+            var worktreePath, _a, _b;
+            var _this = this;
+            return __generator(this, function (_c) {
+                switch (_c.label) {
+                    case 0:
+                        if (this.running) {
+                            throw new Error("Daemon already running");
+                        }
+                        this.state.prompt = prompt;
+                        this.state.slam.state.currentTask = prompt;
+                        this.running = true;
+                        if (!this.config.enableWorktree) return [3 /*break*/, 3];
+                        return [4 /*yield*/, this.worktreeManager.createWorktree()];
+                    case 1:
+                        worktreePath = _c.sent();
+                        _a = this.state.git;
+                        return [4 /*yield*/, this.worktreeManager.createBranch()];
+                    case 2:
+                        _a.branchName = _c.sent();
+                        this.state.git.branchCreated = true;
+                        _c.label = 3;
+                    case 3:
+                        // Initialize team for multi-agent coordination
+                        _b = this;
+                        return [4 /*yield*/, teammates_1.Team.create({
+                                name: this.config.teamName,
+                                description: "GLM daemon for: ".concat(prompt.substring(0, 50), "..."),
+                            })];
+                    case 4:
+                        // Initialize team for multi-agent coordination
+                        _b.team = _c.sent();
+                        // Run session start hook
+                        return [4 /*yield*/, this.hooks.execute("onSessionStart", this.state)];
+                    case 5:
+                        // Run session start hook
+                        _c.sent();
+                        // Save initial state
+                        return [4 /*yield*/, this.stateManager.save(this.state)];
+                    case 6:
+                        // Save initial state
+                        _c.sent();
+                        // Start main loop
+                        this.runLoop().catch(function (error) {
+                            console.error("[GLMDaemon] Loop error:", error);
+                            _this.running = false;
+                        });
+                        return [2 /*return*/, this.config.teamName];
+                }
+            });
+        });
+    };
+    /**
+     * Main daemon loop (SLAM pattern)
+     */
+    GLMDaemon.prototype.runLoop = function () {
+        return __awaiter(this, void 0, void 0, function () {
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        if (!this.running) return [3 /*break*/, 9];
+                        if (!this.checkCompletion()) return [3 /*break*/, 2];
+                        return [4 /*yield*/, this.complete()];
+                    case 1:
+                        _a.sent();
+                        return [3 /*break*/, 9];
+                    case 2:
+                        if (!(this.state.maxIterations > 0 &&
+                            this.state.iteration >= this.state.maxIterations)) return [3 /*break*/, 4];
+                        console.log("[GLMDaemon] Max iterations reached: ".concat(this.state.maxIterations));
+                        return [4 /*yield*/, this.stop()];
+                    case 3:
+                        _a.sent();
+                        return [3 /*break*/, 9];
+                    case 4: 
+                    // Run iteration start hook
+                    return [4 /*yield*/, this.hooks.execute("onIterationStart", this.state.iteration)];
+                    case 5:
+                        // Run iteration start hook
+                        _a.sent();
+                        // Execute current SLAM phase
+                        return [4 /*yield*/, this.executePhase()];
+                    case 6:
+                        // Execute current SLAM phase
+                        _a.sent();
+                        // Update state
+                        this.state.iteration++;
+                        this.state.lastUpdate = new Date().toISOString();
+                        // Save state
+                        return [4 /*yield*/, this.stateManager.save(this.state)];
+                    case 7:
+                        // Save state
+                        _a.sent();
+                        // Run iteration end hook
+                        return [4 /*yield*/, this.hooks.execute("onIterationEnd", this.state.iteration, null)];
+                    case 8:
+                        // Run iteration end hook
+                        _a.sent();
+                        return [3 /*break*/, 0];
+                    case 9: return [2 /*return*/];
+                }
+            });
+        });
+    };
+    /**
+     * Execute current SLAM phase
+     */
+    GLMDaemon.prototype.executePhase = function () {
+        return __awaiter(this, void 0, void 0, function () {
+            var phase, _a;
+            return __generator(this, function (_b) {
+                switch (_b.label) {
+                    case 0:
+                        phase = this.state.slam.phase;
+                        _a = phase;
+                        switch (_a) {
+                            case "planning": return [3 /*break*/, 1];
+                            case "executing": return [3 /*break*/, 3];
+                            case "paranoid": return [3 /*break*/, 5];
+                            case "reviewing": return [3 /*break*/, 7];
+                            case "fixing": return [3 /*break*/, 9];
+                            case "committing": return [3 /*break*/, 11];
+                            case "complete": return [3 /*break*/, 13];
+                        }
+                        return [3 /*break*/, 15];
+                    case 1: return [4 /*yield*/, this.phasePlanning()];
+                    case 2:
+                        _b.sent();
+                        return [3 /*break*/, 15];
+                    case 3: return [4 /*yield*/, this.phaseExecuting()];
+                    case 4:
+                        _b.sent();
+                        return [3 /*break*/, 15];
+                    case 5: return [4 /*yield*/, this.phaseParanoid()];
+                    case 6:
+                        _b.sent();
+                        return [3 /*break*/, 15];
+                    case 7: return [4 /*yield*/, this.phaseReviewing()];
+                    case 8:
+                        _b.sent();
+                        return [3 /*break*/, 15];
+                    case 9: return [4 /*yield*/, this.phaseFixing()];
+                    case 10:
+                        _b.sent();
+                        return [3 /*break*/, 15];
+                    case 11: return [4 /*yield*/, this.phaseCommitting()];
+                    case 12:
+                        _b.sent();
+                        return [3 /*break*/, 15];
+                    case 13: return [4 /*yield*/, this.complete()];
+                    case 14:
+                        _b.sent();
+                        return [3 /*break*/, 15];
+                    case 15: return [2 /*return*/];
+                }
+            });
+        });
+    };
+    /**
+     * Planning phase - break down task into subtasks
+     */
+    GLMDaemon.prototype.phasePlanning = function () {
+        return __awaiter(this, void 0, void 0, function () {
+            var prompt, response, subtasks;
+            var _a;
+            return __generator(this, function (_b) {
+                switch (_b.label) {
+                    case 0:
+                        console.log("[GLMDaemon] Phase: Planning");
+                        prompt = "".concat(this.state.prompt, "\n\nBreak this task down into 3-7 concrete subtasks.\nFor each subtask, specify:\n- Title (short description)\n- Description (what needs to be done)\n- Dependencies (which subtasks must come first)\n\nRespond with a JSON array of subtasks.\n");
+                        return [4 /*yield*/, this.agent.execute(prompt)];
+                    case 1:
+                        response = _b.sent();
+                        subtasks = this.parseSubtasks(response);
+                        this.state.slam.subtasks = subtasks;
+                        this.state.slam.phase = "executing";
+                        this.state.slam.currentSubtask = ((_a = subtasks[0]) === null || _a === void 0 ? void 0 : _a.id) || null;
+                        return [2 /*return*/];
+                }
+            });
+        });
+    };
+    /**
+     * Executing phase - work on current subtask
+     */
+    GLMDaemon.prototype.phaseExecuting = function () {
+        return __awaiter(this, void 0, void 0, function () {
+            var currentSubtaskId, subtask, prompt, response, nextSubtask;
+            var _this = this;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        currentSubtaskId = this.state.slam.currentSubtask;
+                        if (!currentSubtaskId) {
+                            this.state.slam.phase = "reviewing";
+                            return [2 /*return*/];
+                        }
+                        subtask = this.state.slam.subtasks.find(function (st) { return st.id === currentSubtaskId; });
+                        if (!subtask) {
+                            this.state.slam.phase = "reviewing";
+                            return [2 /*return*/];
+                        }
+                        console.log("[GLMDaemon] Executing subtask: ".concat(subtask.title));
+                        prompt = "Work on this subtask: ".concat(subtask.title, "\n\n").concat(subtask.description, "\n\nUse available tools to complete the work.\nFocus on code changes, testing, and verification.\n");
+                        return [4 /*yield*/, this.agent.execute(prompt)];
+                    case 1:
+                        response = _a.sent();
+                        // Update subtask status
+                        subtask.status = "completed";
+                        subtask.result = response;
+                        this.state.slam.completedSubtasks.push(currentSubtaskId);
+                        nextSubtask = this.state.slam.subtasks.find(function (st) { return !_this.state.slam.completedSubtasks.includes(st.id); });
+                        if (nextSubtask) {
+                            this.state.slam.currentSubtask = nextSubtask.id;
+                        }
+                        else {
+                            this.state.slam.phase = "paranoid";
+                        }
+                        return [2 /*return*/];
+                }
+            });
+        });
+    };
+    /**
+     * Paranoid phase - quality check after every edit
+     */
+    GLMDaemon.prototype.phaseParanoid = function () {
+        return __awaiter(this, void 0, void 0, function () {
+            var prompt, response, hasIssues;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        console.log("[GLMDaemon] Phase: Paranoid (quality check)");
+                        prompt = "Review the changes made in this session for:\n- Bugs or errors\n- Edge cases not handled\n- Security vulnerabilities\n- Performance issues\n- Breaking changes\n\nTask: ".concat(this.state.prompt, "\n\nChanges made:\n").concat(this.state.filesChanged.map(function (f) { return "- ".concat(f); }).join("\n"), "\n\nBe thorough. If issues found, we'll fix them. If clean, we proceed to review.\n");
+                        return [4 /*yield*/, this.agent.execute(prompt)];
+                    case 1:
+                        response = _a.sent();
+                        hasIssues = this.detectIssues(response);
+                        if (hasIssues) {
+                            this.state.slam.phase = "fixing";
+                        }
+                        else {
+                            this.state.slam.phase = "reviewing";
+                        }
+                        return [2 /*return*/];
+                }
+            });
+        });
+    };
+    /**
+     * Reviewing phase - final quality review
+     */
+    GLMDaemon.prototype.phaseReviewing = function () {
+        return __awaiter(this, void 0, void 0, function () {
+            var prompt, response;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        console.log("[GLMDaemon] Phase: Reviewing");
+                        prompt = "Final review of the completed work.\n\nTask: ".concat(this.state.prompt, "\nCompletion promise: ").concat(this.state.promise, "\n\nDoes the implementation fully satisfy the completion promise?\nAre there any remaining issues or TODOs?\n\nIf complete and clean, respond with \"APPROVED\".\nOtherwise, list remaining issues.\n");
+                        return [4 /*yield*/, this.agent.execute(prompt)];
+                    case 1:
+                        response = _a.sent();
+                        if (response.includes("APPROVED")) {
+                            this.state.slam.phase = "committing";
+                        }
+                        else {
+                            this.state.slam.phase = "fixing";
+                        }
+                        return [2 /*return*/];
+                }
+            });
+        });
+    };
+    /**
+     * Fixing phase - fix issues found
+     */
+    GLMDaemon.prototype.phaseFixing = function () {
+        return __awaiter(this, void 0, void 0, function () {
+            var prompt;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        console.log("[GLMDaemon] Phase: Fixing");
+                        prompt = "Fix the issues identified in the review.\n\nUse tools to make necessary changes.\nTest your fixes thoroughly.\n";
+                        return [4 /*yield*/, this.agent.execute(prompt)];
+                    case 1:
+                        _a.sent();
+                        this.state.slam.phase = "paranoid"; // Re-check after fixes
+                        return [2 /*return*/];
+                }
+            });
+        });
+    };
+    /**
+     * Committing phase - commit changes
+     */
+    GLMDaemon.prototype.phaseCommitting = function () {
+        return __awaiter(this, void 0, void 0, function () {
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        console.log("[GLMDaemon] Phase: Committing");
+                        if (!this.state.git.autoCommit) return [3 /*break*/, 2];
+                        // Commit changes via worktree manager
+                        return [4 /*yield*/, this.worktreeManager.commitChanges({
+                                message: "feat: ".concat(this.state.prompt.substring(0, 50)),
+                                files: this.state.filesChanged,
+                            })];
+                    case 1:
+                        // Commit changes via worktree manager
+                        _a.sent();
+                        _a.label = 2;
+                    case 2:
+                        this.state.slam.phase = "complete";
+                        return [2 /*return*/];
+                }
+            });
+        });
+    };
+    /**
+     * Complete the daemon run
+     */
+    GLMDaemon.prototype.complete = function () {
+        return __awaiter(this, void 0, void 0, function () {
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        console.log("[GLMDaemon] Task complete!");
+                        this.state.slam.phase = "complete";
+                        this.running = false;
+                        // Run session end hook
+                        return [4 /*yield*/, this.hooks.execute("onSessionEnd", this.state)];
+                    case 1:
+                        // Run session end hook
+                        _a.sent();
+                        // Save final state
+                        return [4 /*yield*/, this.stateManager.save(this.state)];
+                    case 2:
+                        // Save final state
+                        _a.sent();
+                        if (!this.state.git.autoPR) return [3 /*break*/, 4];
+                        return [4 /*yield*/, this.worktreeManager.createPullRequest({
+                                title: this.state.prompt.substring(0, 50),
+                                body: "Completes: ".concat(this.state.promise),
+                            })];
+                    case 3:
+                        _a.sent();
+                        _a.label = 4;
+                    case 4: return [2 /*return*/];
+                }
+            });
+        });
+    };
+    /**
+     * Stop the daemon
+     */
+    GLMDaemon.prototype.stop = function () {
+        return __awaiter(this, void 0, void 0, function () {
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        console.log("[GLMDaemon] Stopping...");
+                        this.running = false;
+                        if (!this.team) return [3 /*break*/, 2];
+                        return [4 /*yield*/, this.team.broadcast("team-lead", "Daemon stopping")];
+                    case 1:
+                        _a.sent();
+                        _a.label = 2;
+                    case 2: 
+                    // Save final state
+                    return [4 /*yield*/, this.stateManager.save(this.state)];
+                    case 3:
+                        // Save final state
+                        _a.sent();
+                        return [2 /*return*/];
+                }
+            });
+        });
+    };
+    /**
+     * Get daemon status
+     */
+    GLMDaemon.prototype.getStatus = function () {
+        return {
+            id: this.config.teamName,
+            status: this.running ? "running" : "stopped",
+            phase: this.state.slam.phase,
+            iteration: this.state.iteration,
+            prompt: this.state.prompt,
+            currentTask: this.state.slam.state.currentTask,
+            totalSubtasks: this.state.slam.subtasks.length,
+            completedSubtasks: this.state.slam.completedSubtasks.length,
+            startedAt: this.state.startTime,
+            lastUpdate: this.state.lastUpdate,
+        };
+    };
+    /**
+     * Parse subtasks from agent response
+     */
+    GLMDaemon.prototype.parseSubtasks = function (response) {
+        try {
+            var jsonMatch = response.match(/\[[\s\S]*\]/);
+            if (jsonMatch) {
+                var parsed = JSON.parse(jsonMatch[0]);
+                return parsed.map(function (st, idx) { return ({
+                    id: st.id || "subtask-".concat(idx),
+                    title: st.title || st.task || "Subtask ".concat(idx + 1),
+                    description: st.description || "",
+                    status: "pending",
+                    dependencies: st.dependencies || [],
+                }); });
+            }
+        }
+        catch (_a) {
+            // Fallback: create single subtask from prompt
+            return [{
+                    id: "subtask-0",
+                    title: this.state.prompt.substring(0, 50),
+                    description: this.state.prompt,
+                    status: "pending",
+                }];
+        }
+        return [];
+    };
+    /**
+     * Detect issues in paranoid check response
+     */
+    GLMDaemon.prototype.detectIssues = function (response) {
+        var issueKeywords = [
+            "bug", "error", "issue", "problem", "vulnerability",
+            "fix", "improve", "missing", "incomplete", "broken"
+        ];
+        var lower = response.toLowerCase();
+        return issueKeywords.some(function (kw) { return lower.includes(kw); });
+    };
+    /**
+     * Check if completion promise is met
+     */
+    GLMDaemon.prototype.checkCompletion = function () {
+        var _this = this;
+        // Simple check: all subtasks complete
+        var allComplete = this.state.slam.subtasks.length > 0 &&
+            this.state.slam.subtasks.every(function (st) {
+                return _this.state.slam.completedSubtasks.includes(st.id);
+            });
+        return allComplete || this.state.slam.phase === "complete";
+    };
+    return GLMDaemon;
+}());
+exports.GLMDaemon = GLMDaemon;