@ebowwa/glm-daemon 0.1.0

package/src/daemon.ts

@@ -0,0 +1,529 @@
+/**
+ * GLM Daemon - Core Daemon
+ *
+ * Main orchestrator for autonomous GLM 4.7 agents.
+ * Implements SLAM pattern: State → Loop → Action → Memory
+ */
+
+import { promises as fsp } from "fs";
+import { join } from "path";
+import type {
+  GLMDaemonConfig,
+  GLMDaemonState,
+  GLMPhase,
+  GLMDaemonStatus,
+} from "./types.js";
+import { GLMAgent } from "./agent.js";
+import { HookSystem } from "./hooks.js";
+import { ToolBridge } from "./tools.js";
+import { StateManager } from "./state.js";
+import { WorktreeManager } from "./worktree.js";
+import { Team } from "@ebowwa/teammates";
+import { GLMClient } from "@ebowwa/ai/client";
+
+const STATE_FILE = ".glm-daemon.json";
+const SETTINGS_FILE = ".claude/settings.local.json";
+
+export class GLMDaemon {
+  private config: GLMDaemonConfig;
+  private state: GLMDaemonState;
+  private statePath: string;
+  private agent: GLMAgent;
+  private hooks: HookSystem;
+  private tools: ToolBridge;
+  private stateManager: StateManager;
+  private worktreeManager: WorktreeManager;
+  private team: Team | null = null;
+  private subagents: Map<string, GLMAgent> = new Map();
+  private running = false;
+  private client: GLMClient;
+
+  constructor(config: GLMDaemonConfig) {
+    this.config = config;
+    this.statePath = join(config.cwd, STATE_FILE);
+    this.client = new GLMClient();
+
+    // Initialize state
+    this.state = this.initializeState();
+
+    // Initialize components
+    this.hooks = new HookSystem(config.hooks || {});
+    this.tools = new ToolBridge(config.tools || {});
+    this.stateManager = new StateManager(this.statePath);
+    this.worktreeManager = new WorktreeManager(config);
+
+    // Initialize main agent
+    this.agent = new GLMAgent({
+      agentId: "glm-daemon",
+      name: "GLM Daemon",
+      prompt: this.buildSystemPrompt(),
+      model: config.model,
+      tools: this.tools.getAvailableTools(),
+    });
+  }
+
+  /**
+   * Initialize daemon state
+   */
+  private initializeState(): GLMDaemonState {
+    const 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
+   */
+  private buildSystemPrompt(): string {
+    return `You are an autonomous AI agent powered by GLM 4.7.
+
+Your task: ${this.state.prompt}
+
+You work in SLAM phases:
+- Planning: Break down the task into subtasks
+- Executing: Work on the current subtask
+- Paranoid: Review your work for bugs and issues
+- Reviewing: Check quality of completed work
+- Fixing: Address any issues found
+- Committing: Commit your changes
+- Complete: Task is finished
+
+Use tools when available. Be thorough but efficient.
+
+Current phase: ${this.state.slam.phase}
+Iteration: ${this.state.iteration}
+`;
+  }
+
+  /**
+   * Start the daemon with a prompt
+   */
+  async start(prompt: string): Promise<string> {
+    if (this.running) {
+      throw new Error("Daemon already running");
+    }
+
+    this.state.prompt = prompt;
+    this.state.slam.state.currentTask = prompt;
+    this.running = true;
+
+    // Setup worktree if enabled
+    if (this.config.enableWorktree) {
+      const worktreePath = await this.worktreeManager.createWorktree();
+      this.state.git.branchName = await this.worktreeManager.createBranch();
+      this.state.git.branchCreated = true;
+    }
+
+    // Initialize team for multi-agent coordination
+    this.team = await Team.create({
+      name: this.config.teamName,
+      description: `GLM daemon for: ${prompt.substring(0, 50)}...`,
+    });
+
+    // Run session start hook
+    await this.hooks.execute("onSessionStart", this.state);
+
+    // Save initial state
+    await this.stateManager.save(this.state);
+
+    // Start main loop
+    this.runLoop().catch((error) => {
+      console.error("[GLMDaemon] Loop error:", error);
+      this.running = false;
+    });
+
+    return this.config.teamName;
+  }
+
+  /**
+   * Main daemon loop (SLAM pattern)
+   */
+  private async runLoop(): Promise<void> {
+    while (this.running) {
+      // Check completion condition
+      if (this.checkCompletion()) {
+        await this.complete();
+        break;
+      }
+
+      // Check iteration limit
+      if (
+        this.state.maxIterations > 0 &&
+        this.state.iteration >= this.state.maxIterations
+      ) {
+        console.log(`[GLMDaemon] Max iterations reached: ${this.state.maxIterations}`);
+        await this.stop();
+        break;
+      }
+
+      // Run iteration start hook
+      await this.hooks.execute("onIterationStart", this.state.iteration);
+
+      // Execute current SLAM phase
+      await this.executePhase();
+
+      // Update state
+      this.state.iteration++;
+      this.state.lastUpdate = new Date().toISOString();
+
+      // Save state
+      await this.stateManager.save(this.state);
+
+      // Run iteration end hook
+      await this.hooks.execute("onIterationEnd", this.state.iteration, null);
+    }
+  }
+
+  /**
+   * Execute current SLAM phase
+   */
+  private async executePhase(): Promise<void> {
+    const phase = this.state.slam.phase;
+
+    switch (phase) {
+      case "planning":
+        await this.phasePlanning();
+        break;
+      case "executing":
+        await this.phaseExecuting();
+        break;
+      case "paranoid":
+        await this.phaseParanoid();
+        break;
+      case "reviewing":
+        await this.phaseReviewing();
+        break;
+      case "fixing":
+        await this.phaseFixing();
+        break;
+      case "committing":
+        await this.phaseCommitting();
+        break;
+      case "complete":
+        await this.complete();
+        break;
+    }
+  }
+
+  /**
+   * Planning phase - break down task into subtasks
+   */
+  private async phasePlanning(): Promise<void> {
+    console.log("[GLMDaemon] Phase: Planning");
+
+    const prompt = `${this.state.prompt}
+
+Break this task down into 3-7 concrete subtasks.
+For each subtask, specify:
+- Title (short description)
+- Description (what needs to be done)
+- Dependencies (which subtasks must come first)
+
+Respond with a JSON array of subtasks.
+`;
+
+    const response = await this.agent.execute(prompt);
+    const subtasks = this.parseSubtasks(response);
+
+    this.state.slam.subtasks = subtasks;
+    this.state.slam.phase = "executing";
+    this.state.slam.currentSubtask = subtasks[0]?.id || null;
+  }
+
+  /**
+   * Executing phase - work on current subtask
+   */
+  private async phaseExecuting(): Promise<void> {
+    const currentSubtaskId = this.state.slam.currentSubtask;
+    if (!currentSubtaskId) {
+      this.state.slam.phase = "reviewing";
+      return;
+    }
+
+    const subtask = this.state.slam.subtasks.find((st) => st.id === currentSubtaskId);
+    if (!subtask) {
+      this.state.slam.phase = "reviewing";
+      return;
+    }
+
+    console.log(`[GLMDaemon] Executing subtask: ${subtask.title}`);
+
+    const prompt = `Work on this subtask: ${subtask.title}
+
+${subtask.description}
+
+Use available tools to complete the work.
+Focus on code changes, testing, and verification.
+`;
+
+    const response = await this.agent.execute(prompt);
+
+    // Update subtask status
+    subtask.status = "completed";
+    subtask.result = response;
+    this.state.slam.completedSubtasks.push(currentSubtaskId);
+
+    // Move to next subtask or paranoid phase
+    const nextSubtask = this.state.slam.subtasks.find(
+      (st) => !this.state.slam.completedSubtasks.includes(st.id)
+    );
+
+    if (nextSubtask) {
+      this.state.slam.currentSubtask = nextSubtask.id;
+    } else {
+      this.state.slam.phase = "paranoid";
+    }
+  }
+
+  /**
+   * Paranoid phase - quality check after every edit
+   */
+  private async phaseParanoid(): Promise<void> {
+    console.log("[GLMDaemon] Phase: Paranoid (quality check)");
+
+    const prompt = `Review the changes made in this session for:
+- Bugs or errors
+- Edge cases not handled
+- Security vulnerabilities
+- Performance issues
+- Breaking changes
+
+Task: ${this.state.prompt}
+
+Changes made:
+${this.state.filesChanged.map((f) => `- ${f}`).join("\n")}
+
+Be thorough. If issues found, we'll fix them. If clean, we proceed to review.
+`;
+
+    const response = await this.agent.execute(prompt);
+    const hasIssues = this.detectIssues(response);
+
+    if (hasIssues) {
+      this.state.slam.phase = "fixing";
+    } else {
+      this.state.slam.phase = "reviewing";
+    }
+  }
+
+  /**
+   * Reviewing phase - final quality review
+   */
+  private async phaseReviewing(): Promise<void> {
+    console.log("[GLMDaemon] Phase: Reviewing");
+
+    const prompt = `Final review of the completed work.
+
+Task: ${this.state.prompt}
+Completion promise: ${this.state.promise}
+
+Does the implementation fully satisfy the completion promise?
+Are there any remaining issues or TODOs?
+
+If complete and clean, respond with "APPROVED".
+Otherwise, list remaining issues.
+`;
+
+    const response = await this.agent.execute(prompt);
+
+    if (response.includes("APPROVED")) {
+      this.state.slam.phase = "committing";
+    } else {
+      this.state.slam.phase = "fixing";
+    }
+  }
+
+  /**
+   * Fixing phase - fix issues found
+   */
+  private async phaseFixing(): Promise<void> {
+    console.log("[GLMDaemon] Phase: Fixing");
+
+    const prompt = `Fix the issues identified in the review.
+
+Use tools to make necessary changes.
+Test your fixes thoroughly.
+`;
+
+    await this.agent.execute(prompt);
+    this.state.slam.phase = "paranoid"; // Re-check after fixes
+  }
+
+  /**
+   * Committing phase - commit changes
+   */
+  private async phaseCommitting(): Promise<void> {
+    console.log("[GLMDaemon] Phase: Committing");
+
+    if (this.state.git.autoCommit) {
+      // Commit changes via worktree manager
+      await this.worktreeManager.commitChanges({
+        message: `feat: ${this.state.prompt.substring(0, 50)}`,
+        files: this.state.filesChanged,
+      });
+    }
+
+    this.state.slam.phase = "complete";
+  }
+
+  /**
+   * Complete the daemon run
+   */
+  private async complete(): Promise<void> {
+    console.log("[GLMDaemon] Task complete!");
+    this.state.slam.phase = "complete";
+    this.running = false;
+
+    // Run session end hook
+    await this.hooks.execute("onSessionEnd", this.state);
+
+    // Save final state
+    await this.stateManager.save(this.state);
+
+    // Create PR if enabled
+    if (this.state.git.autoPR) {
+      await this.worktreeManager.createPullRequest({
+        title: this.state.prompt.substring(0, 50),
+        body: `Completes: ${this.state.promise}`,
+      });
+    }
+  }
+
+  /**
+   * Stop the daemon
+   */
+  async stop(): Promise<void> {
+    console.log("[GLMDaemon] Stopping...");
+    this.running = false;
+
+    // Cleanup
+    if (this.team) {
+      await this.team.broadcast("team-lead", "Daemon stopping");
+    }
+
+    // Save final state
+    await this.stateManager.save(this.state);
+  }
+
+  /**
+   * Get daemon status
+   */
+  getStatus(): GLMDaemonStatus {
+    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
+   */
+  private parseSubtasks(response: string): Array<{
+    id: string;
+    title: string;
+    description: string;
+    status: "pending" | "in_progress" | "completed" | "blocked" | "failed";
+    dependencies?: string[];
+  }> {
+    try {
+      const jsonMatch = response.match(/\[[\s\S]*\]/);
+      if (jsonMatch) {
+        const parsed = JSON.parse(jsonMatch[0]);
+        return parsed.map((st: any, idx: number) => ({
+          id: st.id || `subtask-${idx}`,
+          title: st.title || st.task || `Subtask ${idx + 1}`,
+          description: st.description || "",
+          status: "pending" as const,
+          dependencies: st.dependencies || [],
+        }));
+      }
+    } catch {
+      // 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
+   */
+  private detectIssues(response: string): boolean {
+    const issueKeywords = [
+      "bug", "error", "issue", "problem", "vulnerability",
+      "fix", "improve", "missing", "incomplete", "broken"
+    ];
+
+    const lower = response.toLowerCase();
+    return issueKeywords.some((kw) => lower.includes(kw));
+  }
+
+  /**
+   * Check if completion promise is met
+   */
+  private checkCompletion(): boolean {
+    // Simple check: all subtasks complete
+    const allComplete = this.state.slam.subtasks.length > 0 &&
+      this.state.slam.subtasks.every((st) =>
+        this.state.slam.completedSubtasks.includes(st.id)
+      );
+
+    return allComplete || this.state.slam.phase === "complete";
+  }
+}

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;