@ebowwa/daemons 0.5.0

package/src/workflows/coding.ts

@@ -0,0 +1,580 @@
+/**
+ * GLM Daemon - Coding Workflow
+ *
+ * Default coding workflow extracted from hardcoded daemon phases.
+ * Phases: planning → executing → reflecting → paranoid → reviewing → fixing → committing → complete
+ */
+
+import {
+  BaseWorkflow,
+  type GLMWorkflowConfig,
+  type GLMWorkflowContext,
+  type GLMWorkflowPhaseResult,
+  type GLMWorkflowPhase,
+  type GLMWorkflowTransition,
+} from "../workflow.js";
+import type { GLMReflectionSummary } from "../types.js";
+
+/**
+ * Coding workflow phases
+ */
+export type CodingPhase =
+  | "planning"
+  | "executing"
+  | "reflecting"
+  | "paranoid"
+  | "reviewing"
+  | "fixing"
+  | "committing"
+  | "complete";
+
+/**
+ * Coding workflow phases definition
+ */
+export const CODING_PHASES: GLMWorkflowPhase<CodingPhase>[] = [
+  {
+    name: "planning",
+    label: "Planning",
+    description: "Break down the task into subtasks",
+    skippable: false,
+  },
+  {
+    name: "executing",
+    label: "Executing",
+    description: "Work on the current subtask",
+    skippable: false,
+  },
+  {
+    name: "reflecting",
+    label: "Reflecting",
+    description: "Checkpoint after N tools - summarize progress",
+    skippable: true,
+    timeout: 60000,
+  },
+  {
+    name: "paranoid",
+    label: "Paranoid",
+    description: "Quality check after every edit",
+    skippable: false,
+  },
+  {
+    name: "reviewing",
+    label: "Reviewing",
+    description: "Final quality review",
+    skippable: false,
+  },
+  {
+    name: "fixing",
+    label: "Fixing",
+    description: "Fix issues found in review",
+    skippable: true,
+  },
+  {
+    name: "committing",
+    label: "Committing",
+    description: "Commit changes",
+    skippable: true,
+  },
+  {
+    name: "complete",
+    label: "Complete",
+    description: "Task is finished",
+    skippable: false,
+  },
+];
+
+/**
+ * Coding workflow transition rules
+ */
+export const CODING_TRANSITIONS: GLMWorkflowTransition<CodingPhase>[] = [
+  // Planning -> Executing (always)
+  {
+    from: "planning",
+    to: "executing",
+    priority: 100,
+  },
+  // Executing -> Paranoid (when all subtasks complete)
+  {
+    from: "executing",
+    to: "paranoid",
+    priority: 90,
+    condition: (ctx) => {
+      const subtasks = ctx.state.slam.subtasks;
+      const completed = ctx.state.slam.completedSubtasks;
+      return subtasks.length > 0 && subtasks.every((s) => completed.includes(s.id));
+    },
+  },
+  // Executing -> Executing (continue with next subtask)
+  {
+    from: "executing",
+    to: "executing",
+    priority: 80,
+  },
+  // Paranoid -> Fixing (if issues found)
+  {
+    from: "paranoid",
+    to: "fixing",
+    priority: 90,
+    condition: async (ctx) => {
+      // This will be set by the phase execution
+      return ctx.custom.hasIssues === true;
+    },
+  },
+  // Paranoid -> Reviewing (if no issues)
+  {
+    from: "paranoid",
+    to: "reviewing",
+    priority: 80,
+  },
+  // Reviewing -> Fixing (if not approved)
+  {
+    from: "reviewing",
+    to: "fixing",
+    priority: 90,
+    condition: async (ctx) => {
+      return ctx.custom.approved !== true;
+    },
+  },
+  // Reviewing -> Committing (if approved)
+  {
+    from: "reviewing",
+    to: "committing",
+    priority: 80,
+  },
+  // Fixing -> Paranoid (re-check after fixes)
+  {
+    from: "fixing",
+    to: "paranoid",
+    priority: 100,
+  },
+  // Committing -> Complete
+  {
+    from: "committing",
+    to: "complete",
+    priority: 100,
+  },
+  // Reflecting -> previous phase (handled specially)
+  {
+    from: "reflecting",
+    to: "executing", // Default, will be overridden
+    priority: 100,
+    condition: async (ctx) => {
+      // Return to previous phase
+      const prev = ctx.state.slam.previousPhase;
+      if (prev) {
+        ctx.custom.nextPhase = prev;
+      }
+      return true;
+    },
+  },
+];
+
+/**
+ * Coding workflow configuration
+ */
+export const CODING_WORKFLOW_CONFIG: GLMWorkflowConfig<CodingPhase> = {
+  id: "coding",
+  name: "Coding Workflow",
+  description: "Default coding workflow for software development tasks",
+  phases: CODING_PHASES,
+  initialPhase: "planning",
+  terminalPhases: ["complete"],
+  transitions: CODING_TRANSITIONS,
+  defaultOrder: ["planning", "executing", "paranoid", "reviewing", "fixing", "committing", "complete"],
+  reflectionPhase: "reflecting",
+  systemPromptExtensions: `Use tools when available. Be thorough but efficient.
+Focus on code changes, testing, and verification.`,
+};
+
+/**
+ * Coding Workflow implementation
+ */
+export class CodingWorkflow extends BaseWorkflow<CodingPhase> {
+  constructor() {
+    super(CODING_WORKFLOW_CONFIG);
+  }
+
+  /**
+   * Execute a coding phase
+   */
+  async executePhase(phase: string, context: GLMWorkflowContext): Promise<GLMWorkflowPhaseResult> {
+    switch (phase as CodingPhase) {
+      case "planning":
+        return this.phasePlanning(context);
+      case "executing":
+        return this.phaseExecuting(context);
+      case "reflecting":
+        return this.phaseReflecting(context);
+      case "paranoid":
+        return this.phaseParanoid(context);
+      case "reviewing":
+        return this.phaseReviewing(context);
+      case "fixing":
+        return this.phaseFixing(context);
+      case "committing":
+        return this.phaseCommitting(context);
+      case "complete":
+        return this.phaseComplete(context);
+      default:
+        throw new Error(`Unknown phase: ${phase}`);
+    }
+  }
+
+  /**
+   * Planning phase - break down task into subtasks
+   */
+  private async phasePlanning(context: GLMWorkflowContext): Promise<GLMWorkflowPhaseResult> {
+    console.log("[CodingWorkflow] Phase: Planning");
+
+    const prompt = `${context.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 context.agent.execute(prompt);
+    const subtasks = this.parseSubtasks(response, context);
+
+    return {
+      nextPhase: "executing",
+      continue: true,
+      stateUpdates: {
+        slam: {
+          ...context.state.slam,
+          subtasks,
+          currentSubtask: subtasks[0]?.id || null,
+          phase: "executing",
+        },
+      } as any,
+    };
+  }
+
+  /**
+   * Executing phase - work on current subtask
+   */
+  private async phaseExecuting(context: GLMWorkflowContext): Promise<GLMWorkflowPhaseResult> {
+    const currentSubtaskId = context.state.slam.currentSubtask;
+
+    if (!currentSubtaskId) {
+      return {
+        nextPhase: "reviewing",
+        continue: true,
+      };
+    }
+
+    const subtask = context.state.slam.subtasks.find((st) => st.id === currentSubtaskId);
+    if (!subtask) {
+      return {
+        nextPhase: "reviewing",
+        continue: true,
+      };
+    }
+
+    console.log(`[CodingWorkflow] 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 context.agent.execute(prompt);
+
+    // Find next subtask
+    const completedSubtasks = [...context.state.slam.completedSubtasks, currentSubtaskId];
+    const nextSubtask = context.state.slam.subtasks.find(
+      (st) => !completedSubtasks.includes(st.id)
+    );
+
+    // Update subtask status
+    const updatedSubtasks = context.state.slam.subtasks.map((st) =>
+      st.id === currentSubtaskId
+        ? { ...st, status: "completed" as const, result: response }
+        : st
+    );
+
+    // Determine next phase
+    const nextPhase = nextSubtask ? "executing" : "paranoid";
+
+    return {
+      nextPhase,
+      continue: true,
+      stateUpdates: {
+        slam: {
+          ...context.state.slam,
+          subtasks: updatedSubtasks,
+          completedSubtasks,
+          currentSubtask: nextSubtask?.id || null,
+          phase: nextPhase,
+        },
+      } as any,
+    };
+  }
+
+  /**
+   * Reflecting phase - TL;DR checkpoint after N tools
+   */
+  private async phaseReflecting(context: GLMWorkflowContext): Promise<GLMWorkflowPhaseResult> {
+    console.log(`[CodingWorkflow] Phase: Reflecting (checkpoint #${context.state.reflection.checkpointCount + 1})`);
+    console.log(`[CodingWorkflow] Tools used this chunk: ${context.state.reflection.toolCount}`);
+
+    const previousPhase = context.state.slam.previousPhase || "executing";
+
+    const prompt = `REFLECTION CHECKPOINT #${context.state.reflection.checkpointCount + 1}
+
+You have used ${context.state.reflection.toolCount} tools. Pause and reflect.
+
+Task: ${context.state.prompt}
+Current Phase (before reflection): ${previousPhase}
+Iteration: ${context.state.iteration}
+Subtasks: ${context.state.slam.completedSubtasks.length}/${context.state.slam.subtasks.length} complete
+
+Files changed: ${context.state.filesChanged.length > 0 ? context.state.filesChanged.join(", ") : "none"}
+
+Generate a TL;DR summary in this JSON format:
+{
+  "summary": "1-2 sentence summary of progress",
+  "accomplishments": ["what was done"],
+  "nextSteps": ["what needs to be done next"],
+  "issues": ["any blockers or problems"]
+}
+
+Be concise. Focus on what matters for continuing the task.
+`;
+
+    const response = await context.agent.execute(prompt);
+    const summary = this.parseReflectionSummary(response, previousPhase, context);
+
+    // Run reflection hook
+    await context.executeHook("onReflection", context.state, summary);
+
+    // Log the reflection
+    console.log(`[CodingWorkflow] TL;DR: ${summary.summary}`);
+    console.log(`[CodingWorkflow] Accomplishments: ${summary.accomplishments.join(", ")}`);
+    console.log(`[CodingWorkflow] Next: ${summary.nextSteps.join(", ")}`);
+
+    return {
+      nextPhase: previousPhase,
+      continue: true,
+      data: { summary },
+    };
+  }
+
+  /**
+   * Paranoid phase - quality check after every edit
+   */
+  private async phaseParanoid(context: GLMWorkflowContext): Promise<GLMWorkflowPhaseResult> {
+    console.log("[CodingWorkflow] 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: ${context.state.prompt}
+
+Changes made:
+${context.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 context.agent.execute(prompt);
+    const hasIssues = this.detectIssues(response);
+
+    // Store result in context for transition condition
+    context.custom.hasIssues = hasIssues;
+
+    return {
+      nextPhase: hasIssues ? "fixing" : "reviewing",
+      continue: true,
+    };
+  }
+
+  /**
+   * Reviewing phase - final quality review
+   */
+  private async phaseReviewing(context: GLMWorkflowContext): Promise<GLMWorkflowPhaseResult> {
+    console.log("[CodingWorkflow] Phase: Reviewing");
+
+    const prompt = `Final review of the completed work.
+
+Task: ${context.state.prompt}
+Completion promise: ${context.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 context.agent.execute(prompt);
+    const approved = response.includes("APPROVED");
+
+    // Store result in context for transition condition
+    context.custom.approved = approved;
+
+    return {
+      nextPhase: approved ? "committing" : "fixing",
+      continue: true,
+    };
+  }
+
+  /**
+   * Fixing phase - fix issues found
+   */
+  private async phaseFixing(context: GLMWorkflowContext): Promise<GLMWorkflowPhaseResult> {
+    console.log("[CodingWorkflow] Phase: Fixing");
+
+    const prompt = `Fix the issues identified in the review.
+
+Use tools to make necessary changes.
+Test your fixes thoroughly.
+`;
+
+    await context.agent.execute(prompt);
+
+    // Reset approval state
+    context.custom.approved = false;
+    context.custom.hasIssues = false;
+
+    return {
+      nextPhase: "paranoid", // Re-check after fixes
+      continue: true,
+    };
+  }
+
+  /**
+   * Committing phase - commit changes
+   */
+  private async phaseCommitting(context: GLMWorkflowContext): Promise<GLMWorkflowPhaseResult> {
+    console.log("[CodingWorkflow] Phase: Committing");
+
+    if (context.state.git.autoCommit) {
+      // TODO: Use MCP git tools for commits
+      console.log("[CodingWorkflow] Auto-commit would happen here via MCP git tools");
+    }
+
+    return {
+      nextPhase: "complete",
+      continue: true,
+    };
+  }
+
+  /**
+   * Complete phase - task is finished
+   */
+  private async phaseComplete(context: GLMWorkflowContext): Promise<GLMWorkflowPhaseResult> {
+    console.log("[CodingWorkflow] Task complete!");
+
+    await context.executeHook("onSessionEnd", context.state);
+
+    return {
+      nextPhase: "complete",
+      continue: false, // Stop the loop
+    };
+  }
+
+  /**
+   * Parse subtasks from agent response
+   */
+  private parseSubtasks(
+    response: string,
+    context: GLMWorkflowContext
+  ): 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: context.state.prompt.substring(0, 50),
+        description: context.state.prompt,
+        status: "pending",
+      }];
+    }
+
+    return [];
+  }
+
+  /**
+   * Parse reflection summary from agent response
+   */
+  private parseReflectionSummary(
+    response: string,
+    phase: string,
+    context: GLMWorkflowContext
+  ): GLMReflectionSummary {
+    try {
+      const jsonMatch = response.match(/\{[\s\S]*\}/);
+      if (jsonMatch) {
+        const parsed = JSON.parse(jsonMatch[0]);
+        return {
+          checkpoint: context.state.reflection.checkpointCount + 1,
+          timestamp: new Date().toISOString(),
+          toolsUsed: context.state.reflection.toolCount,
+          phase: phase as any,
+          summary: parsed.summary || "Progress made",
+          accomplishments: parsed.accomplishments || [],
+          nextSteps: parsed.nextSteps || [],
+          issues: parsed.issues || [],
+        };
+      }
+    } catch {
+      // Fallback
+    }
+
+    return {
+      checkpoint: context.state.reflection.checkpointCount + 1,
+      timestamp: new Date().toISOString(),
+      toolsUsed: context.state.reflection.toolCount,
+      phase: phase as any,
+      summary: response.substring(0, 200),
+      accomplishments: [],
+      nextSteps: [],
+      issues: [],
+    };
+  }
+
+  /**
+   * 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));
+  }
+}
+
+// Export singleton instance
+export const codingWorkflow = new CodingWorkflow();

package/src/workflows/index.ts

@@ -0,0 +1,61 @@
+/**
+ * GLM Daemon - Workflows Index
+ *
+ * Export all available workflows and register them with the registry.
+ */
+
+import { workflowRegistry } from "../workflow.js";
+import { CodingWorkflow, codingWorkflow } from "./coding.js";
+import { TradingWorkflow, tradingWorkflow } from "./trading.js";
+
+// Re-export workflow types
+export type {
+  GLMWorkflowPhase,
+  GLMWorkflowContext,
+  GLMWorkflowPhaseResult,
+  GLMWorkflowTransition,
+  GLMWorkflowConfig,
+  GLMWorkflowExecutor,
+} from "../workflow.js";
+
+export { BaseWorkflow, WorkflowRegistry, workflowRegistry } from "../workflow.js";
+
+// Re-export coding workflow
+export { CodingWorkflow, CODING_PHASES, CODING_TRANSITIONS, CODING_WORKFLOW_CONFIG, codingWorkflow } from "./coding.js";
+
+// Re-export trading workflow
+export { TradingWorkflow, TRADING_PHASES, TRADING_TRANSITIONS, TRADING_WORKFLOW_CONFIG, tradingWorkflow } from "./trading.js";
+
+// Export phase types
+export type { CodingPhase } from "./coding.js";
+export type { TradingPhase } from "./trading.js";
+
+/**
+ * Initialize all built-in workflows
+ */
+export function initializeWorkflows(): void {
+  // Register coding workflow as default
+  workflowRegistry.register(codingWorkflow, true);
+
+  // Register trading workflow
+  workflowRegistry.register(tradingWorkflow);
+
+  console.log("[Workflows] Initialized workflows:", workflowRegistry.list().map(w => w.id).join(", "));
+}
+
+/**
+ * Get a workflow by ID
+ */
+export function getWorkflow(id: string) {
+  return workflowRegistry.get(id);
+}
+
+/**
+ * Get the default workflow
+ */
+export function getDefaultWorkflow() {
+  return workflowRegistry.getDefault();
+}
+
+// Auto-initialize on import
+initializeWorkflows();