@ebowwa/daemons 0.5.0

package/src/skills/workflows.ts

@@ -0,0 +1,340 @@
+/**
+ * GLM Daemon - Skill-Based Workflows
+ *
+ * Workflow definitions using skill sequences.
+ * Replaces the old class-based workflow system.
+ */
+
+import type { SkillWorkflowConfig, SkillTransition } from "./types.js";
+
+// ============================================
+// CODING WORKFLOW
+// ============================================
+
+const codingTransitions: SkillTransition[] = [
+  // Planning -> Execution
+  { from: "/plan-task", to: "/execute-subtask", priority: 100 },
+
+  // Execution flow
+  { from: "/execute-subtask", to: "/quality-check",
+    condition: (ctx) => {
+      const completed = ctx.state.slam.completedSubtasks?.length || 0;
+      const total = ctx.state.slam.subtasks?.length || 0;
+      return total > 0 && completed >= total;
+    },
+    priority: 90 },
+  { from: "/execute-subtask", to: "/execute-subtask", priority: 50 },
+
+  // Quality check flow
+  { from: "/quality-check", to: "/fix-issues",
+    condition: (_, result) => (result.data as Record<string, unknown>)?.hasIssues === true,
+    priority: 90 },
+  { from: "/quality-check", to: "/review", priority: 80 },
+
+  // Review flow
+  { from: "/review", to: "/fix-issues",
+    condition: (_, result) => (result.data as Record<string, unknown>)?.approved === false,
+    priority: 90 },
+  { from: "/review", to: "/commit", priority: 80 },
+
+  // Fix flow
+  { from: "/fix-issues", to: "/quality-check", priority: 100 },
+
+  // Commit -> Complete
+  { from: "/commit", to: "/complete", priority: 100 },
+
+  // Reflection (can happen from any skill)
+  { from: "*", to: "/reflect",
+    condition: (ctx) => {
+      const enabled = ctx.state.reflection?.toolCount !== undefined;
+      const limit = 50; // Default tool limit
+      const count = ctx.state.reflection?.toolCount || 0;
+      return enabled && count >= limit;
+    },
+    priority: 200 },
+  { from: "/reflect", to: "/execute-subtask", priority: 100 },
+];
+
+export const codingWorkflow: SkillWorkflowConfig = {
+  id: "coding",
+  name: "Coding Workflow",
+  description: "Software development workflow with planning, execution, and quality checks",
+
+  skills: [
+    "/plan-task",
+    "/execute-subtask",
+    "/reflect",
+    "/quality-check",
+    "/review",
+    "/fix-issues",
+    "/commit",
+  ],
+
+  initialSkill: "/plan-task",
+  terminalSkills: ["/commit", "/complete"],
+
+  transitions: codingTransitions,
+
+  systemPromptExtensions: `You are a software development assistant.
+Use tools when available. Be thorough but efficient.
+Focus on code changes, testing, and verification.`,
+
+  reflectionSkill: "/reflect",
+};
+
+// ============================================
+// TRADING WORKFLOW
+// ============================================
+
+const tradingTransitions: SkillTransition[] = [
+  // Analysis flow
+  { from: "/analyze-market", to: "/generate-signal", priority: 100 },
+
+  // Signal flow
+  { from: "/generate-signal", to: "/check-risk",
+    condition: (_, result) => (result.data as Record<string, unknown>)?.direction !== "none",
+    priority: 100 },
+  { from: "/generate-signal", to: "/analyze-market",
+    condition: (_, result) => (result.data as Record<string, unknown>)?.direction === "none",
+    priority: 90 },
+
+  // Risk check flow
+  { from: "/check-risk", to: "/execute-trade",
+    condition: (_, result) => (result.data as Record<string, unknown>)?.approved === true,
+    priority: 100 },
+  { from: "/check-risk", to: "/analyze-market",
+    condition: (_, result) => (result.data as Record<string, unknown>)?.approved === false,
+    priority: 90 },
+
+  // Execution -> Monitoring
+  { from: "/execute-trade", to: "/monitor-position",
+    condition: (_, result) => result.success && (result.data as Record<string, unknown>)?.status !== "failed",
+    priority: 100 },
+  { from: "/execute-trade", to: "/analyze-market",
+    condition: (_, result) => !result.success,
+    priority: 90 },
+
+  // Monitoring flow
+  { from: "/monitor-position", to: "/complete",
+    condition: (ctx) => ctx.custom.targetReached === true || ctx.custom.stopLoss === true,
+    priority: 100 },
+  { from: "/monitor-position", to: "/analyze-market",
+    condition: (ctx) => ctx.custom.positionClosed === true,
+    priority: 90 },
+  { from: "/monitor-position", to: "/reflect",
+    condition: (ctx) => ctx.state.iteration > 0 && ctx.state.iteration % 10 === 0,
+    priority: 80 },
+  { from: "/monitor-position", to: "/monitor-position", priority: 50 },
+
+  // Reflection
+  { from: "/reflect", to: "/monitor-position", priority: 100 },
+];
+
+export const tradingWorkflow: SkillWorkflowConfig = {
+  id: "trading",
+  name: "Trading Workflow",
+  description: "Trading workflow with analysis, signal generation, risk management, and execution",
+
+  skills: [
+    "/analyze-market",
+    "/generate-signal",
+    "/check-risk",
+    "/execute-trade",
+    "/monitor-position",
+    "/reflect",
+  ],
+
+  initialSkill: "/analyze-market",
+  terminalSkills: ["/complete"],
+
+  transitions: tradingTransitions,
+
+  skillParams: {
+    "/check-risk": {
+      maxRiskPerTrade: 2,
+      minRiskReward: 1.5,
+    },
+    "/execute-trade": {
+      paper: true, // Default to paper trading
+    },
+  },
+
+  systemPromptExtensions: `You are a trading assistant.
+Follow risk management rules strictly.
+Never exceed position size limits.
+Always use stop-loss orders.
+No git operations are needed - focus on market execution.`,
+
+  reflectionSkill: "/reflect",
+};
+
+// ============================================
+// WORKFLOW REGISTRY
+// ============================================
+
+/**
+ * Simple workflow registry for skill-based workflows
+ */
+class WorkflowConfigRegistry {
+  private workflows: Map<string, SkillWorkflowConfig> = new Map();
+  private defaultWorkflow: string | null = null;
+
+  register(config: SkillWorkflowConfig, setDefault = false): void {
+    this.workflows.set(config.id, config);
+    if (setDefault || this.workflows.size === 1) {
+      this.defaultWorkflow = config.id;
+    }
+  }
+
+  get(id: string): SkillWorkflowConfig | undefined {
+    return this.workflows.get(id);
+  }
+
+  getDefault(): SkillWorkflowConfig | undefined {
+    if (!this.defaultWorkflow) return undefined;
+    return this.workflows.get(this.defaultWorkflow);
+  }
+
+  list(): Array<{ id: string; name: string; description: string }> {
+    return Array.from(this.workflows.values()).map((w) => ({
+      id: w.id,
+      name: w.name,
+      description: w.description,
+    }));
+  }
+}
+
+export const workflowConfigRegistry = new WorkflowConfigRegistry();
+
+// Register built-in workflows
+workflowConfigRegistry.register(codingWorkflow, true);
+workflowConfigRegistry.register(tradingWorkflow);
+
+// ============================================
+// WORKFLOW EXECUTOR
+// ============================================
+
+import type { SkillContext, SkillResult } from "./types.js";
+import { skillRegistry } from "./registry.js";
+
+/**
+ * Execute a skill-based workflow
+ */
+export async function executeWorkflowSkill(
+  workflow: SkillWorkflowConfig,
+  context: SkillContext
+): Promise<SkillResult> {
+  const currentSkillId = context.state.slam.phase as string;
+
+  // Get skill params from workflow config
+  const skillParams = workflow.skillParams?.[currentSkillId];
+
+  // Execute the current skill
+  const result = await skillRegistry.execute(
+    currentSkillId,
+    context,
+    skillParams
+  );
+
+  if (!result.success) {
+    return result;
+  }
+
+  // Check if skill specified next skill
+  if (result.nextSkill) {
+    return {
+      ...result,
+      stateUpdates: {
+        ...result.stateUpdates,
+        slam: {
+          ...context.state.slam,
+          ...result.stateUpdates?.slam,
+          phase: result.nextSkill,
+        },
+      },
+    };
+  }
+
+  // Find next skill using transitions
+  const nextSkill = await findNextSkill(workflow, context, result);
+
+  return {
+    ...result,
+    stateUpdates: {
+      ...result.stateUpdates,
+      slam: {
+        ...context.state.slam,
+        ...result.stateUpdates?.slam,
+        phase: nextSkill,
+      },
+    },
+  };
+}
+
+/**
+ * Find the next skill based on transitions
+ */
+async function findNextSkill(
+  workflow: SkillWorkflowConfig,
+  context: SkillContext,
+  result: SkillResult
+): Promise<string> {
+  const currentSkillId = context.state.slam.phase as string;
+
+  // Sort transitions by priority (descending)
+  const sortedTransitions = [...workflow.transitions].sort(
+    (a, b) => (b.priority || 0) - (a.priority || 0)
+  );
+
+  // Check each transition
+  for (const transition of sortedTransitions) {
+    // Check if transition matches current skill (or wildcard)
+    if (transition.from !== "*" && transition.from !== currentSkillId) {
+      continue;
+    }
+
+    // Check condition if present
+    if (transition.condition) {
+      try {
+        const shouldTransition = await transition.condition(context, result);
+        if (!shouldTransition) continue;
+      } catch {
+        continue;
+      }
+    }
+
+    // Return target skill
+    return transition.to;
+  }
+
+  // Fall back to default order
+  const currentIndex = workflow.skills.indexOf(currentSkillId);
+  if (currentIndex >= 0 && currentIndex < workflow.skills.length - 1) {
+    return workflow.skills[currentIndex + 1];
+  }
+
+  // Stay on current skill if no transition matches
+  return currentSkillId;
+}
+
+/**
+ * Check if workflow is complete
+ */
+export async function isWorkflowComplete(
+  workflow: SkillWorkflowConfig,
+  context: SkillContext
+): Promise<boolean> {
+  const currentPhase = context.state.slam.phase as string;
+
+  // Check if in terminal skill
+  if (workflow.terminalSkills.includes(currentPhase)) {
+    return true;
+  }
+
+  // Check custom completion condition
+  if (workflow.isComplete) {
+    return await workflow.isComplete(context);
+  }
+
+  return false;
+}

