@ebowwa/daemons 0.5.0

package/src/skills/trading/check-risk.ts

@@ -0,0 +1,176 @@
+/**
+ * GLM Daemon - Check Risk Skill
+ *
+ * Evaluate risk and validate signal before execution.
+ */
+
+import { z } from "zod";
+import type { Skill, SkillContext, SkillResult } from "../types.js";
+import { skillRegistry } from "../registry.js";
+
+/**
+ * Trade signal from generate-signal skill
+ */
+interface TradeSignal {
+  direction: "long" | "short" | "none";
+  entryZone?: { min: number; max: number };
+  stopLoss?: number;
+  takeProfits?: {
+    tp1?: { price: number; size: string };
+    tp2?: { price: number; size: string };
+    tp3?: { price: number; size: string };
+  };
+  confidence?: number;
+  rationale?: string;
+  positionSize?: {
+    percentage: number;
+    absolute?: number;
+  };
+}
+
+/**
+ * Market analysis from analyze-market skill
+ */
+interface MarketAnalysis {
+  marketId: string;
+  trend?: string;
+  volatility?: string;
+  sentiment?: string;
+  keyLevels?: number[];
+}
+
+/**
+ * Check risk parameters
+ */
+const CheckRiskParams = z.object({
+  /** Maximum risk per trade (percentage) */
+  maxRiskPerTrade: z.number().optional(),
+  /** Minimum risk/reward ratio */
+  minRiskReward: z.number().optional(),
+  /** Maximum portfolio exposure */
+  maxExposure: z.number().optional(),
+});
+
+/**
+ * Risk check result data
+ */
+interface CheckRiskData {
+  approved: boolean;
+  riskScore: number;
+  concerns: string[];
+  adjustments: string[];
+  maxPositionSize: number;
+  reasoning: string;
+}
+
+/**
+ * Check risk skill
+ */
+export const checkRiskSkill: Skill<z.infer<typeof CheckRiskParams>, CheckRiskData> = {
+  id: "/check-risk",
+  name: "Check Risk",
+  description: "Evaluate risk and validate trading signal before execution.",
+  paramsSchema: CheckRiskParams,
+  tags: ["trading", "risk", "validation"],
+  parallelizable: false,
+  requires: ["analysis", "signal"],
+
+  async execute(params, context): Promise<SkillResult<CheckRiskData>> {
+    const analysis = (context.custom.analysis || {}) as MarketAnalysis;
+    const signal = (context.custom.signal || {}) as TradeSignal;
+    const maxRiskPerTrade = params?.maxRiskPerTrade || 2;
+    const minRiskReward = params?.minRiskReward || 1.5;
+    const maxExposure = params?.maxExposure || 10;
+
+    console.log("[/check-risk] Evaluating signal risk");
+
+    const prompt = `Perform risk assessment for the proposed trade.
+
+Analysis: ${JSON.stringify(analysis, null, 2)}
+Signal: ${JSON.stringify(signal, null, 2)}
+
+Risk Parameters:
+- Max risk per trade: ${maxRiskPerTrade}%
+- Min risk/reward: ${minRiskReward}
+- Max portfolio exposure: ${maxExposure}%
+
+Evaluate:
+1. Risk/reward ratio (minimum ${minRiskReward}:1)
+2. Position size vs account risk (max ${maxRiskPerTrade}% per trade)
+3. Market conditions (avoid high volatility if conservative)
+4. Correlation with existing positions
+5. Stop loss placement validity
+
+Respond in JSON format:
+{
+  "approved": true|false,
+  "riskScore": 0-100,
+  "concerns": ["list of concerns"],
+  "adjustments": ["suggested adjustments"],
+  "maxPositionSize": number,
+  "reasoning": "detailed explanation"
+}
+
+If approved is false, explain why and what conditions would make it acceptable.`;
+
+    try {
+      const response = await context.agent.execute(prompt);
+
+      // Parse JSON from response
+      const jsonMatch = response.match(/\{[\s\S]*\}/);
+      let data: CheckRiskData;
+
+      if (jsonMatch) {
+        const parsed = JSON.parse(jsonMatch[0]);
+        data = {
+          approved: parsed.approved === true,
+          riskScore: parsed.riskScore || 50,
+          concerns: parsed.concerns || [],
+          adjustments: parsed.adjustments || [],
+          maxPositionSize: parsed.maxPositionSize || signal.positionSize?.percentage || 1,
+          reasoning: parsed.reasoning || "",
+        };
+      } else {
+        // Fallback: default to not approved
+        const hasConcerns = response.toLowerCase().includes("concern") || response.toLowerCase().includes("risk");
+        data = {
+          approved: !hasConcerns,
+          riskScore: hasConcerns ? 70 : 30,
+          concerns: hasConcerns ? ["Unable to parse risk assessment"] : [],
+          adjustments: [],
+          maxPositionSize: 1,
+          reasoning: response.substring(0, 300),
+        };
+      }
+
+      console.log(`[/check-risk] Result: ${data.approved ? "APPROVED" : "REJECTED"}`);
+      console.log(`[/check-risk] Risk score: ${data.riskScore}/100`);
+      if (data.concerns.length > 0) {
+        console.log(`[/check-risk] Concerns: ${data.concerns.length}`);
+      }
+
+      return {
+        success: true,
+        data,
+        contextUpdates: {
+          riskApproved: data.approved,
+          riskAssessment: data,
+        },
+        nextSkill: data.approved ? "/execute-trade" : "/analyze-market",
+      };
+    } catch (error) {
+      return {
+        success: false,
+        error: error instanceof Error ? error.message : String(error),
+        contextUpdates: {
+          riskApproved: false,
+        },
+      };
+    }
+  },
+};
+
+skillRegistry.register(checkRiskSkill);
+
+export { CheckRiskParams };
+export type { CheckRiskData };

