@ebowwa/daemons 0.5.0

package/src/skills/shared/review.ts

@@ -0,0 +1,201 @@
+/**
+ * GLM Daemon - Review Skill
+ *
+ * Quality review for code changes or trading performance.
+ * Used by coding and trading workflows.
+ */
+
+import { z } from "zod";
+import type { Skill, SkillContext, SkillResult } from "../types.js";
+import { skillRegistry } from "../registry.js";
+
+/**
+ * Review skill parameters
+ */
+const ReviewParams = z.object({
+  /** Type of review: "code" | "trading" | "general" */
+  type: z.enum(["code", "trading", "general"]).optional(),
+  /** Specific criteria to review against */
+  criteria: z.array(z.string()).optional(),
+  /** Whether to approve on success */
+  approveOnPass: z.boolean().optional(),
+});
+
+/**
+ * Review result data
+ */
+interface ReviewData {
+  /** Whether the review passed */
+  approved: boolean;
+  /** Issues found during review */
+  issues: string[];
+  /** Suggestions for improvement */
+  suggestions: string[];
+  /** Overall assessment */
+  assessment: string;
+  /** Score (0-100) if applicable */
+  score?: number;
+}
+
+/**
+ * Default review criteria by type
+ */
+const DEFAULT_CRITERIA: Record<string, string[]> = {
+  code: [
+    "Correctness: Does it work as intended?",
+    "Edge cases: Are error cases handled?",
+    "Security: Any vulnerabilities?",
+    "Performance: Any bottlenecks?",
+    "Maintainability: Is it readable?",
+  ],
+  trading: [
+    "Risk management: Position size within limits?",
+    "Stop loss: Properly placed?",
+    "Entry/Exit: Logical levels?",
+    "Market conditions: Suitable for current state?",
+    "P&L projection: Realistic expectations?",
+  ],
+  general: [
+    "Completeness: Task fully addressed?",
+    "Quality: Meets standards?",
+    "Consistency: Follows patterns?",
+  ],
+};
+
+/**
+ * Review skill definition
+ */
+export const reviewSkill: Skill<z.infer<typeof ReviewParams>, ReviewData> = {
+  id: "/review",
+  name: "Review",
+  description:
+    "Quality review for changes or decisions. Can review code, trades, or general work.",
+  paramsSchema: ReviewParams,
+  tags: ["shared", "quality", "validation"],
+  parallelizable: false,
+  produces: ["approved", "issues", "assessment"],
+
+  async execute(params, context): Promise<SkillResult<ReviewData>> {
+    const reviewType = params?.type || "general";
+    const criteria = params?.criteria || DEFAULT_CRITERIA[reviewType] || DEFAULT_CRITERIA.general;
+    const approveOnPass = params?.approveOnPass ?? true;
+
+    console.log(`[/review] Type: ${reviewType}`);
+    console.log(`[/review] Criteria: ${criteria.length} items`);
+
+    // Build review prompt based on type
+    let reviewContext = "";
+    switch (reviewType) {
+      case "code":
+        reviewContext = `
+Files changed: ${context.state.filesChanged.join(", ") || "none"}
+Subtasks completed: ${context.state.slam.completedSubtasks.length}/${context.state.slam.subtasks.length}
+Task: ${context.state.prompt}
+Completion promise: ${context.state.promise}
+`;
+        break;
+      case "trading":
+        reviewContext = `
+Current position: ${JSON.stringify(context.custom.position || "none")}
+P&L: ${context.custom.currentPnL || "N/A"}
+Risk level: ${context.custom.riskLevel || "unknown"}
+Iteration: ${context.state.iteration}
+`;
+        break;
+      default:
+        reviewContext = `
+Task: ${context.state.prompt}
+Files changed: ${context.state.filesChanged.join(", ") || "none"}
+Iterations: ${context.state.iteration}
+`;
+    }
+
+    const prompt = `Perform a thorough review.
+
+Type: ${reviewType}
+
+Context:
+${reviewContext}
+
+Review Criteria:
+${criteria.map((c, i) => `${i + 1}. ${c}`).join("\n")}
+
+For each criterion:
+1. Assess whether it's met
+2. Note any issues or concerns
+3. Provide suggestions if applicable
+
+Respond in JSON format:
+{
+  "approved": true|false,
+  "issues": ["list of issues found"],
+  "suggestions": ["list of improvement suggestions"],
+  "assessment": "overall assessment text",
+  "score": 0-100
+}
+
+If all criteria are met and there are no critical issues, set approved to true.
+If there are critical issues that must be fixed, set approved to false.`;
+
+    try {
+      const response = await context.agent.execute(prompt);
+
+      // Parse JSON from response
+      const jsonMatch = response.match(/\{[\s\S]*\}/);
+      let data: ReviewData;
+
+      if (jsonMatch) {
+        const parsed = JSON.parse(jsonMatch[0]);
+        data = {
+          approved: parsed.approved ?? false,
+          issues: parsed.issues || [],
+          suggestions: parsed.suggestions || [],
+          assessment: parsed.assessment || "",
+          score: parsed.score,
+        };
+      } else {
+        // Fallback: detect approval from response
+        const lowerResponse = response.toLowerCase();
+        const hasApproved = lowerResponse.includes("approved") && !lowerResponse.includes("not approved");
+        data = {
+          approved: approveOnPass && hasApproved,
+          issues: [],
+          suggestions: [],
+          assessment: response.substring(0, 500),
+        };
+      }
+
+      console.log(`[/review] Result: ${data.approved ? "APPROVED" : "NEEDS WORK"}`);
+      if (data.issues.length > 0) {
+        console.log(`[/review] Issues: ${data.issues.length}`);
+      }
+      if (data.score !== undefined) {
+        console.log(`[/review] Score: ${data.score}/100`);
+      }
+
+      return {
+        success: true,
+        data,
+        contextUpdates: {
+          approved: data.approved,
+          reviewIssues: data.issues,
+          reviewScore: data.score,
+        },
+      };
+    } catch (error) {
+      return {
+        success: false,
+        error: error instanceof Error ? error.message : String(error),
+        contextUpdates: {
+          approved: false,
+        },
+      };
+    }
+  },
+};
+
+// Auto-register
+skillRegistry.register(reviewSkill);
+
+export { ReviewParams };
+export type { ReviewData };

