@ebowwa/daemons 0.5.0

package/src/skills/registry.ts

@@ -0,0 +1,380 @@
+/**
+ * GLM Daemon - Skill Registry
+ *
+ * Central registry for all available skills.
+ * Skills register themselves on import, or can be registered manually.
+ */
+
+import type {
+  Skill,
+  SkillConfig,
+  SkillContext,
+  SkillResult,
+  SkillExecutionOptions,
+  SkillExecutionMeta,
+} from "./types.js";
+
+/**
+ * Skill Registry - manages all available skills
+ */
+export class SkillRegistry {
+  private skills: Map<string, Skill> = new Map();
+  private executionHistory: SkillExecutionMeta[] = [];
+  private maxHistorySize = 1000;
+
+  /**
+   * Register a skill
+   */
+  register(skill: Skill): void {
+    if (this.skills.has(skill.id)) {
+      console.warn(`[SkillRegistry] Overwriting existing skill: ${skill.id}`);
+    }
+    this.skills.set(skill.id, skill);
+    console.log(`[SkillRegistry] Registered skill: ${skill.id}`);
+  }
+
+  /**
+   * Register multiple skills
+   */
+  registerAll(skills: Skill[]): void {
+    for (const skill of skills) {
+      this.register(skill);
+    }
+  }
+
+  /**
+   * Get a skill by ID
+   */
+  get(id: string): Skill | undefined {
+    return this.skills.get(id);
+  }
+
+  /**
+   * Check if a skill exists
+   */
+  has(id: string): boolean {
+    return this.skills.has(id);
+  }
+
+  /**
+   * List all registered skills
+   */
+  list(): Skill[] {
+    return Array.from(this.skills.values());
+  }
+
+  /**
+   * List skill IDs only
+   */
+  listIds(): string[] {
+    return Array.from(this.skills.keys());
+  }
+
+  /**
+   * List skills by tag
+   */
+  listByTag(tag: string): Skill[] {
+    return this.list().filter((s) => s.tags?.includes(tag));
+  }
+
+  /**
+   * Get skills info for AI/discovery
+   */
+  getInfo(): Array<{
+    id: string;
+    name: string;
+    description: string;
+    tags?: string[];
+    parallelizable?: boolean;
+  }> {
+    return this.list().map((s) => ({
+      id: s.id,
+      name: s.name,
+      description: s.description,
+      tags: s.tags,
+      parallelizable: s.parallelizable,
+    }));
+  }
+
+  /**
+   * Execute a skill with retry logic
+   */
+  async execute(
+    skillId: string,
+    context: SkillContext,
+    params?: unknown,
+    options: SkillExecutionOptions = {}
+  ): Promise<SkillResult> {
+    const skill = this.skills.get(skillId);
+    if (!skill) {
+      return {
+        success: false,
+        error: `Skill not found: ${skillId}`,
+      };
+    }
+
+    // Validate parameters if schema provided
+    if (skill.paramsSchema && !options.skipValidation) {
+      const parsed = skill.paramsSchema.safeParse(params);
+      if (!parsed.success) {
+        return {
+          success: false,
+          error: `Invalid params for ${skillId}: ${parsed.error.message}`,
+        };
+      }
+    }
+
+    // Check required context keys
+    if (skill.requires) {
+      const missing = skill.requires.filter((key) => !(key in context.custom));
+      if (missing.length > 0) {
+        return {
+          success: false,
+          error: `Missing required context for ${skillId}: ${missing.join(", ")}`,
+        };
+      }
+    }
+
+    // Execute with retry
+    const maxRetries = options.maxRetries ?? skill.maxRetries ?? 3;
+    const baseDelay = skill.retryBaseDelay ?? 1000;
+    let lastError: string | undefined;
+
+    for (let attempt = 1; attempt <= maxRetries; attempt++) {
+      const meta: SkillExecutionMeta = {
+        skillId,
+        startTime: new Date().toISOString(),
+        attempt,
+        success: false,
+      };
+
+      try {
+        // Merge default params with provided params
+        const mergedParams = skill.defaultParams
+          ? { ...skill.defaultParams, ...(params as Record<string, unknown>) }
+          : params;
+
+        const result = await this.executeWithTimeout(
+          skill,
+          mergedParams,
+          context,
+          options.timeout
+        );
+
+        meta.endTime = new Date().toISOString();
+        meta.duration =
+          new Date(meta.endTime).getTime() - new Date(meta.startTime).getTime();
+        meta.success = result.success;
+        meta.error = result.error;
+
+        this.recordExecution(meta);
+
+        if (result.success) {
+          return result;
+        }
+
+        lastError = result.error;
+
+        // Don't retry on certain errors
+        if (
+          result.error?.includes("not allowed") ||
+          result.error?.includes("not found")
+        ) {
+          break;
+        }
+
+        // Exponential backoff before retry
+        if (attempt < maxRetries) {
+          const delay = baseDelay * Math.pow(2, attempt - 1);
+          console.log(
+            `[SkillRegistry] Retrying ${skillId} in ${delay}ms (attempt ${attempt}/${maxRetries})`
+          );
+          await new Promise((resolve) => setTimeout(resolve, delay));
+        }
+      } catch (error) {
+        meta.endTime = new Date().toISOString();
+        meta.duration =
+          new Date(meta.endTime).getTime() - new Date(meta.startTime).getTime();
+        meta.success = false;
+        meta.error = error instanceof Error ? error.message : String(error);
+        lastError = meta.error;
+
+        this.recordExecution(meta);
+
+        if (attempt < maxRetries) {
+          const delay = baseDelay * Math.pow(2, attempt - 1);
+          await new Promise((resolve) => setTimeout(resolve, delay));
+        }
+      }
+    }
+
+    return {
+      success: false,
+      error: lastError || `Skill failed after ${maxRetries} attempts`,
+    };
+  }
+
+  /**
+   * Execute multiple skills in parallel
+   */
+  async executeParallel(
+    skillIds: string[],
+    context: SkillContext,
+    params?: Record<string, unknown>
+  ): Promise<Map<string, SkillResult>> {
+    const results = new Map<string, SkillResult>();
+
+    // Validate all skills exist and are parallelizable
+    for (const id of skillIds) {
+      const skill = this.skills.get(id);
+      if (!skill) {
+        results.set(id, { success: false, error: `Skill not found: ${id}` });
+        continue;
+      }
+      if (!skill.parallelizable) {
+        results.set(id, {
+          success: false,
+          error: `Skill ${id} is not parallelizable`,
+        });
+      }
+    }
+
+    // Filter out already-failed skills
+    const toExecute = skillIds.filter((id) => !results.has(id));
+
+    // Execute in parallel
+    const promises = toExecute.map(async (id) => {
+      const result = await this.execute(id, context, params?.[id]);
+      return { id, result };
+    });
+
+    const settled = await Promise.allSettled(promises);
+
+    for (const item of settled) {
+      if (item.status === "fulfilled") {
+        results.set(item.value.id, item.value.result);
+      } else {
+        // This shouldn't happen as errors are caught in execute()
+        const id = toExecute[settled.indexOf(item)];
+        results.set(id, {
+          success: false,
+          error: item.reason?.message || "Unknown error",
+        });
+      }
+    }
+
+    return results;
+  }
+
+  /**
+   * Execute with optional timeout
+   */
+  private async executeWithTimeout(
+    skill: Skill,
+    params: unknown,
+    context: SkillContext,
+    timeout?: number
+  ): Promise<SkillResult> {
+    if (!timeout) {
+      return skill.execute(params, context);
+    }
+
+    return new Promise((resolve) => {
+      const timer = setTimeout(() => {
+        resolve({
+          success: false,
+          error: `Skill ${skill.id} timed out after ${timeout}ms`,
+        });
+      }, timeout);
+
+      skill
+        .execute(params, context)
+        .then((result) => {
+          clearTimeout(timer);
+          resolve(result);
+        })
+        .catch((error) => {
+          clearTimeout(timer);
+          resolve({
+            success: false,
+            error: error instanceof Error ? error.message : String(error),
+          });
+        });
+    });
+  }
+
+  /**
+   * Record execution in history
+   */
+  private recordExecution(meta: SkillExecutionMeta): void {
+    this.executionHistory.push(meta);
+
+    // Trim old entries
+    if (this.executionHistory.length > this.maxHistorySize) {
+      this.executionHistory = this.executionHistory.slice(-this.maxHistorySize);
+    }
+  }
+
+  /**
+   * Get execution history
+   */
+  getHistory(limit = 100): SkillExecutionMeta[] {
+    return this.executionHistory.slice(-limit);
+  }
+
+  /**
+   * Get execution stats for a skill
+   */
+  getStats(skillId: string): {
+    total: number;
+    success: number;
+    failed: number;
+    avgDuration: number;
+  } {
+    const executions = this.executionHistory.filter((m) => m.skillId === skillId);
+    const total = executions.length;
+    const success = executions.filter((m) => m.success).length;
+    const durations = executions
+      .filter((m) => m.duration !== undefined)
+      .map((m) => m.duration!);
+
+    return {
+      total,
+      success,
+      failed: total - success,
+      avgDuration:
+        durations.length > 0
+          ? durations.reduce((a, b) => a + b, 0) / durations.length
+          : 0,
+    };
+  }
+
+  /**
+   * Clear registry (useful for testing)
+   */
+  clear(): void {
+    this.skills.clear();
+    this.executionHistory = [];
+  }
+}
+
+/**
+ * Global skill registry instance
+ */
+export const skillRegistry = new SkillRegistry();
+
+/**
+ * Helper to create and register a skill
+ */
+export function defineSkill<P = unknown, D extends Record<string, unknown> = Record<string, unknown>>(
+  config: SkillConfig<P>,
+  execute: (params: P | undefined, context: SkillContext) => Promise<SkillResult<D>>
+): Skill<P, D> {
+  const skill: Skill<P, D> = {
+    ...config,
+    execute,
+  };
+
+  skillRegistry.register(skill);
+  return skill;
+}

