@ebowwa/daemons 0.5.0

package/src/skills/coding/execute-subtask.ts

@@ -0,0 +1,136 @@
+/**
+ * GLM Daemon - Execute Subtask Skill
+ *
+ * Work on the current subtask from the plan.
+ */
+
+import { z } from "zod";
+import type { Skill, SkillContext, SkillResult } from "../types.js";
+import { skillRegistry } from "../registry.js";
+import type { Subtask } from "./plan-task.js";
+
+/**
+ * Execute subtask parameters
+ */
+const ExecuteSubtaskParams = z.object({
+  /** Specific subtask ID to execute (defaults to current) */
+  subtaskId: z.string().optional(),
+});
+
+/**
+ * Execute subtask result data
+ */
+interface ExecuteSubtaskData {
+  subtaskId: string;
+  title: string;
+  result: string;
+  completed: boolean;
+  nextSubtaskId: string | null;
+}
+
+/**
+ * Execute subtask skill
+ */
+export const executeSubtaskSkill: Skill<z.infer<typeof ExecuteSubtaskParams>, ExecuteSubtaskData> = {
+  id: "/execute-subtask",
+  name: "Execute Subtask",
+  description: "Work on the current subtask using available tools.",
+  paramsSchema: ExecuteSubtaskParams,
+  tags: ["coding", "execution"],
+  parallelizable: false,
+  requires: ["subtasks"],
+
+  async execute(params, context): Promise<SkillResult<ExecuteSubtaskData>> {
+    // Get subtask to execute
+    const subtaskId = params?.subtaskId || context.state.slam.currentSubtask;
+
+    if (!subtaskId) {
+      console.log("[/execute-subtask] No current subtask, all complete");
+      return {
+        success: true,
+        data: {
+          subtaskId: "",
+          title: "",
+          result: "All subtasks complete",
+          completed: true,
+          nextSubtaskId: null,
+        },
+        nextSkill: "/quality-check",
+      };
+    }
+
+    const subtask = context.state.slam.subtasks.find((st) => st.id === subtaskId) as Subtask | undefined;
+
+    if (!subtask) {
+      return {
+        success: false,
+        error: `Subtask not found: ${subtaskId}`,
+      };
+    }
+
+    console.log(`[/execute-subtask] Working on: ${subtask.title}`);
+
+    const prompt = `Work on this subtask: ${subtask.title}
+
+${subtask.description}
+
+Use available tools to complete the work.
+Focus on making concrete progress.
+
+When done, briefly summarize what was accomplished.`;
+
+    try {
+      const result = await context.agent.execute(prompt);
+
+      // Mark subtask as completed
+      const completedSubtasks = [...new Set([...context.state.slam.completedSubtasks, subtaskId])];
+      const updatedSubtasks = context.state.slam.subtasks.map((st) =>
+        st.id === subtaskId ? { ...st, status: "completed" as const, result } : st
+      );
+
+      // Find next subtask (that isn't completed and has dependencies met)
+      const nextSubtask = context.state.slam.subtasks.find(
+        (st) => !completedSubtasks.includes(st.id) && (!st.dependencies || st.dependencies.every((d) => completedSubtasks.includes(d)))
+      );
+
+      const allComplete = completedSubtasks.length === context.state.slam.subtasks.length;
+
+      console.log(`[/execute-subtask] Completed: ${subtask.title}`);
+      console.log(`[/execute-subtask] Progress: ${completedSubtasks.length}/${context.state.slam.subtasks.length}`);
+
+      return {
+        success: true,
+        data: {
+          subtaskId,
+          title: subtask.title,
+          result: result.substring(0, 500),
+          completed: allComplete,
+          nextSubtaskId: nextSubtask?.id || null,
+        },
+        stateUpdates: {
+          slam: {
+            ...context.state.slam,
+            subtasks: updatedSubtasks,
+            currentSubtask: nextSubtask?.id || null,
+            completedSubtasks,
+          },
+        },
+        contextUpdates: {
+          currentSubtask: nextSubtask?.id || null,
+          lastCompletedSubtask: subtaskId,
+        },
+        nextSkill: allComplete ? "/quality-check" : undefined,
+      };
+    } catch (error) {
+      return {
+        success: false,
+        error: error instanceof Error ? error.message : String(error),
+      };
+    }
+  },
+};
+
+skillRegistry.register(executeSubtaskSkill);
+
+export { ExecuteSubtaskParams };
+export type { ExecuteSubtaskData };

