@ebowwa/daemons 0.5.0 → 0.7.0

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

@@ -1,176 +0,0 @@
-/**
- * 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

@@ -1,185 +0,0 @@
-/**
- * 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

@@ -1,160 +0,0 @@
-/**
- * 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

@@ -1,26 +0,0 @@
-/**
- * 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";