package/src/skills/shared/trajectory.ts

@@ -0,0 +1,319 @@
+/**
+ * GLM Daemon - Trajectory Skill
+ *
+ * Integration with @ebowwa/trajectory for learning from execution patterns.
+ * Provides:
+ * - Query learned patterns by domain
+ * - Record execution results for learning
+ * - Provide context about past successful patterns
+ */
+
+import { z } from "zod";
+import type { Skill, SkillContext, SkillResult } from "../types.js";
+import { skillRegistry } from "../registry.js";
+
+/**
+ * Trajectory skill parameters
+ */
+const TrajectoryParams = z.discriminatedUnion("action", [
+  z.object({
+    /** Query patterns by domain */
+    action: z.literal("query"),
+    /** Domain to query (e.g., "math", "trading", "coding") */
+    domain: z.string(),
+    /** Minimum success rate filter (0-1) */
+    minSuccessRate: z.number().min(0).max(1).optional(),
+    /** Maximum patterns to return */
+    limit: z.number().min(1).max(50).optional(),
+  }),
+  z.object({
+    /** Record execution result */
+    action: z.literal("record"),
+    /** Execution data to record */
+    execution: z.object({
+      primitiveId: z.string(),
+      package: z.string(),
+      version: z.string(),
+      inputs: z.record(z.unknown()),
+      output: z.unknown(),
+      durationNs: z.number(),
+      verified: z.boolean(),
+      invariantsChecked: z.array(z.string()).optional(),
+      verificationErrors: z.array(z.string()).optional(),
+      specId: z.string().optional(),
+      sessionId: z.string().optional(),
+    }),
+  }),
+  z.object({
+    /** Get context about past patterns for a given task */
+    action: z.literal("context"),
+    /** Task description to find relevant patterns */
+    task: z.string(),
+    /** Domain hint */
+    domain: z.string().optional(),
+  }),
+  z.object({
+    /** Get memory statistics */
+    action: z.literal("stats"),
+  }),
+]);
+
+/**
+ * Pattern info from trajectory memory
+ */
+interface LearnedPattern {
+  primitiveSequence: string[];
+  avgDurationMs: number;
+  successRate: number;
+}
+
+/**
+ * Trajectory skill result data
+ */
+interface TrajectoryData {
+  action: "query" | "record" | "context" | "stats";
+  patterns?: LearnedPattern[];
+  recorded?: {
+    executionId: string;
+    timestamp: number;
+  };
+  context?: {
+    relevantPatterns: LearnedPattern[];
+    suggestions: string[];
+    historicalSuccess: number;
+  };
+  stats?: {
+    totalExecutions: number;
+    totalCompositions: number;
+    totalTrajectories: number;
+    successfulTrajectories: number;
+    avgExecutionsPerComposition: number;
+    avgAttemptsPerTrajectory: number;
+  };
+}
+
+/**
+ * Lazy-loaded trajectory memory reference
+ * We import dynamically to avoid bundling issues if trajectory is not installed
+ */
+let _trajectoryMemory: InstanceType<
+  typeof import("@ebowwa/trajectory").TrajectoryMemory
+> | null = null;
+let _trajectoryAvailable: boolean | null = null;
+
+/**
+ * Get or initialize trajectory memory
+ */
+async function getTrajectoryMemory(): Promise<
+  InstanceType<typeof import("@ebowwa/trajectory").TrajectoryMemory> | null
+> {
+  if (_trajectoryAvailable === false) {
+    return null;
+  }
+
+  if (_trajectoryMemory) {
+    return _trajectoryMemory;
+  }
+
+  try {
+    const { TrajectoryMemory } = await import("@ebowwa/trajectory");
+
+    // Use default path or custom path from env
+    const dbPath = process.env.TRAJECTORY_DB_PATH || ".trajectory/memory.lmdb";
+    _trajectoryMemory = new TrajectoryMemory({ path: dbPath });
+    _trajectoryAvailable = true;
+    return _trajectoryMemory;
+  } catch (error) {
+    console.warn(
+      "[/trajectory] @ebowwa/trajectory not available or initialization failed:",
+      error instanceof Error ? error.message : String(error)
+    );
+    _trajectoryAvailable = false;
+    return null;
+  }
+}
+
+/**
+ * Trajectory skill definition
+ */
+export const trajectorySkill: Skill<
+  z.infer<typeof TrajectoryParams>,
+  TrajectoryData
+> = {
+  id: "/trajectory",
+  name: "Trajectory",
+  description:
+    "Query and record execution patterns for learning. Integrates with @ebowwa/trajectory memory system.",
+  paramsSchema: TrajectoryParams,
+  tags: ["shared", "learning", "memory", "meta"],
+  parallelizable: true,
+  maxRetries: 1,
+
+  async execute(params, context): Promise<SkillResult<TrajectoryData>> {
+    const memory = await getTrajectoryMemory();
+
+    if (!memory) {
+      return {
+        success: false,
+        error:
+          "Trajectory memory not available. Ensure @ebowwa/trajectory is installed.",
+        data: { action: params.action },
+      };
+    }
+
+    try {
+      switch (params.action) {
+        case "query": {
+          const { domain, minSuccessRate = 0.5, limit = 10 } = params;
+
+          console.log("[/trajectory] Querying patterns for domain:", domain);
+
+          let patterns = memory.findSuccessfulPatterns(domain);
+
+          // Filter by success rate
+          patterns = patterns.filter((p) => p.successRate >= minSuccessRate);
+
+          // Sort by success rate and limit
+          patterns = patterns
+            .sort((a, b) => b.successRate - a.successRate)
+            .slice(0, limit);
+
+          console.log("[/trajectory] Found", patterns.length, "patterns for", domain);
+
+          return {
+            success: true,
+            data: {
+              action: "query",
+              patterns,
+            },
+          };
+        }
+
+        case "record": {
+          const { execution } = params;
+
+          console.log("[/trajectory] Recording execution:", execution.primitiveId);
+
+          const record = memory.recordExecution({
+            primitive: {
+              id: execution.primitiveId,
+              package: execution.package,
+              version: execution.version,
+            },
+            inputs: execution.inputs,
+            output: execution.output,
+            durationNs: execution.durationNs,
+            verified: execution.verified,
+            invariantsChecked: execution.invariantsChecked || [],
+            verificationErrors: execution.verificationErrors || [],
+            specId: execution.specId,
+            sessionId: execution.sessionId,
+          });
+
+          console.log("[/trajectory] Recorded execution", record.id);
+
+          return {
+            success: true,
+            data: {
+              action: "record",
+              recorded: {
+                executionId: record.id,
+                timestamp: record.timestamp,
+              },
+            },
+          };
+        }
+
+        case "context": {
+          const { task, domain } = params;
+
+          console.log("[/trajectory] Getting context for task:", task.substring(0, 50));
+
+          // Query patterns from relevant domains
+          const domains = domain
+            ? [domain]
+            : ["coding", "trading", "math", "general"];
+
+          let allPatterns: LearnedPattern[] = [];
+          for (const d of domains) {
+            const patterns = memory.findSuccessfulPatterns(d);
+            allPatterns.push(...patterns);
+          }
+
+          // Sort by success rate and get top patterns
+          const relevantPatterns = allPatterns
+            .sort((a, b) => b.successRate - a.successRate)
+            .slice(0, 5);
+
+          // Generate suggestions based on patterns
+          const suggestions: string[] = [];
+          if (relevantPatterns.length > 0) {
+            suggestions.push(
+              "Past successful patterns: " + relevantPatterns[0].primitiveSequence.join(" -> ")
+            );
+            if (relevantPatterns[0].successRate > 0.8) {
+              suggestions.push(
+                "This pattern has high success rate - consider following similar approach"
+              );
+            }
+          }
+
+          const stats = memory.getStats();
+          const historicalSuccess =
+            stats.totalTrajectories > 0
+              ? stats.successfulTrajectories / stats.totalTrajectories
+              : 0;
+
+          console.log("[/trajectory] Found", relevantPatterns.length, "relevant patterns");
+
+          return {
+            success: true,
+            data: {
+              action: "context",
+              context: {
+                relevantPatterns,
+                suggestions,
+                historicalSuccess,
+              },
+            },
+          };
+        }
+
+        case "stats": {
+          console.log("[/trajectory] Getting memory statistics");
+
+          const stats = memory.getStats();
+
+          console.log("[/trajectory] Stats:", stats.totalExecutions, "executions,", stats.successfulTrajectories + "/" + stats.totalTrajectories, "successful trajectories");
+
+          return {
+            success: true,
+            data: {
+              action: "stats",
+              stats,
+            },
+          };
+        }
+
+        default:
+          return {
+            success: false,
+            error: "Unknown action: " + (params as { action: string }).action,
+            data: { action: (params as { action: string }).action as TrajectoryData["action"] },
+          };
+      }
+    } catch (error) {
+      return {
+        success: false,
+        error: error instanceof Error ? error.message : String(error),
+        data: { action: params.action },
+      };
+    }
+  },
+};
+
+// Auto-register
+skillRegistry.register(trajectorySkill);
+
+export { TrajectoryParams };
+export type { TrajectoryData, LearnedPattern };