package/src/skills/coding/fix-issues.ts

@@ -0,0 +1,126 @@
+/**
+ * GLM Daemon - Fix Issues Skill
+ *
+ * Fix issues found during quality check or review.
+ */
+
+import { z } from "zod";
+import type { Skill, SkillContext, SkillResult } from "../types.js";
+import { skillRegistry } from "../registry.js";
+
+/**
+ * Fix issues parameters
+ */
+const FixIssuesParams = z.object({
+  /** Specific issues to fix (defaults to all) */
+  issues: z.array(z.string()).optional(),
+  /** Maximum fixes to attempt */
+  maxFixes: z.number().optional(),
+});
+
+/**
+ * Fix issues result data
+ */
+interface FixIssuesData {
+  fixedCount: number;
+  remainingIssues: string[];
+  fixes: string[];
+}
+
+/**
+ * Fix issues skill
+ */
+export const fixIssuesSkill: Skill<z.infer<typeof FixIssuesParams>, FixIssuesData> = {
+  id: "/fix-issues",
+  name: "Fix Issues",
+  description: "Fix issues identified during quality check or review.",
+  paramsSchema: FixIssuesParams,
+  tags: ["coding", "fixing"],
+  parallelizable: false,
+  requires: ["qualityIssues"],
+
+  async execute(params, context): Promise<SkillResult<FixIssuesData>> {
+    const issues = params?.issues || (context.custom.qualityIssues as string[]) || [];
+    const maxFixes = params?.maxFixes || 10;
+
+    if (issues.length === 0) {
+      console.log("[/fix-issues] No issues to fix");
+      return {
+        success: true,
+        data: {
+          fixedCount: 0,
+          remainingIssues: [],
+          fixes: [],
+        },
+        nextSkill: "/review",
+      };
+    }
+
+    console.log(`[/fix-issues] Fixing ${issues.length} issues`);
+
+    const prompt = `Fix the following issues:
+
+${issues.map((issue, i) => `${i + 1}. ${issue}`).join("\n")}
+
+Context:
+- Task: ${context.state.prompt}
+- Files changed: ${context.state.filesChanged.join(", ") || "none"}
+
+Use tools to make the necessary fixes.
+Test your changes after fixing.
+Report what was fixed.`;
+
+    try {
+      const response = await context.agent.execute(prompt);
+
+      // Parse what was fixed from response
+      const fixes: string[] = [];
+      const fixedMatch = response.match(/fixed:?\s*([\s\S]*?)(?=remaining|still|$)/i);
+      if (fixedMatch) {
+        fixes.push(...fixedMatch[1].split("\n").filter((l) => l.trim()));
+      }
+
+      // Check if issues are resolved (simplified - would need actual validation)
+      const remainingIssues: string[] = [];
+      const lowerResponse = response.toLowerCase();
+      for (const issue of issues) {
+        if (
+          !lowerResponse.includes("fixed") &&
+          !lowerResponse.includes("resolved") &&
+          lowerResponse.includes("still")
+        ) {
+          remainingIssues.push(issue);
+        }
+      }
+
+      const fixedCount = issues.length - remainingIssues.length;
+
+      console.log(`[/fix-issues] Fixed ${fixedCount}/${issues.length} issues`);
+
+      return {
+        success: true,
+        data: {
+          fixedCount,
+          remainingIssues,
+          fixes: fixes.length > 0 ? fixes : [response.substring(0, 200)],
+        },
+        contextUpdates: {
+          qualityIssues: remainingIssues,
+          hasIssues: remainingIssues.length > 0,
+          lastFixes: fixes,
+        },
+        nextSkill: "/quality-check", // Re-check after fixes
+      };
+    } catch (error) {
+      return {
+        success: false,
+        error: error instanceof Error ? error.message : String(error),
+      };
+    }
+  },
+};
+
+skillRegistry.register(fixIssuesSkill);
+
+export { FixIssuesParams };
+export type { FixIssuesData };

