@ebowwa/daemons 0.5.0 → 0.7.0

package/src/index.ts

@@ -1,111 +1,33 @@
 /**
- * Daemons - Autonomous Agent Daemon Framework
+ * @ebowwa/daemons
  *
- * A daemon framework for autonomous AI agents.
- * Implements SLAM pattern (State → Loop → Action → Memory).
- * Supports hooks, tools via MCP, multi-agent coordination, and communication channels.
+ * Framework for building daemons.
+ * Provides DaemonCore primitive with lifecycle, signals, channels, HTTP API, state persistence.
+ *
+ * @example
+ * ```ts
+ * import { DaemonCore } from "@ebowwa/daemons";
+ *
+ * class MyDaemon extends DaemonCore {
+ *   async start() {
+ *     // Register channels, set up handlers
+ *     await super.start();
+ *   }
+ * }
+ * ```
  *
  * @module @ebowwa/daemons
  */
 
-// Main daemon class
-export { GLMDaemon, type GLMDaemonConfigWithWorkflow } from "./daemon.js";
-
-// Agent class
-export { GLMAgent } from "./agent.js";
-
-// Supporting systems
-export { HookSystem } from "./hooks.js";
-export { ToolBridge } from "./tools.js";
-export { StateManager } from "./state.js";
-
-// Workflow system
-export {
-  // Classes
-  BaseWorkflow,
-  WorkflowRegistry,
-  workflowRegistry,
-  // Functions
-  initializeWorkflows,
-  getWorkflow,
-  getDefaultWorkflow,
-  // Built-in workflows
-  CodingWorkflow,
-  codingWorkflow,
-  CODING_PHASES,
-  CODING_TRANSITIONS,
-  CODING_WORKFLOW_CONFIG,
-  TradingWorkflow,
-  tradingWorkflow,
-  TRADING_PHASES,
-  TRADING_TRANSITIONS,
-  TRADING_WORKFLOW_CONFIG,
-  // Types
-  type GLMWorkflowPhase,
-  type GLMWorkflowContext,
-  type GLMWorkflowPhaseResult,
-  type GLMWorkflowTransition,
-  type GLMWorkflowConfig,
-  type GLMWorkflowExecutor,
-  type CodingPhase,
-  type TradingPhase,
-} from "./workflows/index.js";
-
-// Built-in tools - re-exported from @ebowwa/ai/tools for convenience
+// Generic daemon core
 export {
-  BUILTIN_TOOLS,
-  getBuiltinTool,
-  getBuiltinToolNames,
-  toGLMFormat,
-  executeBuiltinTool,
-  ToolExecutor,
-  type ToolDefinition,
-  type ToolCall,
-  type ToolExecutorOptions,
-  type ToolExecutionResult,
-} from "@ebowwa/ai/tools";
-
-// Memory systems
-export {
-  ConversationMemory,
-  NumericConversationMemory,
-  StringConversationMemory,
-  type ConversationMessage,
-  type ConversationMemoryConfig,
-} from "./memory.js";
-
-// Communication channels
-export {
-  BaseChannel,
-  TelegramChannel,
-  DiscordChannel,
-  ChannelRegistry,
-  type BaseChannelConfig,
-  type TelegramChannelConfig,
-  type DiscordChannelConfig,
-  type MessageContext,
-  type RouteResult,
-  type MessageClassification,
-} from "./channels/index.js";
+  DaemonCore,
+  type DaemonCoreConfig,
+  type DaemonCoreState,
+  type CoreHookName,
+  type CoreHookCallback,
+  type DaemonPlugin,
+} from "./core.js";
 
 // Types
 export * from "./types.js";
-
-// Convenience function to create and start a daemon
-import { GLMDaemon } from "./daemon.js";
-import type { GLMDaemonConfig } from "./types.js";
-
-export async function createGLMDaemon(
-  config: GLMDaemonConfig
-): Promise<GLMDaemon> {
-  const daemon = new GLMDaemon(config);
-  return daemon;
-}
-
-export async function startGLMDaemon(
-  config: GLMDaemonConfig,
-  prompt: string
-): Promise<string> {
-  const daemon = new GLMDaemon(config);
-  return await daemon.start(prompt);
-}

package/src/types.ts

@@ -1,314 +1,37 @@
 /**
- * GLM Daemon - Core Types
+ * Daemons - 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).
+ * Minimal types for DaemonCore and VPSDaemon.
  */
 
-import type { Team } from "@ebowwa/teammates";
+// ============================================================
+// Generic Daemon Types
+// ============================================================
 
-/**
- * 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;
+export type DaemonStatus = "starting" | "running" | "stopping" | "stopped" | "error";
 
-  /** 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 {
+export interface Channel {
   id: string;
-  title: string;
-  description: string;
-  status: "pending" | "in_progress" | "completed" | "blocked" | "failed";
-  assignedTo?: string;
-  dependencies?: string[];
-  result?: unknown;
+  type: string;
+  start(): Promise<void>;
+  stop(): Promise<void>;
+  isRunning(): boolean;
+  send?(message: unknown): Promise<unknown>;
+  onMessage(handler: (msg: unknown) => Promise<void>): void;
 }
 
-/**
- * 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 */
+export interface ChannelMessage {
+  id: string;
+  channelId: string;
+  type: "text" | "command" | "event";
+  content: string;
+  metadata?: Record<string, unknown>;
   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;
+export interface HealthStatus {
+  status: "healthy" | "degraded" | "unhealthy";
+  uptime: number;
+  channels: Record<string, { running: boolean; error?: string }>;
+  checks: Record<string, { passed: boolean; message?: string }>;
 }