package/src/skills/trading/execute-trade.ts

@@ -0,0 +1,185 @@
+/**
+ * GLM Daemon - Execute Trade Skill
+ *
+ * Execute trades according to validated signals.
+ */
+
+import { z } from "zod";
+import type { Skill, SkillContext, SkillResult } from "../types.js";
+import { skillRegistry } from "../registry.js";
+
+/**
+ * Trade signal from generate-signal skill
+ */
+interface TradeSignal {
+  direction: "long" | "short" | "none";
+  entryZone?: { min: number; max: number };
+  stopLoss?: number;
+  takeProfits?: {
+    tp1?: { price: number; size: string };
+    tp2?: { price: number; size: string };
+    tp3?: { price: number; size: string };
+  };
+  confidence?: number;
+  rationale?: string;
+  positionSize?: {
+    percentage: number;
+    absolute?: number;
+  };
+}
+
+/**
+ * Risk assessment from check-risk skill
+ */
+interface RiskAssessment {
+  approved: boolean;
+  positionSize?: number;
+  riskPercent?: number;
+  riskRewardRatio?: number;
+  maxLoss?: number;
+  reasons?: string[];
+}
+
+/**
+ * Execute trade parameters
+ */
+const ExecuteTradeParams = z.object({
+  /** Use paper trading (simulation) */
+  paper: z.boolean().optional(),
+  /** Custom order type */
+  orderType: z.enum(["market", "limit", "fok"]).optional(),
+});
+
+/**
+ * Execute trade result data
+ */
+interface ExecuteTradeData {
+  orderId: string;
+  direction: string;
+  entryPrice: number;
+  size: number;
+  stopLossOrderId: string;
+  takeProfitOrderIds: string[];
+  status: "placed" | "filled" | "partial" | "failed";
+  timestamp: string;
+}
+
+/**
+ * Execute trade skill
+ */
+export const executeTradeSkill: Skill<z.infer<typeof ExecuteTradeParams>, ExecuteTradeData> = {
+  id: "/execute-trade",
+  name: "Execute Trade",
+  description: "Execute trades using available trading tools.",
+  paramsSchema: ExecuteTradeParams,
+  tags: ["trading", "execution"],
+  parallelizable: false,
+  requires: ["signal", "riskApproved"],
+  maxRetries: 2,
+
+  async execute(params, context): Promise<SkillResult<ExecuteTradeData>> {
+    const signal = (context.custom.signal || {}) as TradeSignal;
+    const riskAssessment = (context.custom.riskAssessment || {}) as RiskAssessment;
+    const paper = params?.paper ?? true; // Default to paper trading
+
+    if (!context.custom.riskApproved) {
+      return {
+        success: false,
+        error: "Risk not approved - cannot execute trade",
+      };
+    }
+
+    console.log(`[/execute-trade] Executing ${signal.direction} trade (${paper ? "PAPER" : "LIVE"})`);
+
+    const prompt = `Execute the approved trade signal.
+
+Signal: ${JSON.stringify(signal, null, 2)}
+Risk Assessment: ${JSON.stringify(riskAssessment, null, 2)}
+Mode: ${paper ? "PAPER TRADING" : "LIVE TRADING"}
+
+Use the available trading tools to:
+1. Place the entry order (${params?.orderType || "limit"})
+2. Set stop loss order at ${signal.stopLoss}
+3. Set take profit orders:
+   - TP1 at ${signal.takeProfits?.tp1?.price} (${signal.takeProfits?.tp1?.size})
+   - TP2 at ${signal.takeProfits?.tp2?.price} (${signal.takeProfits?.tp2?.size})
+   - TP3 at ${signal.takeProfits?.tp3?.price} (${signal.takeProfits?.tp3?.size})
+4. Confirm all orders are placed correctly
+
+Report execution status with order IDs in JSON format:
+{
+  "orderId": "entry order id",
+  "direction": "long|short",
+  "entryPrice": number,
+  "size": number,
+  "stopLossOrderId": "stop loss order id",
+  "takeProfitOrderIds": ["tp1 id", "tp2 id", "tp3 id"],
+  "status": "placed|filled|partial|failed",
+  "timestamp": "ISO timestamp"
+}`;
+
+    try {
+      const response = await context.agent.execute(prompt);
+
+      // Parse JSON from response
+      const jsonMatch = response.match(/\{[\s\S]*\}/);
+      let data: ExecuteTradeData;
+
+      if (jsonMatch) {
+        const parsed = JSON.parse(jsonMatch[0]);
+        data = {
+          orderId: parsed.orderId || `paper-${Date.now()}`,
+          direction: parsed.direction || signal.direction,
+          entryPrice: parsed.entryPrice || signal.entryZone?.min || 0,
+          size: parsed.size || signal.positionSize?.percentage || 0,
+          stopLossOrderId: parsed.stopLossOrderId || `sl-${Date.now()}`,
+          takeProfitOrderIds: parsed.takeProfitOrderIds || [`tp1-${Date.now()}`, `tp2-${Date.now()}`, `tp3-${Date.now()}`],
+          status: parsed.status || "placed",
+          timestamp: parsed.timestamp || new Date().toISOString(),
+        };
+      } else {
+        // Fallback for paper trading
+        data = {
+          orderId: `paper-${Date.now()}`,
+          direction: signal.direction || "long",
+          entryPrice: signal.entryZone?.min || 0,
+          size: signal.positionSize?.percentage || 1,
+          stopLossOrderId: `sl-${Date.now()}`,
+          takeProfitOrderIds: [`tp1-${Date.now()}`, `tp2-${Date.now()}`, `tp3-${Date.now()}`],
+          status: "placed",
+          timestamp: new Date().toISOString(),
+        };
+      }
+
+      console.log(`[/execute-trade] Order ID: ${data.orderId}`);
+      console.log(`[/execute-trade] Status: ${data.status}`);
+      console.log(`[/execute-trade] Entry: ${data.entryPrice}, Size: ${data.size}%`);
+
+      return {
+        success: data.status !== "failed",
+        data,
+        contextUpdates: {
+          executionResult: data,
+          tradeStartTime: data.timestamp,
+          position: {
+            orderId: data.orderId,
+            direction: data.direction,
+            entryPrice: data.entryPrice,
+            size: data.size,
+          },
+        },
+        error: data.status === "failed" ? "Order execution failed" : undefined,
+      };
+    } catch (error) {
+      return {
+        success: false,
+        error: error instanceof Error ? error.message : String(error),
+      };
+    }
+  },
+};
+
+skillRegistry.register(executeTradeSkill);
+
+export { ExecuteTradeParams };
+export type { ExecuteTradeData };