package/src/skills/trading/analyze-market.ts

@@ -0,0 +1,144 @@
+/**
+ * GLM Daemon - Analyze Market Skill
+ *
+ * Analyze market conditions and identify trading opportunities.
+ */
+
+import { z } from "zod";
+import type { Skill, SkillContext, SkillResult } from "../types.js";
+import { skillRegistry } from "../registry.js";
+
+/**
+ * Analyze market parameters
+ */
+const AnalyzeMarketParams = z.object({
+  /** Market symbol or ID */
+  symbol: z.string().optional(),
+  /** Analysis timeframe */
+  timeframe: z.enum(["short", "medium", "long"]).optional(),
+  /** Include sentiment analysis */
+  includeSentiment: z.boolean().optional(),
+});
+
+/**
+ * Market analysis result data
+ */
+interface AnalyzeMarketData {
+  trend: "bullish" | "bearish" | "sideways";
+  confidence: number;
+  supportLevels: number[];
+  resistanceLevels: number[];
+  indicators: {
+    rsi?: number;
+    macd?: string;
+    volume?: string;
+  };
+  signals: string[];
+  riskLevel: "low" | "medium" | "high";
+  marketCondition: "volatile" | "ranging" | "trending";
+}
+
+/**
+ * Analyze market skill
+ */
+export const analyzeMarketSkill: Skill<z.infer<typeof AnalyzeMarketParams>, AnalyzeMarketData> = {
+  id: "/analyze-market",
+  name: "Analyze Market",
+  description: "Analyze market conditions using technical indicators and sentiment.",
+  paramsSchema: AnalyzeMarketParams,
+  tags: ["trading", "analysis"],
+  parallelizable: true,
+  produces: ["analysis", "riskLevel", "marketCondition"],
+
+  async execute(params, context): Promise<SkillResult<AnalyzeMarketData>> {
+    const symbol = params?.symbol || context.custom.symbol || "current market";
+    const timeframe = params?.timeframe || "medium";
+
+    console.log(`[/analyze-market] Analyzing ${symbol} (${timeframe} term)`);
+
+    const prompt = `Analyze current market conditions for ${symbol}.
+
+Consider:
+- Price action and trends
+- Volume analysis
+- Technical indicators (RSI, MACD, Moving Averages)
+- Market sentiment
+- News and events (if known)
+- Support and resistance levels
+- Timeframe: ${timeframe}
+
+Provide analysis in JSON format:
+{
+  "trend": "bullish|bearish|sideways",
+  "confidence": 0-100,
+  "supportLevels": [price levels],
+  "resistanceLevels": [price levels],
+  "indicators": {
+    "rsi": number,
+    "macd": "bullish|bearish|neutral",
+    "volume": "high|medium|low"
+  },
+  "signals": ["list of trading signals"],
+  "riskLevel": "low|medium|high",
+  "marketCondition": "volatile|ranging|trending"
+}`;
+
+    try {
+      const response = await context.agent.execute(prompt);
+
+      // Parse JSON from response
+      const jsonMatch = response.match(/\{[\s\S]*\}/);
+      let data: AnalyzeMarketData;
+
+      if (jsonMatch) {
+        const parsed = JSON.parse(jsonMatch[0]);
+        data = {
+          trend: parsed.trend || "sideways",
+          confidence: parsed.confidence || 50,
+          supportLevels: parsed.supportLevels || [],
+          resistanceLevels: parsed.resistanceLevels || [],
+          indicators: parsed.indicators || {},
+          signals: parsed.signals || [],
+          riskLevel: parsed.riskLevel || "medium",
+          marketCondition: parsed.marketCondition || "ranging",
+        };
+      } else {
+        // Fallback
+        data = {
+          trend: "sideways",
+          confidence: 50,
+          supportLevels: [],
+          resistanceLevels: [],
+          indicators: {},
+          signals: ["Unable to parse analysis"],
+          riskLevel: "medium",
+          marketCondition: "ranging",
+        };
+      }
+
+      console.log(`[/analyze-market] Trend: ${data.trend} (${data.confidence}% confidence)`);
+      console.log(`[/analyze-market] Risk: ${data.riskLevel}, Condition: ${data.marketCondition}`);
+      console.log(`[/analyze-market] Signals: ${data.signals.length}`);
+
+      return {
+        success: true,
+        data,
+        contextUpdates: {
+          analysis: data,
+          riskLevel: data.riskLevel,
+          marketCondition: data.marketCondition,
+        },
+      };
+    } catch (error) {
+      return {
+        success: false,
+        error: error instanceof Error ? error.message : String(error),
+      };
+    }
+  },
+};
+
+skillRegistry.register(analyzeMarketSkill);
+
+export { AnalyzeMarketParams };
+export type { AnalyzeMarketData };