package/src/state.ts

@@ -0,0 +1,77 @@
+/**
+ * GLM Daemon - State Manager
+ *
+ * Manages SLAM state persistence to disk.
+ */
+
+import { promises as fsp } from "fs";
+import type { GLMDaemonState } from "./types.js";
+
+export class StateManager {
+  private statePath: string;
+
+  constructor(statePath: string) {
+    this.statePath = statePath;
+  }
+
+  /**
+   * Load state from disk
+   */
+  async load(): Promise<GLMDaemonState | null> {
+    try {
+      const content = await fsp.readFile(this.statePath, "utf-8");
+      return JSON.parse(content) as GLMDaemonState;
+    } catch {
+      // File doesn't exist or invalid JSON
+      return null;
+    }
+  }
+
+  /**
+   * Save state to disk
+   */
+  async save(state: GLMDaemonState): Promise<void> {
+    await fsp.writeFile(
+      this.statePath,
+      JSON.stringify(state, null, 2),
+      "utf-8"
+    );
+  }
+
+  /**
+   * Delete state file
+   */
+  async delete(): Promise<void> {
+    try {
+      await fsp.unlink(this.statePath);
+    } catch {
+      // File doesn't exist, ignore
+    }
+  }
+
+  /**
+   * Check if state file exists
+   */
+  async exists(): Promise<boolean> {
+    try {
+      await fsp.access(this.statePath);
+      return true;
+    } catch {
+      return false;
+    }
+  }
+
+  /**
+   * Update a portion of state (merge)
+   */
+  async update(updates: Partial<GLMDaemonState>): Promise<GLMDaemonState> {
+    const current = await this.load();
+    if (!current) {
+      throw new Error("No existing state to update");
+    }
+
+    const updated = { ...current, ...updates };
+    await this.save(updated);
+    return updated;
+  }
+}

