@ebowwa/daemons 0.5.0

package/src/types.ts

@@ -0,0 +1,314 @@
+/**
+ * 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).
+ */
+
+import type { Team } from "@ebowwa/teammates";
+
+/**
+ * GLM Daemon state phases (SLAM pattern)
+ * @deprecated Skills now use string IDs directly (e.g., "/plan-task")
+ */
+export const GLM_PHASES = {
+  planning: "planning",
+  executing: "executing",
+  reflecting: "reflecting", // Checkpoint after N tools
+  paranoid: "paranoid",
+  reviewing: "reviewing",
+  fixing: "fixing",
+  committing: "committing",
+  complete: "complete",
+} as const;
+
+/**
+ * Legacy phase type for backwards compatibility
+ * @deprecated Skills now use string IDs (e.g., "/plan-task", "/execute-subtask")
+ */
+export type GLMPhase = keyof typeof GLM_PHASES;
+
+/**
+ * GLM Daemon configuration
+ */
+export interface GLMDaemonConfig {
+  /** Team name for multi-agent coordination */
+  teamName: string;
+
+  /** GLM model to use */
+  model?: string;
+
+  /** Working directory */
+  cwd: string;
+
+  /** Enable automatic commits */
+  autoCommit?: boolean;
+
+  /** Enable automatic PR creation */
+  autoPR?: boolean;
+
+  /** Base branch for PRs */
+  baseBranch?: string;
+
+  /** Maximum iterations (0 = unlimited) */
+  maxIterations?: number;
+
+  /** Completion promise text */
+  completionPromise?: string;
+
+  /** Hooks configuration */
+  hooks?: GLMHooksConfig;
+
+  /** Tools configuration */
+  tools?: GLMToolsConfig;
+
+  /** Reflection checkpoint configuration */
+  reflection?: GLMReflectionConfig;
+}
+
+/**
+ * GLM Daemon state (persisted to disk)
+ */
+export interface GLMDaemonState {
+  /** Original prompt/task */
+  prompt: string;
+
+  /** Completion promise (when to stop) */
+  promise: string;
+
+  /** Current iteration */
+  iteration: number;
+
+  /** Maximum iterations */
+  maxIterations: number;
+
+  /** Start timestamp */
+  startTime: string;
+
+  /** Last update timestamp */
+  lastUpdate: string;
+
+  /** Token usage tracking */
+  tokens: {
+    totalInput: number;
+    totalOutput: number;
+    byIteration: Array<{
+      iteration: number;
+      input: number;
+      output: number;
+    }>;
+  };
+
+  /** Files changed in this session */
+  filesChanged: string[];
+
+  /** Working memory */
+  workMemory: {
+    completedFiles: string[];
+    fileChecksums: Record<string, string>;
+  };
+
+  /** SLAM state */
+  slam: {
+    enabled: boolean;
+    /** Current skill ID (e.g., "/plan-task", "/execute-subtask") or legacy phase */
+    phase: string;
+    /** Previous phase/skill (used to return after reflection) */
+    previousPhase?: string;
+    state: {
+      currentTask: string;
+      beliefs: Record<string, unknown>;
+      goals: string[];
+    };
+    subtasks: GLMSubtask[];
+    currentSubtask: string | null;
+    completedSubtasks: string[];
+    memory: {
+      actionsTaken: string[];
+      outcomes: Record<string, unknown>;
+      patterns: Record<string, unknown>;
+    };
+  };
+
+  /** Git configuration */
+  git: {
+    enabled: boolean;
+    autoCommit: boolean;
+    autoPR: boolean;
+    baseBranch: string;
+    branchName: string;
+    branchCreated: boolean;
+    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 };
+    memory: { total: number; free: number; tier: string };
+    disk: { total: number; available: number; tier: string };
+    platform: { os: string; arch: string; isContainer: boolean };
+    capacity: string;
+    score: number;
+  };
+}
+
+/**
+ * GLM Subtask (for SLAM coordination)
+ */
+export interface GLMSubtask {
+  id: string;
+  title: string;
+  description: string;
+  status: "pending" | "in_progress" | "completed" | "blocked" | "failed";
+  assignedTo?: string;
+  dependencies?: string[];
+  result?: unknown;
+}
+
+/**
+ * GLM Hooks configuration
+ */
+export interface GLMHooksConfig {
+  onSessionStart?: (state: GLMDaemonState) => Promise<void>;
+  onSessionEnd?: (state: GLMDaemonState) => Promise<void>;
+  onPreToolUse?: (tool: string, args: unknown) => Promise<boolean>;
+  onPostToolUse?: (tool: string, args: unknown, result: unknown) => Promise<void>;
+  onSubagentStart?: (subagentId: string) => Promise<void>;
+  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>;
+}
+
+/**
+ * GLM Tools configuration
+ */
+export interface GLMToolsConfig {
+  /** Enable MCP tool access */
+  enableMCP?: boolean;
+
+  /** Allowed tools (whitelist) */
+  allowedTools?: string[];
+
+  /** Blocked tools (blacklist) */
+  blockedTools?: string[];
+
+  /** Tool timeout in ms */
+  toolTimeout?: number;
+
+  /** Max retries for failed tools */
+  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)
+ */
+export interface GLMAgentConfig {
+  /** Agent ID */
+  agentId: string;
+
+  /** Agent name */
+  name: string;
+
+  /** System prompt */
+  prompt: string;
+
+  /** Model to use */
+  model?: string;
+
+  /** Temperature (0-1) */
+  temperature?: number;
+
+  /** Max tokens */
+  maxTokens?: number;
+
+  /** Tools this agent can use */
+  tools?: string[];
+
+  /** Assigned subtasks */
+  assignedSubtasks?: string[];
+}
+
+/**
+ * GLM Tool execution result
+ * @deprecated Use ToolExecutionResult from @ebowwa/codespaces-types/runtime/tools
+ */
+export interface GLMToolResult {
+  success: boolean;
+  result?: unknown;
+  error?: string;
+  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/skill when reflection occurred */
+  phase: string;
+  /** TL;DR summary */
+  summary: string;
+  /** Key accomplishments */
+  accomplishments: string[];
+  /** Next steps identified */
+  nextSteps: string[];
+  /** Issues/blockers found */
+  issues: string[];
+}
+
+/**
+ * GLM Daemon status
+ */
+export interface GLMDaemonStatus {
+  id: string;
+  status: "starting" | "running" | "complete" | "error" | "stopped";
+  /** Current skill ID or phase */
+  phase: string;
+  iteration: number;
+  prompt: string;
+  currentTask?: string;
+  totalSubtasks: number;
+  completedSubtasks: number;
+  startedAt: string;
+  lastUpdate: string;
+  processId?: number;
+}