package/src/skills/coding/index.ts

@@ -0,0 +1,26 @@
+/**
+ * GLM Daemon - Coding Skills
+ *
+ * Skills for software development workflows.
+ */
+
+// Import to auto-register
+import "./plan-task.js";
+import "./execute-subtask.js";
+import "./quality-check.js";
+import "./fix-issues.js";
+import "./commit.js";
+
+// Re-export for explicit imports
+export { planTaskSkill } from "./plan-task.js";
+export { executeSubtaskSkill } from "./execute-subtask.js";
+export { qualityCheckSkill } from "./quality-check.js";
+export { fixIssuesSkill } from "./fix-issues.js";
+export { commitSkill } from "./commit.js";
+
+// Re-export types
+export type { PlanTaskData, Subtask } from "./plan-task.js";
+export type { ExecuteSubtaskData } from "./execute-subtask.js";
+export type { QualityCheckData } from "./quality-check.js";
+export type { FixIssuesData } from "./fix-issues.js";
+export type { CommitData } from "./commit.js";

package/src/skills/coding/plan-task.ts

@@ -0,0 +1,158 @@
+/**
+ * GLM Daemon - Plan Task Skill
+ *
+ * Break down a task into subtasks for execution.
+ */
+
+import { z } from "zod";
+import type { Skill, SkillContext, SkillResult } from "../types.js";
+import { skillRegistry } from "../registry.js";
+
+/**
+ * Plan task parameters
+ */
+const PlanTaskParams = z.object({
+  /** Max number of subtasks to create */
+  maxSubtasks: z.number().min(2).max(10).optional(),
+  /** Force replanning even if subtasks exist */
+  force: z.boolean().optional(),
+});
+
+/**
+ * Subtask structure
+ */
+interface Subtask {
+  id: string;
+  title: string;
+  description: string;
+  status: "pending" | "in_progress" | "completed" | "blocked" | "failed";
+  dependencies?: string[];
+}
+
+/**
+ * Plan task result data
+ */
+interface PlanTaskData {
+  subtasks: Subtask[];
+  firstSubtaskId: string;
+}
+
+/**
+ * Plan task skill
+ */
+export const planTaskSkill: Skill<z.infer<typeof PlanTaskParams>, PlanTaskData> = {
+  id: "/plan-task",
+  name: "Plan Task",
+  description: "Break down a task into concrete subtasks with dependencies.",
+  paramsSchema: PlanTaskParams,
+  tags: ["coding", "planning"],
+  parallelizable: false,
+  produces: ["subtasks", "currentSubtask"],
+
+  async execute(params, context): Promise<SkillResult<PlanTaskData>> {
+    const maxSubtasks = params?.maxSubtasks ?? 7;
+    const force = params?.force ?? false;
+
+    // Skip if subtasks already exist and not forcing
+    if (!force && context.state.slam.subtasks.length > 0) {
+      console.log("[/plan-task] Subtasks already exist, skipping");
+      return {
+        success: true,
+        data: {
+          subtasks: context.state.slam.subtasks as Subtask[],
+          firstSubtaskId: context.state.slam.subtasks[0]?.id,
+        },
+      };
+    }
+
+    console.log("[/plan-task] Breaking down task into subtasks");
+
+    const prompt = `${context.state.prompt}
+
+Break this task down into ${maxSubtasks} or fewer concrete subtasks.
+For each subtask, specify:
+- Title (short description)
+- Description (what needs to be done)
+- Dependencies (which subtasks must complete first, by ID)
+
+Respond with a JSON array:
+[
+  {
+    "id": "subtask-0",
+    "title": "Short title",
+    "description": "Detailed description",
+    "dependencies": []
+  }
+]
+
+Keep subtasks small and actionable. Each should be completable in one iteration.`;
+
+    try {
+      const response = await context.agent.execute(prompt);
+
+      // Parse JSON from response
+      const jsonMatch = response.match(/\[[\s\S]*\]/);
+      let subtasks: Subtask[] = [];
+
+      if (jsonMatch) {
+        const parsed = JSON.parse(jsonMatch[0]);
+        subtasks = 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 || [],
+        }));
+      }
+
+      // Fallback if parsing failed
+      if (subtasks.length === 0) {
+        subtasks = [
+          {
+            id: "subtask-0",
+            title: context.state.prompt.substring(0, 50),
+            description: context.state.prompt,
+            status: "pending",
+          },
+        ];
+      }
+
+      console.log(`[/plan-task] Created ${subtasks.length} subtasks`);
+      subtasks.forEach((st, i) => {
+        console.log(`  ${i + 1}. ${st.title}`);
+      });
+
+      const firstSubtaskId = subtasks[0]?.id;
+
+      return {
+        success: true,
+        data: {
+          subtasks,
+          firstSubtaskId,
+        },
+        stateUpdates: {
+          slam: {
+            ...context.state.slam,
+            subtasks,
+            currentSubtask: firstSubtaskId || null,
+            completedSubtasks: [],
+          },
+        },
+        contextUpdates: {
+          subtasks,
+          currentSubtask: firstSubtaskId,
+        },
+      };
+    } catch (error) {
+      return {
+        success: false,
+        error: error instanceof Error ? error.message : String(error),
+      };
+    }
+  },
+};
+
+skillRegistry.register(planTaskSkill);
+
+export { PlanTaskParams };
+export type { PlanTaskData, Subtask };