package/src/skills/shared/index.ts

@@ -0,0 +1,21 @@
+/**
+ * GLM Daemon - Shared Skills
+ *
+ * Skills shared across all workflows.
+ */
+
+// Import to auto-register
+import "./reflect.js";
+import "./review.js";
+import "./trajectory.js";
+
+// Re-export for explicit imports
+export { reflectSkill } from "./reflect.js";
+export { reviewSkill } from "./review.js";
+export { trajectorySkill } from "./trajectory.js";
+
+// Re-export types
+export type { ReflectData } from "./reflect.js";
+export type { ReviewData } from "./review.js";
+export type { TrajectoryData, LearnedPattern } from "./trajectory.js";
+export { TrajectoryParams } from "./trajectory.js";

package/src/skills/shared/reflect.ts

@@ -0,0 +1,156 @@
+/**
+ * GLM Daemon - Reflect Skill
+ *
+ * TL;DR checkpoint for summarizing progress after N tool calls.
+ * Used by all workflows for periodic reflection.
+ */
+
+import { z } from "zod";
+import type { Skill, SkillContext, SkillResult } from "../types.js";
+import { skillRegistry } from "../registry.js";
+
+/**
+ * Reflect skill parameters
+ */
+const ReflectParams = z.object({
+  /** Force reflection even if not at checkpoint */
+  force: z.boolean().optional(),
+});
+
+/**
+ * Reflection result data (matches GLMReflectionSummary)
+ */
+interface ReflectData {
+  /** Checkpoint number */
+  checkpoint: number;
+  /** Summary text */
+  summary: string;
+  /** What was accomplished */
+  accomplishments: string[];
+  /** What to do next */
+  nextSteps: string[];
+  /** Any issues/blockers */
+  issues: string[];
+  /** Timestamp */
+  timestamp: string;
+  /** Tools used in this chunk */
+  toolsUsed: number;
+  /** Phase when reflection occurred */
+  phase: string;
+}
+
+/**
+ * Reflect skill definition
+ */
+export const reflectSkill: Skill<void, ReflectData> = {
+  id: "/reflect",
+  name: "Reflect",
+  description:
+    "TL;DR checkpoint for summarizing progress. Generates a brief summary of what was done and what's next.",
+  tags: ["shared", "checkpoint", "meta"],
+  parallelizable: false,
+  maxRetries: 1,
+
+  async execute(_params, context): Promise<SkillResult<ReflectData>> {
+    const checkpoint = context.state.reflection.checkpointCount + 1;
+    const previousPhase = context.state.slam.previousPhase || "unknown";
+
+    console.log(`[/reflect] Checkpoint #${checkpoint}`);
+    console.log(`[/reflect] Tools used this chunk: ${context.state.reflection.toolCount}`);
+
+    const prompt = `REFLECTION CHECKPOINT #${checkpoint}
+
+You have used ${context.state.reflection.toolCount} tools. Pause and reflect.
+
+Task: ${context.state.prompt}
+Current Phase: ${previousPhase}
+Iteration: ${context.state.iteration}
+
+Progress so far:
+- Subtasks completed: ${context.state.slam.completedSubtasks.length}/${context.state.slam.subtasks.length}
+- 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.`;
+
+    try {
+      const response = await context.agent.execute(prompt);
+
+      // Parse JSON from response
+      const jsonMatch = response.match(/\{[\s\S]*\}/);
+      let data: ReflectData;
+
+      if (jsonMatch) {
+        const parsed = JSON.parse(jsonMatch[0]);
+        data = {
+          checkpoint,
+          summary: parsed.summary || "Progress made",
+          accomplishments: parsed.accomplishments || [],
+          nextSteps: parsed.nextSteps || [],
+          issues: parsed.issues || [],
+          timestamp: new Date().toISOString(),
+          toolsUsed: context.state.reflection.toolCount,
+          phase: previousPhase,
+        };
+      } else {
+        // Fallback if no JSON found
+        data = {
+          checkpoint,
+          summary: response.substring(0, 200),
+          accomplishments: [],
+          nextSteps: [],
+          issues: [],
+          timestamp: new Date().toISOString(),
+          toolsUsed: context.state.reflection.toolCount,
+          phase: previousPhase,
+        };
+      }
+
+      console.log(`[/reflect] Summary: ${data.summary}`);
+      if (data.accomplishments.length > 0) {
+        console.log(`[/reflect] Accomplishments: ${data.accomplishments.join(", ")}`);
+      }
+      if (data.nextSteps.length > 0) {
+        console.log(`[/reflect] Next: ${data.nextSteps.join(", ")}`);
+      }
+      if (data.issues.length > 0) {
+        console.log(`[/reflect] Issues: ${data.issues.join(", ")}`);
+      }
+
+      // Execute reflection hook
+      await context.executeHook("onReflection", context.state, data);
+
+      return {
+        success: true,
+        data,
+        stateUpdates: {
+          reflection: {
+            ...context.state.reflection,
+            toolCount: 0, // Reset counter
+            checkpointCount: checkpoint,
+            lastReflection: data.timestamp,
+            summaries: [...context.state.reflection.summaries, data],
+          },
+        },
+      };
+    } catch (error) {
+      return {
+        success: false,
+        error: error instanceof Error ? error.message : String(error),
+      };
+    }
+  },
+};
+
+// Auto-register
+skillRegistry.register(reflectSkill);
+
+export { ReflectParams };
+export type { ReflectData };