@ebowwa/daemons 0.5.0

package/src/skills/trading/monitor-position.ts

@@ -0,0 +1,179 @@
+/**
+ * GLM Daemon - Monitor Position Skill
+ *
+ * Monitor open positions and market conditions.
+ */
+
+import { z } from "zod";
+import type { Skill, SkillContext, SkillResult } from "../types.js";
+import { skillRegistry } from "../registry.js";
+
+/**
+ * Trade execution result
+ */
+interface TradeExecution {
+  orderId: string;
+  direction: string;
+  entryPrice: number;
+  size: number;
+  stopLoss?: number;
+  takeProfits?: {
+    tp1?: { price: number; size: string };
+    tp2?: { price: number; size: string };
+    tp3?: { price: number; size: string };
+  };
+}
+
+/**
+ * Monitor position parameters
+ */
+const MonitorPositionParams = z.object({
+  /** Check interval hint (ms) */
+  interval: z.number().optional(),
+  /** Maximum hold time (ms) */
+  maxHoldTime: z.number().optional(),
+});
+
+/**
+ * Monitor position result data
+ */
+interface MonitorPositionData {
+  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";
+}
+
+/**
+ * Monitor position skill
+ */
+export const monitorPositionSkill: Skill<z.infer<typeof MonitorPositionParams>, MonitorPositionData> = {
+  id: "/monitor-position",
+  name: "Monitor Position",
+  description: "Monitor open positions and check for target/stop hits.",
+  paramsSchema: MonitorPositionParams,
+  tags: ["trading", "monitoring"],
+  parallelizable: false,
+  requires: ["position"],
+
+  async execute(params, context): Promise<SkillResult<MonitorPositionData>> {
+    const position = (context.custom.position || {}) as TradeExecution;
+    const tradeStartTime = context.custom.tradeStartTime as number | undefined;
+
+    console.log("[/monitor-position] Checking position status");
+
+    const prompt = `Monitor the current position.
+
+Position: ${JSON.stringify(position, null, 2)}
+Trade Start: ${tradeStartTime || "unknown"}
+Current Iteration: ${context.state.iteration}
+
+Check:
+- Current price vs entry
+- Unrealized P&L
+- Distance to take profit levels (TP1: ${position.takeProfits?.tp1?.price}, TP2: ${position.takeProfits?.tp2?.price}, TP3: ${position.takeProfits?.tp3?.price})
+- Distance to stop loss (${position.stopLoss})
+- Market conditions changes
+- Time in trade
+
+Report status 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"
+}`;
+
+    try {
+      const response = await context.agent.execute(prompt);
+
+      // Parse JSON from response
+      const jsonMatch = response.match(/\{[\s\S]*\}/);
+      let data: MonitorPositionData;
+
+      if (jsonMatch) {
+        const parsed = JSON.parse(jsonMatch[0]);
+        data = {
+          currentPrice: parsed.currentPrice || position.entryPrice || 0,
+          unrealizedPnL: parsed.unrealizedPnL || 0,
+          pnlPercent: parsed.pnlPercent || 0,
+          tp1Hit: parsed.tp1Hit || false,
+          tp2Hit: parsed.tp2Hit || false,
+          tp3Hit: parsed.tp3Hit || false,
+          stopLossHit: parsed.stopLossHit || false,
+          targetReached: parsed.targetReached || false,
+          positionClosed: parsed.positionClosed || false,
+          status: parsed.status || "open",
+          recommendation: parsed.recommendation || "hold",
+        };
+      } else {
+        // Fallback: detect from response
+        const lower = response.toLowerCase();
+        data = {
+          currentPrice: position.entryPrice || 0,
+          unrealizedPnL: 0,
+          pnlPercent: 0,
+          tp1Hit: lower.includes("tp1") && lower.includes("hit"),
+          tp2Hit: lower.includes("tp2") && lower.includes("hit"),
+          tp3Hit: lower.includes("tp3") && lower.includes("hit"),
+          stopLossHit: lower.includes("stop loss") && lower.includes("hit"),
+          targetReached: lower.includes("target") && lower.includes("reached"),
+          positionClosed: lower.includes("position closed"),
+          status: "open",
+          recommendation: "hold",
+        };
+      }
+
+      console.log(`[/monitor-position] P&L: ${data.pnlPercent.toFixed(2)}%`);
+      console.log(`[/monitor-position] Status: ${data.status}`);
+      console.log(`[/monitor-position] TP hits: ${[data.tp1Hit, data.tp2Hit, data.tp3Hit].filter(Boolean).length}/3`);
+
+      // Determine next phase
+      let nextSkill: string | undefined;
+      if (data.targetReached || data.stopLossHit || data.status === "closed") {
+        nextSkill = "/complete";
+      } else if (data.positionClosed) {
+        nextSkill = "/analyze-market"; // Look for new opportunities
+      } else if (context.state.iteration % 10 === 0 && context.state.iteration > 0) {
+        nextSkill = "/reflect";
+      }
+
+      return {
+        success: true,
+        data,
+        contextUpdates: {
+          monitorStatus: data,
+          targetReached: data.targetReached,
+          stopLoss: data.stopLossHit,
+          positionClosed: data.positionClosed,
+          currentPnL: data.unrealizedPnL,
+        },
+        nextSkill,
+      };
+    } catch (error) {
+      return {
+        success: false,
+        error: error instanceof Error ? error.message : String(error),
+      };
+    }
+  },
+};
+
+skillRegistry.register(monitorPositionSkill);
+
+export { MonitorPositionParams };
+export type { MonitorPositionData };

