@ebowwa/daemons 0.5.0

package/src/workflows/trading.ts

@@ -0,0 +1,608 @@
+/**
+ * GLM Daemon - Trading Workflow
+ *
+ * Trading workflow for automated market analysis and execution.
+ * Phases: analyzing → signaling → risk_checking → executing → monitoring → complete
+ *
+ * Key differences from coding workflow:
+ * - No git state (trading doesn't need commits/PRs)
+ * - Focus on market signals and risk management
+ * - Real-time monitoring loops
+ */
+
+import {
+  BaseWorkflow,
+  type GLMWorkflowConfig,
+  type GLMWorkflowContext,
+  type GLMWorkflowPhaseResult,
+  type GLMWorkflowPhase,
+  type GLMWorkflowTransition,
+} from "../workflow.js";
+
+/**
+ * Trading workflow phases
+ */
+export type TradingPhase =
+  | "analyzing"
+  | "signaling"
+  | "risk_checking"
+  | "executing"
+  | "monitoring"
+  | "reflecting"
+  | "complete";
+
+/**
+ * Trading workflow phases definition
+ */
+export const TRADING_PHASES: GLMWorkflowPhase<TradingPhase>[] = [
+  {
+    name: "analyzing",
+    label: "Analyzing",
+    description: "Analyze market conditions and identify opportunities",
+    skippable: false,
+    timeout: 120000, // 2 minutes for analysis
+  },
+  {
+    name: "signaling",
+    label: "Signaling",
+    description: "Generate trading signals based on analysis",
+    skippable: false,
+    timeout: 60000,
+  },
+  {
+    name: "risk_checking",
+    label: "Risk Checking",
+    description: "Evaluate risk and validate signal before execution",
+    skippable: false,
+    timeout: 30000,
+  },
+  {
+    name: "executing",
+    label: "Executing",
+    description: "Execute trades according to validated signals",
+    skippable: false,
+    timeout: 30000, // Quick execution needed
+  },
+  {
+    name: "monitoring",
+    label: "Monitoring",
+    description: "Monitor open positions and market conditions",
+    skippable: false,
+  },
+  {
+    name: "reflecting",
+    label: "Reflecting",
+    description: "Review performance and lessons learned",
+    skippable: true,
+  },
+  {
+    name: "complete",
+    label: "Complete",
+    description: "Trading session finished",
+    skippable: false,
+  },
+];
+
+/**
+ * Trading workflow transition rules
+ */
+export const TRADING_TRANSITIONS: GLMWorkflowTransition<TradingPhase>[] = [
+  // Analyzing -> Signaling (always)
+  {
+    from: "analyzing",
+    to: "signaling",
+    priority: 100,
+  },
+  // Signaling -> Risk Checking (always)
+  {
+    from: "signaling",
+    to: "risk_checking",
+    priority: 100,
+  },
+  // Risk Checking -> Executing (if risk approved)
+  {
+    from: "risk_checking",
+    to: "executing",
+    priority: 100,
+    condition: async (ctx) => {
+      return ctx.custom.riskApproved === true;
+    },
+  },
+  // Risk Checking -> Analyzing (if risk rejected - re-analyze)
+  {
+    from: "risk_checking",
+    to: "analyzing",
+    priority: 90,
+    condition: async (ctx) => {
+      return ctx.custom.riskApproved === false;
+    },
+  },
+  // Executing -> Monitoring (always)
+  {
+    from: "executing",
+    to: "monitoring",
+    priority: 100,
+  },
+  // Monitoring -> Complete (if target reached or stop loss)
+  {
+    from: "monitoring",
+    to: "complete",
+    priority: 100,
+    condition: async (ctx) => {
+      return ctx.custom.targetReached === true || ctx.custom.stopLoss === true;
+    },
+  },
+  // Monitoring -> Analyzing (if position closed - look for new opportunities)
+  {
+    from: "monitoring",
+    to: "analyzing",
+    priority: 90,
+    condition: async (ctx) => {
+      return ctx.custom.positionClosed === true;
+    },
+  },
+  // Monitoring -> Reflecting (periodic checkpoint)
+  {
+    from: "monitoring",
+    to: "reflecting",
+    priority: 80,
+    condition: async (ctx) => {
+      // Reflect every N iterations
+      return ctx.state.iteration % 10 === 0;
+    },
+  },
+  // Monitoring -> Monitoring (continue monitoring)
+  {
+    from: "monitoring",
+    to: "monitoring",
+    priority: 60,
+  },
+  // Reflecting -> Monitoring
+  {
+    from: "reflecting",
+    to: "monitoring",
+    priority: 100,
+  },
+];
+
+/**
+ * Trading workflow configuration
+ */
+export const TRADING_WORKFLOW_CONFIG: GLMWorkflowConfig<TradingPhase> = {
+  id: "trading",
+  name: "Trading Workflow",
+  description: "Trading workflow for automated market analysis and execution",
+  phases: TRADING_PHASES,
+  initialPhase: "analyzing",
+  terminalPhases: ["complete"],
+  transitions: TRADING_TRANSITIONS,
+  defaultOrder: ["analyzing", "signaling", "risk_checking", "executing", "monitoring", "complete"],
+  reflectionPhase: "reflecting",
+  systemPromptExtensions: `You are a trading assistant.
+Follow risk management rules strictly.
+Never exceed position size limits.
+Always use stop-loss orders.
+No git operations are needed - focus on market execution.`,
+};
+
+/**
+ * Trading Workflow implementation
+ */
+export class TradingWorkflow extends BaseWorkflow<TradingPhase> {
+  constructor() {
+    super(TRADING_WORKFLOW_CONFIG);
+  }
+
+  /**
+   * Build system prompt for trading context
+   */
+  buildSystemPrompt(context: GLMWorkflowContext): string {
+    const basePrompt = super.buildSystemPrompt(context);
+
+    // Add trading-specific context
+    const tradingContext = `
+Trading Context:
+- Risk Level: ${context.custom.riskLevel || "medium"}
+- Position Limit: ${context.custom.positionLimit || 1}
+- Current P&L: ${context.custom.currentPnL || "N/A"}
+`;
+
+    return basePrompt + tradingContext;
+  }
+
+  /**
+   * Execute a trading phase
+   */
+  async executePhase(phase: string, context: GLMWorkflowContext): Promise<GLMWorkflowPhaseResult> {
+    switch (phase as TradingPhase) {
+      case "analyzing":
+        return this.phaseAnalyzing(context);
+      case "signaling":
+        return this.phaseSignaling(context);
+      case "risk_checking":
+        return this.phaseRiskChecking(context);
+      case "executing":
+        return this.phaseExecuting(context);
+      case "monitoring":
+        return this.phaseMonitoring(context);
+      case "reflecting":
+        return this.phaseReflecting(context);
+      case "complete":
+        return this.phaseComplete(context);
+      default:
+        throw new Error(`Unknown phase: ${phase}`);
+    }
+  }
+
+  /**
+   * Analyzing phase - analyze market conditions
+   */
+  private async phaseAnalyzing(context: GLMWorkflowContext): Promise<GLMWorkflowPhaseResult> {
+    console.log("[TradingWorkflow] Phase: Analyzing market conditions");
+
+    const prompt = `Analyze current market conditions for trading.
+
+Task: ${context.state.prompt}
+
+Consider:
+- Price action and trends
+- Volume analysis
+- Technical indicators (RSI, MACD, Moving Averages)
+- Market sentiment
+- News and events
+- Support and resistance levels
+
+Provide a structured analysis in JSON format:
+{
+  "trend": "bullish|bearish|sideways",
+  "confidence": 0-100,
+  "keyLevels": {
+    "support": ["price levels"],
+    "resistance": ["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"
+}
+`;
+
+    const response = await context.agent.execute(prompt);
+
+    // Parse and store analysis
+    try {
+      const jsonMatch = response.match(/\{[\s\S]*\}/);
+      if (jsonMatch) {
+        const analysis = JSON.parse(jsonMatch[0]);
+        context.custom.analysis = analysis;
+        context.custom.riskLevel = analysis.riskLevel || "medium";
+      }
+    } catch {
+      context.custom.analysis = { raw: response };
+    }
+
+    return {
+      nextPhase: "signaling",
+      continue: true,
+    };
+  }
+
+  /**
+   * Signaling phase - generate trading signals
+   */
+  private async phaseSignaling(context: GLMWorkflowContext): Promise<GLMWorkflowPhaseResult> {
+    console.log("[TradingWorkflow] Phase: Generating signals");
+
+    const analysis = context.custom.analysis || {};
+
+    const prompt = `Generate trading signals based on the market analysis.
+
+Analysis: ${JSON.stringify(analysis, null, 2)}
+
+Generate a trading signal with:
+- Direction (long/short)
+- Entry price zone
+- Stop loss level
+- Take profit targets (1, 2, 3)
+- Position size recommendation
+- Risk/reward ratio
+- Confidence level
+
+Provide the signal in JSON format:
+{
+  "direction": "long|short",
+  "entryZone": { "min": number, "max": number },
+  "stopLoss": number,
+  "takeProfits": {
+    "tp1": { "price": number, "size": "percentage of position" },
+    "tp2": { "price": number, "size": "percentage of position" },
+    "tp3": { "price": number, "size": "percentage of position" }
+  },
+  "positionSize": { "percentage": number, "reason": "string" },
+  "riskReward": number,
+  "confidence": 0-100,
+  "rationale": "explanation for the signal"
+}
+`;
+
+    const response = await context.agent.execute(prompt);
+
+    // Parse and store signal
+    try {
+      const jsonMatch = response.match(/\{[\s\S]*\}/);
+      if (jsonMatch) {
+        context.custom.signal = JSON.parse(jsonMatch[0]);
+      }
+    } catch {
+      context.custom.signal = { raw: response };
+    }
+
+    return {
+      nextPhase: "risk_checking",
+      continue: true,
+    };
+  }
+
+  /**
+   * Risk Checking phase - evaluate risk before execution
+   */
+  private async phaseRiskChecking(context: GLMWorkflowContext): Promise<GLMWorkflowPhaseResult> {
+    console.log("[TradingWorkflow] Phase: Risk checking");
+
+    const analysis = context.custom.analysis || {};
+    const signal = context.custom.signal || {};
+
+    const prompt = `Perform risk assessment for the proposed trade.
+
+Analysis: ${JSON.stringify(analysis, null, 2)}
+Signal: ${JSON.stringify(signal, null, 2)}
+
+Evaluate:
+1. Risk/reward ratio (minimum 1:2)
+2. Position size vs account risk (max 2% per trade)
+3. Market conditions (avoid high volatility if conservative)
+4. Correlation with existing positions
+5. Stop loss placement validity
+
+Respond with risk assessment 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.
+`;
+
+    const response = await context.agent.execute(prompt);
+
+    // Parse risk assessment
+    try {
+      const jsonMatch = response.match(/\{[\s\S]*\}/);
+      if (jsonMatch) {
+        const riskAssessment = JSON.parse(jsonMatch[0]);
+        context.custom.riskAssessment = riskAssessment;
+        context.custom.riskApproved = riskAssessment.approved === true;
+
+        // Adjust position size if suggested
+        if (riskAssessment.maxPositionSize && context.custom.signal) {
+          (context.custom.signal as any).positionSize = { percentage: riskAssessment.maxPositionSize };
+        }
+      }
+    } catch {
+      // Default to not approved on parse failure
+      context.custom.riskApproved = false;
+      context.custom.riskAssessment = { raw: response, approved: false };
+    }
+
+    const nextPhase = context.custom.riskApproved ? "executing" : "analyzing";
+
+    return {
+      nextPhase,
+      continue: true,
+      data: { riskApproved: context.custom.riskApproved },
+    };
+  }
+
+  /**
+   * Executing phase - execute trades
+   */
+  private async phaseExecuting(context: GLMWorkflowContext): Promise<GLMWorkflowPhaseResult> {
+    console.log("[TradingWorkflow] Phase: Executing trade");
+
+    const signal = context.custom.signal || {};
+    const riskAssessment = context.custom.riskAssessment || {};
+
+    const prompt = `Execute the approved trade signal.
+
+Signal: ${JSON.stringify(signal, null, 2)}
+Risk Assessment: ${JSON.stringify(riskAssessment, null, 2)}
+
+Use the available trading tools to:
+1. Place the entry order (limit or market based on conditions)
+2. Set stop loss order
+3. Set take profit orders (tp1, tp2, tp3)
+4. Confirm all orders are placed correctly
+
+Report the execution status with order IDs.
+`;
+
+    const response = await context.agent.execute(prompt);
+    context.custom.executionResult = response;
+    context.custom.tradeStartTime = new Date().toISOString();
+
+    return {
+      nextPhase: "monitoring",
+      continue: true,
+    };
+  }
+
+  /**
+   * Monitoring phase - monitor positions
+   */
+  private async phaseMonitoring(context: GLMWorkflowContext): Promise<GLMWorkflowPhaseResult> {
+    console.log("[TradingWorkflow] Phase: Monitoring position");
+
+    const signal = context.custom.signal || {};
+    const executionResult = context.custom.executionResult || "";
+
+    const prompt = `Monitor the current position.
+
+Signal: ${JSON.stringify(signal, null, 2)}
+Execution: ${executionResult}
+Trade Start: ${context.custom.tradeStartTime || "unknown"}
+
+Check:
+- Current price vs entry
+- Unrealized P&L
+- Distance to take profit levels
+- Distance to stop loss
+- Market conditions changes
+- Time in trade
+
+Report status and current state in JSON format:
+{
+  "currentPrice": number,
+  "unrealizedPnL": number,
+  "pnlPercent": number,
+  "tp1Hit": boolean,
+  "tp2Hit": boolean,
+  "tp3Hit": boolean,
+  "stopLossHit": boolean,
+  "targetReached": boolean,
+  "positionClosed": boolean,
+  "status": "open|closed|stopped_out|taken_profit",
+  "recommendation": "hold|close|adjust"
+}
+`;
+
+    const response = await context.agent.execute(prompt);
+
+    // Parse monitoring result
+    try {
+      const jsonMatch = response.match(/\{[\s\S]*\}/);
+      if (jsonMatch) {
+        const monitorStatus = JSON.parse(jsonMatch[0]);
+        context.custom.monitorStatus = monitorStatus;
+        context.custom.targetReached = monitorStatus.targetReached === true;
+        context.custom.stopLoss = monitorStatus.stopLossHit === true;
+        context.custom.positionClosed = monitorStatus.positionClosed === true;
+        context.custom.currentPnL = monitorStatus.unrealizedPnL;
+      }
+    } catch {
+      // Fallback detection
+      const lowerResponse = response.toLowerCase();
+      context.custom.targetReached = lowerResponse.includes("target") && lowerResponse.includes("reached");
+      context.custom.stopLoss = lowerResponse.includes("stop loss") && lowerResponse.includes("hit");
+      context.custom.positionClosed = lowerResponse.includes("position closed");
+    }
+
+    // Determine next phase
+    let nextPhase: TradingPhase = "monitoring";
+    if (context.custom.targetReached || context.custom.stopLoss) {
+      nextPhase = "complete";
+    } else if (context.custom.positionClosed) {
+      nextPhase = "analyzing"; // Look for new opportunities
+    } else if (context.state.iteration % 10 === 0 && context.state.iteration > 0) {
+      nextPhase = "reflecting";
+    }
+
+    return {
+      nextPhase,
+      continue: true,
+    };
+  }
+
+  /**
+   * Reflecting phase - review performance
+   */
+  private async phaseReflecting(context: GLMWorkflowContext): Promise<GLMWorkflowPhaseResult> {
+    console.log(`[TradingWorkflow] Phase: Reflecting (checkpoint #${context.state.reflection.checkpointCount + 1})`);
+
+    const prompt = `Reflect on trading performance so far.
+
+Iteration: ${context.state.iteration}
+Current P&L: ${context.custom.currentPnL || "unknown"}
+Risk Level: ${context.custom.riskLevel || "medium"}
+
+Review:
+- What trades were taken?
+- What signals were generated but not executed?
+- What's the win rate?
+- Are risk parameters being followed?
+
+Provide a brief performance summary:
+{
+  "totalSignals": number,
+  "signalsExecuted": number,
+  "winRate": number,
+  "currentDrawdown": number,
+  "lessonsLearned": ["insights"],
+  "adjustmentsNeeded": ["suggested adjustments"]
+}
+`;
+
+    const response = await context.agent.execute(prompt);
+
+    // Parse reflection
+    try {
+      const jsonMatch = response.match(/\{[\s\S]*\}/);
+      if (jsonMatch) {
+        context.custom.reflection = JSON.parse(jsonMatch[0]);
+      }
+    } catch {
+      context.custom.reflection = { raw: response };
+    }
+
+    return {
+      nextPhase: "monitoring",
+      continue: true,
+    };
+  }
+
+  /**
+   * Complete phase - trading session finished
+   */
+  private async phaseComplete(context: GLMWorkflowContext): Promise<GLMWorkflowPhaseResult> {
+    console.log("[TradingWorkflow] Trading session complete!");
+
+    const prompt = `Final summary of trading session.
+
+Session Summary:
+- Total Iterations: ${context.state.iteration}
+- Final P&L: ${context.custom.currentPnL || "unknown"}
+- Target Reached: ${context.custom.targetReached ? "Yes" : "No"}
+- Stop Loss Hit: ${context.custom.stopLoss ? "Yes" : "No"}
+
+Report:
+- Total signals generated
+- Trades executed
+- Win/loss ratio
+- Total P&L
+- Maximum drawdown
+- Key lessons learned
+- Recommendations for future sessions
+
+Format as a trading journal entry.
+`;
+
+    await context.agent.execute(prompt);
+
+    await context.executeHook("onSessionEnd", context.state);
+
+    return {
+      nextPhase: "complete",
+      continue: false,
+    };
+  }
+}
+
+// Export singleton instance
+export const tradingWorkflow = new TradingWorkflow();