package/src/skills/coding/quality-check.ts

@@ -0,0 +1,155 @@
+/**
+ * GLM Daemon - Quality Check Skill
+ *
+ * Paranoid review of changes made during execution.
+ */
+
+import { z } from "zod";
+import type { Skill, SkillContext, SkillResult } from "../types.js";
+import { skillRegistry } from "../registry.js";
+
+/**
+ * Quality check parameters
+ */
+const QualityCheckParams = z.object({
+  /** Focus areas for the check */
+  focusAreas: z.array(z.string()).optional(),
+  /** Strictness level */
+  strictness: z.enum(["relaxed", "normal", "strict"]).optional(),
+});
+
+/**
+ * Quality check result data
+ */
+interface QualityCheckData {
+  passed: boolean;
+  hasIssues: boolean;
+  issues: string[];
+  warnings: string[];
+  assessment: string;
+}
+
+/**
+ * Default focus areas
+ */
+const DEFAULT_FOCUS_AREAS = [
+  "Bugs or errors",
+  "Edge cases not handled",
+  "Security vulnerabilities",
+  "Performance issues",
+  "Breaking changes",
+  "Type errors",
+  "Missing error handling",
+];
+
+/**
+ * Quality check skill
+ */
+export const qualityCheckSkill: Skill<z.infer<typeof QualityCheckParams>, QualityCheckData> = {
+  id: "/quality-check",
+  name: "Quality Check",
+  description: "Paranoid review of all changes for bugs, security issues, and quality problems.",
+  paramsSchema: QualityCheckParams,
+  tags: ["coding", "quality", "validation"],
+  parallelizable: false,
+  produces: ["hasIssues", "issues"],
+
+  async execute(params, context): Promise<SkillResult<QualityCheckData>> {
+    const focusAreas = params?.focusAreas || DEFAULT_FOCUS_AREAS;
+    const strictness = params?.strictness || "normal";
+
+    console.log("[/quality-check] Running paranoid review");
+
+    const filesChanged = context.state.filesChanged.length > 0
+      ? context.state.filesChanged.join("\n- ")
+      : "No files changed";
+
+    const prompt = `Review the changes made in this session for quality issues.
+
+Task: ${context.state.prompt}
+
+Files changed:
+- ${filesChanged}
+
+Focus areas (${strictness} mode):
+${focusAreas.map((a, i) => `${i + 1}. ${a}`).join("\n")}
+
+Be thorough but fair. In "relaxed" mode, only flag critical issues.
+In "strict" mode, flag even minor issues.
+
+Respond in JSON format:
+{
+  "passed": true|false,
+  "hasIssues": true|false,
+  "issues": ["critical problems that MUST be fixed"],
+  "warnings": ["minor issues or suggestions"],
+  "assessment": "overall assessment"
+}
+
+Set hasIssues to true only if there are critical problems in the "issues" array.
+Minor concerns go in "warnings".`;
+
+    try {
+      const response = await context.agent.execute(prompt);
+
+      // Parse JSON from response
+      const jsonMatch = response.match(/\{[\s\S]*\}/);
+      let data: QualityCheckData;
+
+      if (jsonMatch) {
+        const parsed = JSON.parse(jsonMatch[0]);
+        data = {
+          passed: parsed.passed ?? !parsed.hasIssues,
+          hasIssues: parsed.hasIssues ?? (parsed.issues?.length > 0),
+          issues: parsed.issues || [],
+          warnings: parsed.warnings || [],
+          assessment: parsed.assessment || "",
+        };
+      } else {
+        // Fallback: detect issues from response
+        const lowerResponse = response.toLowerCase();
+        const issueKeywords = ["bug", "error", "critical", "must fix", "problem", "vulnerability"];
+        const hasIssues = issueKeywords.some((kw) => lowerResponse.includes(kw));
+        data = {
+          passed: !hasIssues,
+          hasIssues,
+          issues: hasIssues ? ["Issues detected in review"] : [],
+          warnings: [],
+          assessment: response.substring(0, 500),
+        };
+      }
+
+      console.log(`[/quality-check] Result: ${data.passed ? "PASSED" : "ISSUES FOUND"}`);
+      if (data.issues.length > 0) {
+        console.log(`[/quality-check] Issues: ${data.issues.length}`);
+      }
+      if (data.warnings.length > 0) {
+        console.log(`[/quality-check] Warnings: ${data.warnings.length}`);
+      }
+
+      return {
+        success: true,
+        data,
+        contextUpdates: {
+          hasIssues: data.hasIssues,
+          qualityIssues: data.issues,
+          qualityWarnings: data.warnings,
+        },
+        nextSkill: data.hasIssues ? "/fix-issues" : "/review",
+      };
+    } catch (error) {
+      return {
+        success: false,
+        error: error instanceof Error ? error.message : String(error),
+        contextUpdates: {
+          hasIssues: false,
+        },
+      };
+    }
+  },
+};
+
+skillRegistry.register(qualityCheckSkill);
+
+export { QualityCheckParams };
+export type { QualityCheckData };