package/src/skills/types.ts

@@ -0,0 +1,235 @@
+/**
+ * GLM Daemon - Skill Types
+ *
+ * Composable skill system for workflow phases.
+ * Skills are reusable units of work that can be shared across workflows.
+ */
+
+import type { z } from "zod";
+import type { GLMDaemonState } from "../types.js";
+import type { GLMAgent } from "../agent.js";
+
+/**
+ * Skill parameter schema type
+ */
+export type SkillParams = z.ZodType<unknown>;
+
+/**
+ * Skill result data type
+ * Flexible type for skill result data - can be any non-null value
+ */
+export type SkillData = unknown;
+
+/**
+ * Context passed to skill execution
+ */
+export interface SkillContext {
+  /** Current daemon state */
+  state: GLMDaemonState;
+
+  /** Agent instance for AI calls */
+  agent: GLMAgent;
+
+  /** Workflow-specific custom data */
+  custom: Record<string, unknown>;
+
+  /** Increment tool count and check for reflection trigger */
+  incrementToolCount: () => boolean;
+
+  /** Execute a lifecycle hook */
+  executeHook: (event: string, ...args: unknown[]) => Promise<void>;
+
+  /** Call another skill by ID */
+  callSkill: (id: string, params?: unknown) => Promise<SkillResult>;
+
+  /** Workflow configuration (contains skill params) */
+  workflowConfig?: Record<string, unknown>;
+}
+
+/**
+ * Result returned by skill execution
+ */
+export interface SkillResult<T = SkillData> {
+  /** Whether the skill executed successfully */
+  success: boolean;
+
+  /** Result data from skill execution */
+  data?: T;
+
+  /** Error message if failed */
+  error?: string;
+
+  /** Updates to apply to context.custom */
+  contextUpdates?: Record<string, unknown>;
+
+  /** Updates to apply to daemon state */
+  stateUpdates?: Partial<GLMDaemonState>;
+
+  /** Next skill to execute (overrides workflow transition) */
+  nextSkill?: string;
+
+  /** Whether to stop the workflow */
+  stop?: boolean;
+}
+
+/**
+ * Skill configuration (static definition)
+ */
+export interface SkillConfig<P = unknown> {
+  /** Unique skill identifier (e.g., "analyze-market" → "/analyze-market") */
+  id: string;
+
+  /** Human-readable name */
+  name: string;
+
+  /** Description for AI to understand skill purpose */
+  description: string;
+
+  /** Parameter schema (Zod) for validation */
+  paramsSchema?: z.ZodType<P>;
+
+  /** Default parameters from workflow config */
+  defaultParams?: P;
+
+  /** Context keys required before execution */
+  requires?: string[];
+
+  /** Context keys produced after execution */
+  produces?: string[];
+
+  /** Tags for categorization */
+  tags?: string[];
+
+  /** Whether this skill can run in parallel with others */
+  parallelizable?: boolean;
+
+  /** Max retry attempts on failure (default: 3) */
+  maxRetries?: number;
+
+  /** Base delay for retry backoff in ms (default: 1000) */
+  retryBaseDelay?: number;
+}
+
+/**
+ * Skill interface - combines config and execution
+ */
+export interface Skill<P = unknown, T = SkillData> extends SkillConfig<P> {
+  /** Execute the skill */
+  execute(params: P | undefined, context: SkillContext): Promise<SkillResult<T>>;
+}
+
+/**
+ * Skill factory function type
+ */
+export type SkillFactory<P = unknown, T = SkillData> = (
+  config?: Partial<SkillConfig<P>>
+) => Skill<P, T>;
+
+/**
+ * Transition rule between skills
+ */
+export interface SkillTransition {
+  /** Source skill ID or "*" for any */
+  from: string;
+
+  /** Target skill ID */
+  to: string;
+
+  /** Condition for transition */
+  condition?: SkillTransitionCondition;
+
+  /** Priority (higher = checked first) */
+  priority?: number;
+
+  /** Description of when this transition applies */
+  description?: string;
+}
+
+/**
+ * Transition condition function
+ */
+export type SkillTransitionCondition = (
+  context: SkillContext,
+  result: SkillResult
+) => boolean | Promise<boolean>;
+
+/**
+ * Workflow configuration using skill sequences
+ */
+export interface SkillWorkflowConfig {
+  /** Workflow identifier */
+  id: string;
+
+  /** Human-readable name */
+  name: string;
+
+  /** Description */
+  description: string;
+
+  /** Skills to execute (in order, unless transitions override) */
+  skills: string[];
+
+  /** Initial skill to start with */
+  initialSkill: string;
+
+  /** Skills that terminate the workflow */
+  terminalSkills: string[];
+
+  /** Transition rules between skills */
+  transitions: SkillTransition[];
+
+  /** Default skill parameters */
+  skillParams?: Record<string, unknown>;
+
+  /** System prompt extensions for this workflow */
+  systemPromptExtensions?: string;
+
+  /** Reflection skill ID (if supported) */
+  reflectionSkill?: string;
+
+  /** Custom completion check */
+  isComplete?: (context: SkillContext) => boolean | Promise<boolean>;
+}
+
+/**
+ * Skill execution metadata
+ */
+export interface SkillExecutionMeta {
+  /** Skill ID */
+  skillId: string;
+
+  /** Execution start time */
+  startTime: string;
+
+  /** Execution end time */
+  endTime?: string;
+
+  /** Duration in ms */
+  duration?: number;
+
+  /** Attempt number (for retries) */
+  attempt: number;
+
+  /** Whether execution succeeded */
+  success: boolean;
+
+  /** Error message if failed */
+  error?: string;
+}
+
+/**
+ * Skill execution options
+ */
+export interface SkillExecutionOptions {
+  /** Override max retries */
+  maxRetries?: number;
+
+  /** Skip parameter validation */
+  skipValidation?: boolean;
+
+  /** Custom timeout in ms */
+  timeout?: number;
+
+  /** Whether to update context after execution */
+  updateContext?: boolean;
+}