package/src/workflow.ts

@@ -0,0 +1,341 @@
+/**
+ * GLM Daemon - Workflow System
+ *
+ * Pluggable workflow architecture for domain-agnostic daemon operations.
+ * Supports multiple workflows: coding, trading, research, etc.
+ */
+
+import type { GLMAgent } from "./agent.js";
+import type { GLMDaemonState, GLMReflectionSummary } from "./types.js";
+
+/**
+ * Workflow phase definition
+ */
+export interface GLMWorkflowPhase<P extends string = string> {
+  /** Phase identifier */
+  name: P;
+
+  /** Human-readable phase name */
+  label: string;
+
+  /** Phase description for system prompts */
+  description: string;
+
+  /** Optional timeout for this phase (ms) */
+  timeout?: number;
+
+  /** Whether this phase can be skipped */
+  skippable?: boolean;
+
+  /** Hooks to run before phase execution */
+  beforeHooks?: string[];
+
+  /** Hooks to run after phase execution */
+  afterHooks?: string[];
+}
+
+/**
+ * Workflow execution context
+ */
+export interface GLMWorkflowContext {
+  /** Current daemon state */
+  state: GLMDaemonState;
+
+  /** Agent instance for executing prompts */
+  agent: GLMAgent;
+
+  /** Reflection summary if in reflecting phase */
+  reflectionSummary?: GLMReflectionSummary;
+
+  /** Custom data for workflow-specific use */
+  custom: Record<string, unknown>;
+
+  /** Tool count increment callback */
+  incrementToolCount: () => boolean;
+
+  /** Hook execution callback */
+  executeHook: (event: string, ...args: unknown[]) => Promise<void>;
+}
+
+/**
+ * Phase execution result
+ */
+export interface GLMWorkflowPhaseResult {
+  /** Next phase to transition to */
+  nextPhase: string;
+
+  /** Whether to continue the loop */
+  continue: boolean;
+
+  /** Optional result data */
+  data?: unknown;
+
+  /** Optional error */
+  error?: Error;
+
+  /** State updates to apply */
+  stateUpdates?: Partial<GLMDaemonState>;
+}
+
+/**
+ * Workflow transition rule
+ */
+export interface GLMWorkflowTransition<P extends string = string> {
+  /** From phase */
+  from: P | "*";
+
+  /** Condition for transition */
+  condition?: (context: GLMWorkflowContext) => boolean | Promise<boolean>;
+
+  /** Target phase */
+  to: P;
+
+  /** Priority (higher = checked first) */
+  priority?: number;
+}
+
+/**
+ * Workflow configuration
+ */
+export interface GLMWorkflowConfig<P extends string = string> {
+  /** Workflow identifier */
+  id: string;
+
+  /** Human-readable name */
+  name: string;
+
+  /** Workflow description */
+  description: string;
+
+  /** All phases in this workflow */
+  phases: GLMWorkflowPhase<P>[];
+
+  /** Initial phase */
+  initialPhase: P;
+
+  /** Terminal phases (end states) */
+  terminalPhases: P[];
+
+  /** Transition rules */
+  transitions: GLMWorkflowTransition<P>[];
+
+  /** Default phase execution order if no transitions match */
+  defaultOrder?: P[];
+
+  /** Workflow-specific system prompt additions */
+  systemPromptExtensions?: string;
+
+  /** Reflection phase name (if supported) */
+  reflectionPhase?: P;
+
+  /** Custom completion check */
+  isComplete?: (context: GLMWorkflowContext) => boolean | Promise<boolean>;
+}
+
+/**
+ * Workflow executor interface
+ */
+export interface GLMWorkflowExecutor {
+  /** Get workflow configuration */
+  getConfig(): GLMWorkflowConfig;
+
+  /** Execute a specific phase */
+  executePhase(phase: string, context: GLMWorkflowContext): Promise<GLMWorkflowPhaseResult>;
+
+  /** Determine next phase based on current state */
+  getNextPhase(context: GLMWorkflowContext): Promise<string>;
+
+  /** Check if workflow is complete */
+  isComplete(context: GLMWorkflowContext): Promise<boolean>;
+
+  /** Get phase definition */
+  getPhase(phase: string): GLMWorkflowPhase | undefined;
+
+  /** Get all phases */
+  getPhases(): GLMWorkflowPhase[];
+
+  /** Build system prompt for current state */
+  buildSystemPrompt(context: GLMWorkflowContext): string;
+}
+
+/**
+ * Base workflow class with common functionality
+ */
+export abstract class BaseWorkflow<P extends string = string> implements GLMWorkflowExecutor {
+  protected config: GLMWorkflowConfig<P>;
+  protected phaseMap: Map<string, GLMWorkflowPhase<P>>;
+
+  constructor(config: GLMWorkflowConfig<P>) {
+    this.config = config;
+    this.phaseMap = new Map(config.phases.map(p => [p.name, p]));
+  }
+
+  getConfig(): GLMWorkflowConfig {
+    return this.config;
+  }
+
+  getPhase(phase: string): GLMWorkflowPhase | undefined {
+    return this.phaseMap.get(phase);
+  }
+
+  getPhases(): GLMWorkflowPhase[] {
+    return this.config.phases;
+  }
+
+  /**
+   * Execute a phase - must be implemented by subclasses
+   */
+  abstract executePhase(phase: string, context: GLMWorkflowContext): Promise<GLMWorkflowPhaseResult>;
+
+  /**
+   * Determine next phase based on transitions
+   */
+  async getNextPhase(context: GLMWorkflowContext): Promise<string> {
+    const currentPhase = context.state.slam.phase;
+
+    // Sort transitions by priority (descending)
+    const sortedTransitions = [...this.config.transitions].sort(
+      (a, b) => (b.priority || 0) - (a.priority || 0)
+    );
+
+    // Check each transition
+    for (const transition of sortedTransitions) {
+      if (transition.from === "*" || transition.from === currentPhase) {
+        if (!transition.condition) {
+          return transition.to;
+        }
+
+        const shouldTransition = await transition.condition(context);
+        if (shouldTransition) {
+          return transition.to;
+        }
+      }
+    }
+
+    // Fall back to default order
+    if (this.config.defaultOrder) {
+      const currentIndex = this.config.defaultOrder.indexOf(currentPhase as P);
+      if (currentIndex >= 0 && currentIndex < this.config.defaultOrder.length - 1) {
+        return this.config.defaultOrder[currentIndex + 1];
+      }
+    }
+
+    // Stay in current phase if no transition matches
+    return currentPhase;
+  }
+
+  /**
+   * Check if workflow is complete
+   */
+  async isComplete(context: GLMWorkflowContext): Promise<boolean> {
+    // Check if in terminal phase
+    if (this.config.terminalPhases.includes(context.state.slam.phase as P)) {
+      return true;
+    }
+
+    // Check custom completion condition
+    if (this.config.isComplete) {
+      return await this.config.isComplete(context);
+    }
+
+    return false;
+  }
+
+  /**
+   * Build system prompt with workflow context
+   */
+  buildSystemPrompt(context: GLMWorkflowContext): string {
+    const phase = this.getPhase(context.state.slam.phase);
+    const phaseInfo = phase
+      ? `${phase.label}: ${phase.description}`
+      : context.state.slam.phase;
+
+    let prompt = `You are an autonomous AI agent.
+
+Your task: ${context.state.prompt}
+
+You work in phases:
+${this.config.phases.map(p => `- ${p.label}: ${p.description}`).join("\n")}
+
+Current phase: ${phaseInfo}
+Iteration: ${context.state.iteration}
+`;
+
+    if (this.config.systemPromptExtensions) {
+      prompt += `\n${this.config.systemPromptExtensions}`;
+    }
+
+    return prompt;
+  }
+}
+
+/**
+ * Workflow registry for managing multiple workflows
+ */
+export class WorkflowRegistry {
+  private workflows: Map<string, GLMWorkflowExecutor> = new Map();
+  private defaultWorkflow: string | null = null;
+
+  /**
+   * Register a workflow
+   */
+  register(workflow: GLMWorkflowExecutor, setDefault = false): void {
+    const config = workflow.getConfig();
+    this.workflows.set(config.id, workflow);
+
+    if (setDefault || this.workflows.size === 1) {
+      this.defaultWorkflow = config.id;
+    }
+  }
+
+  /**
+   * Get a workflow by ID
+   */
+  get(id: string): GLMWorkflowExecutor | undefined {
+    return this.workflows.get(id);
+  }
+
+  /**
+   * Get the default workflow
+   */
+  getDefault(): GLMWorkflowExecutor | undefined {
+    if (!this.defaultWorkflow) {
+      return undefined;
+    }
+    return this.workflows.get(this.defaultWorkflow);
+  }
+
+  /**
+   * Set the default workflow
+   */
+  setDefault(id: string): void {
+    if (!this.workflows.has(id)) {
+      throw new Error(`Workflow not found: ${id}`);
+    }
+    this.defaultWorkflow = id;
+  }
+
+  /**
+   * List all registered workflows
+   */
+  list(): Array<{ id: string; name: string; description: string }> {
+    return Array.from(this.workflows.values()).map(w => {
+      const config = w.getConfig();
+      return {
+        id: config.id,
+        name: config.name,
+        description: config.description,
+      };
+    });
+  }
+
+  /**
+   * Check if a workflow exists
+   */
+  has(id: string): boolean {
+    return this.workflows.has(id);
+  }
+}
+
+// Global registry instance
+export const workflowRegistry = new WorkflowRegistry();