package/src/skills/trading/generate-signal.ts

@@ -0,0 +1,160 @@
+/**
+ * GLM Daemon - Generate Signal Skill
+ *
+ * Generate trading signals based on market analysis.
+ */
+
+import { z } from "zod";
+import type { Skill, SkillContext, SkillResult } from "../types.js";
+import { skillRegistry } from "../registry.js";
+
+/**
+ * Generate signal parameters
+ */
+const GenerateSignalParams = z.object({
+  /** Risk tolerance */
+  riskTolerance: z.enum(["conservative", "moderate", "aggressive"]).optional(),
+  /** Position size limit (percentage) */
+  maxPositionSize: z.number().optional(),
+});
+
+/**
+ * Trading signal result data
+ */
+interface GenerateSignalData {
+  direction: "long" | "short" | "none";
+  entryZone: { min: number; max: number };
+  stopLoss: number;
+  takeProfits: {
+    tp1: { price: number; size: string };
+    tp2: { price: number; size: string };
+    tp3: { price: number; size: string };
+  };
+  positionSize: { percentage: number; reason: string };
+  riskReward: number;
+  confidence: number;
+  rationale: string;
+}
+
+/**
+ * Generate signal skill
+ */
+export const generateSignalSkill: Skill<z.infer<typeof GenerateSignalParams>, GenerateSignalData> = {
+  id: "/generate-signal",
+  name: "Generate Signal",
+  description: "Generate trading signals based on market analysis.",
+  paramsSchema: GenerateSignalParams,
+  tags: ["trading", "signal"],
+  parallelizable: false,
+  requires: ["analysis"],
+
+  async execute(params, context): Promise<SkillResult<GenerateSignalData>> {
+    const analysis = context.custom.analysis || {};
+    const riskTolerance = params?.riskTolerance || "moderate";
+    const maxPositionSize = params?.maxPositionSize || 5;
+
+    console.log("[/generate-signal] Generating trading signal");
+
+    const prompt = `Generate a trading signal based on this analysis.
+
+Analysis: ${JSON.stringify(analysis, null, 2)}
+Risk Tolerance: ${riskTolerance}
+Max Position Size: ${maxPositionSize}%
+
+Generate a trading signal with:
+- Direction (long/short/none)
+- Entry price zone
+- Stop loss level
+- Take profit targets (3 levels)
+- Position size recommendation
+- Risk/reward ratio
+- Confidence level
+- Rationale
+
+Provide the signal in JSON format:
+{
+  "direction": "long|short|none",
+  "entryZone": { "min": number, "max": number },
+  "stopLoss": number,
+  "takeProfits": {
+    "tp1": { "price": number, "size": "percentage" },
+    "tp2": { "price": number, "size": "percentage" },
+    "tp3": { "price": number, "size": "percentage" }
+  },
+  "positionSize": { "percentage": number, "reason": "string" },
+  "riskReward": number,
+  "confidence": 0-100,
+  "rationale": "explanation"
+}
+
+If no clear signal exists, set direction to "none" and explain why.`;
+
+    try {
+      const response = await context.agent.execute(prompt);
+
+      // Parse JSON from response
+      const jsonMatch = response.match(/\{[\s\S]*\}/);
+      let data: GenerateSignalData;
+
+      if (jsonMatch) {
+        const parsed = JSON.parse(jsonMatch[0]);
+        data = {
+          direction: parsed.direction || "none",
+          entryZone: parsed.entryZone || { min: 0, max: 0 },
+          stopLoss: parsed.stopLoss || 0,
+          takeProfits: parsed.takeProfits || {
+            tp1: { price: 0, size: "33%" },
+            tp2: { price: 0, size: "33%" },
+            tp3: { price: 0, size: "34%" },
+          },
+          positionSize: parsed.positionSize || { percentage: 1, reason: "Default" },
+          riskReward: parsed.riskReward || 0,
+          confidence: parsed.confidence || 0,
+          rationale: parsed.rationale || "",
+        };
+      } else {
+        data = {
+          direction: "none",
+          entryZone: { min: 0, max: 0 },
+          stopLoss: 0,
+          takeProfits: {
+            tp1: { price: 0, size: "33%" },
+            tp2: { price: 0, size: "33%" },
+            tp3: { price: 0, size: "34%" },
+          },
+          positionSize: { percentage: 0, reason: "No valid signal" },
+          riskReward: 0,
+          confidence: 0,
+          rationale: response.substring(0, 200),
+        };
+      }
+
+      console.log(`[/generate-signal] Direction: ${data.direction}`);
+      console.log(`[/generate-signal] R:R = ${data.riskReward}, Confidence = ${data.confidence}%`);
+
+      // If no signal, go back to analysis
+      if (data.direction === "none") {
+        console.log("[/generate-signal] No signal generated, will re-analyze");
+      }
+
+      return {
+        success: true,
+        data,
+        contextUpdates: {
+          signal: data,
+        },
+        nextSkill: data.direction === "none" ? "/analyze-market" : undefined,
+      };
+    } catch (error) {
+      return {
+        success: false,
+        error: error instanceof Error ? error.message : String(error),
+      };
+    }
+  },
+};
+
+skillRegistry.register(generateSignalSkill);
+
+export { GenerateSignalParams };
+export type { GenerateSignalData };

package/src/skills/trading/index.ts

@@ -0,0 +1,26 @@
+/**
+ * GLM Daemon - Trading Skills
+ *
+ * Skills for trading and market analysis workflows.
+ */
+
+// Import to auto-register
+import "./analyze-market.js";
+import "./generate-signal.js";
+import "./check-risk.js";
+import "./execute-trade.js";
+import "./monitor-position.js";
+
+// Re-export for explicit imports
+export { analyzeMarketSkill } from "./analyze-market.js";
+export { generateSignalSkill } from "./generate-signal.js";
+export { checkRiskSkill } from "./check-risk.js";
+export { executeTradeSkill } from "./execute-trade.js";
+export { monitorPositionSkill } from "./monitor-position.js";
+
+// Re-export types
+export type { AnalyzeMarketData } from "./analyze-market.js";
+export type { GenerateSignalData } from "./generate-signal.js";
+export type { CheckRiskData } from "./check-risk.js";
+export type { ExecuteTradeData } from "./execute-trade.js";
+export type { MonitorPositionData } from "./monitor-position.js";