package/src/tools.ts

@@ -0,0 +1,134 @@
+/**
+ * GLM Daemon - Tool Bridge
+ *
+ * Connects GLM agents to MCP servers for tool access.
+ */
+
+import type { GLMToolsConfig } from "./types.js";
+
+export class ToolBridge {
+  private config: GLMToolsConfig;
+  private availableTools: string[] = [];
+  private toolTimeout: number;
+  private maxRetries: number;
+
+  constructor(config: GLMToolsConfig = {}) {
+    this.config = config;
+    this.toolTimeout = config.toolTimeout || 30000;
+    this.maxRetries = config.maxRetries || 3;
+  }
+
+  /**
+   * Get list of available tools
+   */
+  getAvailableTools(): string[] {
+    return this.availableTools;
+  }
+
+  /**
+   * Set available tools (from MCP discovery)
+   */
+  setAvailableTools(tools: string[]): void {
+    this.availableTools = tools;
+  }
+
+  /**
+   * Check if a tool is allowed
+   */
+  isToolAllowed(toolName: string): boolean {
+    // Check blacklist first
+    if (this.config.blockedTools?.includes(toolName)) {
+      return false;
+    }
+
+    // If whitelist exists, check it
+    if (this.config.allowedTools && this.config.allowedTools.length > 0) {
+      return this.config.allowedTools.includes(toolName);
+    }
+
+    // Default: allow if not blocked
+    return true;
+  }
+
+  /**
+   * Execute a tool with timeout and retry
+   */
+  async executeTool(
+    toolName: string,
+    args: Record<string, unknown>
+  ): Promise<{ success: boolean; result?: unknown; error?: string }> {
+    if (!this.isToolAllowed(toolName)) {
+      return {
+        success: false,
+        error: `Tool not allowed: ${toolName}`,
+      };
+    }
+
+    let lastError: Error | null = null;
+
+    for (let attempt = 0; attempt < this.maxRetries; attempt++) {
+      try {
+        const result = await this.executeWithTimeout(toolName, args);
+        return { success: true, result };
+      } catch (error) {
+        lastError = error as Error;
+        // Wait before retry (exponential backoff)
+        if (attempt < this.maxRetries - 1) {
+          await new Promise((resolve) =>
+            setTimeout(resolve, Math.pow(2, attempt) * 1000)
+          );
+        }
+      }
+    }
+
+    return {
+      success: false,
+      error: lastError?.message || "Unknown error",
+    };
+  }
+
+  /**
+   * Execute tool with timeout
+   */
+  private async executeWithTimeout(
+    toolName: string,
+    args: Record<string, unknown>
+  ): Promise<unknown> {
+    return new Promise((resolve, reject) => {
+      const timer = setTimeout(() => {
+        reject(new Error(`Tool timeout: ${toolName}`));
+      }, this.toolTimeout);
+
+      // TODO: Actually call MCP tool here
+      // For now, this is a placeholder
+      setTimeout(() => {
+        clearTimeout(timer);
+        resolve(`Executed ${toolName} with ${JSON.stringify(args)}`);
+      }, 100);
+    });
+  }
+
+  /**
+   * Discover tools from MCP servers
+   */
+  async discoverMCPTools(): Promise<void> {
+    if (!this.config.enableMCP) {
+      return;
+    }
+
+    // TODO: Query MCP servers for available tools
+    // For now, add common tools
+    const commonTools = [
+      "Read",
+      "Write",
+      "Edit",
+      "Grep",
+      "Glob",
+      "Bash",
+      "git_status",
+      "git_commit",
+    ];
+
+    this.setAvailableTools(commonTools);
+  }
+}