package/src/skills/index.ts

@@ -0,0 +1,65 @@
+/**
+ * Daemons - Skills Module
+ *
+ * Composable skill system for workflow phases.
+ *
+ * Usage:
+ * ```typescript
+ * import { skillRegistry, defineSkill } from '@ebowwa/daemons/skills';
+ *
+ * // Define a skill (auto-registers)
+ * const mySkill = defineSkill({
+ *   id: 'my-skill',
+ *   name: 'My Skill',
+ *   description: 'Does something useful',
+ * }, async (params, context) => {
+ *   // Do work
+ *   return { success: true, data: { result: 'done' } };
+ * });
+ *
+ * // Execute a skill
+ * const result = await skillRegistry.execute('my-skill', context, { foo: 'bar' });
+ *
+ * // Use built-in workflows
+ * import { codingWorkflow, executeWorkflowSkill } from '@ebowwa/daemons/skills';
+ * ```
+ *
+ * Skills are auto-registered on import. To use all built-in skills:
+ * ```typescript
+ * import '@ebowwa/daemons/skills'; // Core types + registry + workflows
+ * ```
+ */
+
+// Core types
+export type {
+  Skill,
+  SkillConfig,
+  SkillContext,
+  SkillResult,
+  SkillData,
+  SkillParams,
+  SkillTransition,
+  SkillTransitionCondition,
+  SkillWorkflowConfig,
+  SkillExecutionMeta,
+  SkillExecutionOptions,
+} from "./types.js";
+
+// Registry
+export { SkillRegistry, skillRegistry, defineSkill } from "./registry.js";
+
+// Shared skills (auto-register on import)
+export * from "./shared/index.js";
+
+// Domain-specific skills (auto-register on import)
+export * from "./coding/index.js";
+export * from "./trading/index.js";
+
+// Workflow definitions and executor
+export {
+  codingWorkflow,
+  tradingWorkflow,
+  workflowConfigRegistry,
+  executeWorkflowSkill,
+  isWorkflowComplete,
+} from "./workflows.js";