@ebowwa/daemons 0.5.0

package/src/daemon.ts

@@ -0,0 +1,534 @@
+/**
+ * GLM Daemon - Core Daemon
+ *
+ * Main orchestrator for autonomous GLM 4.7 agents.
+ * Implements SLAM pattern: State → Loop → Action → Memory
+ *
+ * Now skill-based - uses composable skills instead of hardcoded phases.
+ */
+
+import { promises as fsp } from "fs";
+import { join } from "path";
+import type {
+  GLMDaemonConfig,
+  GLMDaemonState,
+  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 { Team } from "@ebowwa/teammates";
+import { GLMClient } from "@ebowwa/ai";
+import {
+  type SkillWorkflowConfig,
+  type SkillContext,
+  codingWorkflow,
+  workflowConfigRegistry,
+  executeWorkflowSkill,
+  isWorkflowComplete,
+  skillRegistry,
+} from "./skills/index.js";
+
+// Re-export types for external use
+export type { GLMDaemonConfig, GLMDaemonState, GLMDaemonStatus } from "./types.js";
+
+const STATE_FILE = ".glm-daemon.json";
+const SETTINGS_FILE = ".claude/settings.local.json";
+
+/**
+ * Extended daemon config with skill-based workflow support
+ */
+export interface GLMDaemonConfigWithWorkflow extends GLMDaemonConfig {
+  /** Workflow ID to use (defaults to "coding") */
+  workflowId?: string;
+}
+
+export class GLMDaemon {
+  private config: GLMDaemonConfigWithWorkflow;
+  private state: GLMDaemonState;
+  private statePath: string;
+  private agent: GLMAgent;
+  private hooks: HookSystem;
+  private tools: ToolBridge;
+  private stateManager: StateManager;
+  private team: Team | null = null;
+  private subagents: Map<string, GLMAgent> = new Map();
+  private running = false;
+  private client: GLMClient;
+  private workflow: SkillWorkflowConfig;
+  private customContext: Record<string, unknown> = {};
+
+  constructor(config: GLMDaemonConfigWithWorkflow) {
+    this.config = config;
+    this.statePath = join(config.cwd, STATE_FILE);
+    this.client = new GLMClient();
+
+    // Initialize workflow from registry
+    const workflowId = config.workflowId || "coding";
+    const foundWorkflow = workflowConfigRegistry.get(workflowId);
+    if (!foundWorkflow) {
+      throw new Error(`Workflow not found: ${workflowId}. Available: ${workflowConfigRegistry.list().map(w => w.id).join(", ")}`);
+    }
+    this.workflow = foundWorkflow;
+
+    console.log(`[GLMDaemon] Using workflow: ${this.workflow.name}`);
+
+    // 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);
+
+    // Initialize main agent
+    this.agent = new GLMAgent({
+      agentId: "glm-daemon",
+      name: "GLM Daemon",
+      prompt: this.buildSystemPrompt(),
+      model: config.model,
+      tools: this.tools.getAvailableTools(),
+    });
+
+    // Log available skills
+    console.log(`[GLMDaemon] Available skills: ${skillRegistry.listIds().length}`);
+  }
+
+  /**
+   * Initialize daemon state
+   */
+  private initializeState(): GLMDaemonState {
+    const now = new Date().toISOString();
+    const initialSkill = this.workflow.initialSkill;
+
+    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: initialSkill, // Now uses skill ID as phase
+        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",
+        branchName: "",
+        branchCreated: false,
+        currentCommit: "",
+      },
+      reflection: {
+        toolCount: 0,
+        totalToolCount: 0,
+        checkpointCount: 0,
+        lastReflection: null,
+        summaries: [],
+      },
+    };
+  }
+
+  /**
+   * Build system prompt using workflow config
+   */
+  private buildSystemPrompt(): string {
+    const currentSkillId = this.state.slam.phase;
+    const currentSkill = skillRegistry.get(currentSkillId);
+
+    let prompt = `You are an autonomous AI agent.
+
+Your task: ${this.state.prompt}
+
+Workflow: ${this.workflow.name}
+Available skills in this workflow:
+${this.workflow.skills.map(s => `- ${s}`).join("\n")}
+
+Current skill: ${currentSkill?.name || currentSkillId}
+${currentSkill?.description ? `Description: ${currentSkill.description}` : ""}
+
+Iteration: ${this.state.iteration}
+`;
+
+    if (this.workflow.systemPromptExtensions) {
+      prompt += `\n${this.workflow.systemPromptExtensions}`;
+    }
+
+    return prompt;
+  }
+
+  /**
+   * Create skill execution context
+   */
+  private createSkillContext(): SkillContext {
+    return {
+      state: this.state,
+      agent: this.agent,
+      custom: this.customContext,
+      incrementToolCount: () => this.incrementToolCount(),
+      executeHook: (event: string, ...args: unknown[]) => this.hooks.execute(event, ...args),
+      callSkill: async (id: string, params?: unknown) => {
+        return skillRegistry.execute(id, this.createSkillContext(), params);
+      },
+      workflowConfig: this.workflow.skillParams,
+    };
+  }
+
+  /**
+   * 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;
+
+    // Update agent prompt
+    this.agent = new GLMAgent({
+      agentId: "glm-daemon",
+      name: "GLM Daemon",
+      prompt: this.buildSystemPrompt(),
+      model: this.config.model,
+      tools: this.tools.getAvailableTools(),
+    });
+
+    // 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);
+
+    console.log(`[GLMDaemon] Starting with skill: ${this.state.slam.phase}`);
+
+    // 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 with skill execution)
+   */
+  private async runLoop(): Promise<void> {
+    while (this.running) {
+      // Check completion condition
+      if (await 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 skill
+      await this.executeSkill();
+
+      // 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 skill via skill registry
+   */
+  private async executeSkill(): Promise<void> {
+    const currentSkillId = this.state.slam.phase;
+    console.log(`[GLMDaemon] Executing skill: ${currentSkillId}`);
+
+    // Create skill context
+    const context = this.createSkillContext();
+
+    try {
+      // Execute via skill-based workflow
+      const result = await executeWorkflowSkill(this.workflow, context);
+
+      // Update custom context
+      if (result.contextUpdates) {
+        this.customContext = { ...this.customContext, ...result.contextUpdates };
+      }
+
+      // Apply state updates from result
+      if (result.stateUpdates) {
+        this.applyStateUpdates(result.stateUpdates);
+      }
+
+      // Update phase from result (skill transition)
+      if (result.stateUpdates?.slam?.phase) {
+        const newPhase = result.stateUpdates.slam.phase;
+        if (newPhase !== currentSkillId) {
+          console.log(`[GLMDaemon] Skill transition: ${currentSkillId} -> ${newPhase}`);
+          this.state.slam.phase = newPhase;
+        }
+      }
+
+      // Stop loop if requested
+      if (!result.success && result.error) {
+        console.error(`[GLMDaemon] Skill error:`, result.error);
+      }
+    } catch (error) {
+      console.error(`[GLMDaemon] Skill execution failed:`, error);
+      throw error;
+    }
+  }
+
+  /**
+   * Apply state updates from skill result
+   */
+  private applyStateUpdates(updates: Partial<GLMDaemonState>): void {
+    // Deep merge slam updates
+    if (updates.slam) {
+      this.state.slam = {
+        ...this.state.slam,
+        ...updates.slam,
+        state: {
+          ...this.state.slam.state,
+          ...(updates.slam.state || {}),
+        },
+        memory: {
+          ...this.state.slam.memory,
+          ...(updates.slam.memory || {}),
+        },
+      };
+    }
+
+    // Apply other updates
+    if (updates.filesChanged) {
+      this.state.filesChanged = updates.filesChanged;
+    }
+    if (updates.workMemory) {
+      this.state.workMemory = updates.workMemory;
+    }
+    if (updates.git) {
+      this.state.git = { ...this.state.git, ...updates.git };
+    }
+    if (updates.reflection) {
+      this.state.reflection = { ...this.state.reflection, ...updates.reflection };
+    }
+  }
+
+  /**
+   * Increment tool count and check for reflection trigger
+   */
+  incrementToolCount(): boolean {
+    const reflectionConfig = this.config.reflection || {
+      enabled: false,
+      toolLimit: 0,
+      autoContinue: true,
+    };
+
+    this.state.reflection.toolCount++;
+    this.state.reflection.totalToolCount++;
+
+    // Check if we hit the limit
+    if (reflectionConfig.enabled && reflectionConfig.toolLimit > 0 &&
+        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 = "/reflect"; // Use skill ID
+      return true; // Reflection triggered
+    }
+
+    return false;
+  }
+
+  /**
+   * 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) {
+      // TODO: Use MCP git tools for PR creation
+      console.log("[GLMDaemon] Auto-PR would happen here via MCP git tools");
+    }
+  }
+
+  /**
+   * Check if workflow is complete
+   */
+  private async checkCompletion(): Promise<boolean> {
+    const context = this.createSkillContext();
+    return isWorkflowComplete(this.workflow, context);
+  }
+
+  /**
+   * 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,
+    };
+  }
+
+  /**
+   * 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: false,
+      toolLimit: 0,
+    };
+
+    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 = "/reflect";
+
+    // Execute reflection skill
+    const context = this.createSkillContext();
+    const result = await skillRegistry.execute("/reflect", context);
+
+    // Return to previous phase
+    if (result.stateUpdates?.slam?.phase) {
+      this.state.slam.phase = result.stateUpdates.slam.phase;
+    } else {
+      this.state.slam.phase = this.state.slam.previousPhase || "/execute-subtask";
+    }
+
+    // Return the summary from result data
+    return result.data as any || null;
+  }
+
+  /**
+   * Get the current workflow config
+   */
+  getWorkflow(): SkillWorkflowConfig {
+    return this.workflow;
+  }
+
+  /**
+   * Get workflow configuration
+   */
+  getWorkflowConfig() {
+    return this.workflow;
+  }
+
+  /**
+   * Get custom context (for debugging)
+   */
+  getContext(): Record<string, unknown> {
+    return { ...this.customContext };
+  }
+
+  /**
+   * List available skills
+   */
+  listSkills(): Array<{ id: string; name: string; description: string }> {
+    return skillRegistry.getInfo();
+  }
+}

package/src/hooks.ts

@@ -0,0 +1,97 @@
+/**
+ * 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);
+    }
+    if (config.onReflection) {
+      this.register("onReflection", config.onReflection 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());
+  }
+}