hyper_agent_ai/

adjuster_prompt.rs

use serde::{Deserialize, Serialize};

// ---------------------------------------------------------------------------
// Types
// ---------------------------------------------------------------------------

/// All context needed to build a market-context prompt for Claude strategy
/// adjuster. Fields are kept as simple, serializable types so the caller
/// can assemble them from heterogeneous sources without coupling to internal
/// domain structs.
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct AdjusterContext {
    /// Trading symbol, e.g. "BTC-PERP".
    pub symbol: String,
    /// Latest mark / last price (None if not yet available).
    pub current_price: Option<f64>,
    /// Snapshot of technical indicators as free-form JSON.
    /// Expected keys: rsi, macd, bb, adx, volume (truncated to essentials).
    pub indicators: Option<serde_json::Value>,
    /// Current market regime label, e.g. "trending_up".
    pub current_regime: String,
    /// How long the current regime has been held, in seconds.
    pub regime_duration_secs: u64,
    /// Last N signal summaries (capped to 10 by caller).
    pub recent_signals: Vec<String>,
    /// Last N trade summaries (capped to 5 by caller).
    pub recent_trades: Vec<String>,
    /// Open position summaries (human-readable lines).
    pub current_positions: Vec<String>,
    /// Cumulative realised + unrealised P&L.
    pub total_pnl: f64,
    /// P&L for the current calendar day.
    pub daily_pnl: f64,
    /// Current StrategyGroup serialized as JSON.
    pub strategy_params: serde_json::Value,
    /// Hard cap on any single position size (USDC).
    pub max_position_usdc: f64,
}

// ---------------------------------------------------------------------------
// System prompt
// ---------------------------------------------------------------------------

/// Build the system prompt that tells Claude how to behave as a strategy
/// optimizer. `max_position_usdc` is embedded as a hard constraint.
pub fn build_system_prompt(max_position_usdc: f64) -> String {
    format!(
        r#"You are a **strategy parameter optimizer** for an automated crypto trading system.
You are NOT a trader -- you do not place orders. Your sole job is to suggest
small, incremental adjustments to the strategy configuration so that the
system can adapt to changing market conditions.

## Output format

Return a JSON object conforming to the `StrategyAdjustment` schema:

```json
{{
  "reasoning": "string — explain WHY you are making changes",
  "regime_rules": null | [...],
  "default_regime": null | "string",
  "hysteresis": null | {{ "min_hold_secs": u64, "confirmation_count": u32 }},
  "playbook_overrides": null | {{
    "<regime_name>": {{
      "rules": null | [...],
      "max_position_size": null | f64,
      "stop_loss_pct": null | f64,
      "take_profit_pct": null | f64
    }}
  }}
}}
```

- Omit any field you do not want to change (set it to `null`).
- If the strategy is performing well and no changes are needed, return an
  empty object `{{}}`.
- Always include a `"reasoning"` field when you *do* propose changes.

## Constraints

- **max_position_size** must not exceed {max_position_usdc:.2} USDC.
- **stop_loss_pct** must be between 0.5 and 50.0 (percent).
- **take_profit_pct** must be between 0.5 and 200.0 (percent).
- **min_hold_secs** (hysteresis) must be between 60 and 86400.
- **confirmation_count** must be between 1 and 20.

## Philosophy

- Prefer **small, incremental** changes over large swings.
- Be **conservative** -- only adjust when the data clearly supports it.
- If the strategy is profitable and volatility is normal, **do nothing**.
- Never chase short-term noise; focus on regime-level signals.
- When in doubt, tighten risk (lower position size, tighter SL) rather than
  loosen it."#,
        max_position_usdc = max_position_usdc,
    )
}

// ---------------------------------------------------------------------------
// User message
// ---------------------------------------------------------------------------

/// Build the user message containing full market + strategy context.
/// Sections are ordered for readability and token efficiency.
pub fn build_user_message(ctx: &AdjusterContext) -> String {
    let mut sections: Vec<String> = Vec::with_capacity(10);

    // --- Current Price ---
    sections.push(build_price_section(ctx));

    // --- Technical Indicators ---
    sections.push(build_indicators_section(ctx));

    // --- Regime ---
    sections.push(build_regime_section(ctx));

    // --- Current Strategy Parameters ---
    sections.push(build_strategy_section(ctx));

    // --- Recent Performance ---
    sections.push(build_performance_section(ctx));

    // --- Recent Signals ---
    sections.push(build_signals_section(ctx));

    // --- Recent Trades ---
    if !ctx.recent_trades.is_empty() {
        sections.push(build_trades_section(ctx));
    }

    // --- Open Positions ---
    sections.push(build_positions_section(ctx));

    // --- Task ---
    sections.push(build_task_section());

    sections.join("\n\n")
}

// ---------------------------------------------------------------------------
// Section builders
// ---------------------------------------------------------------------------

fn build_price_section(ctx: &AdjusterContext) -> String {
    match ctx.current_price {
        Some(price) => format!("## Current Price\n{}: ${:.2}", ctx.symbol, price),
        None => format!("## Current Price\n{}: (unavailable)", ctx.symbol),
    }
}

fn build_indicators_section(ctx: &AdjusterContext) -> String {
    let mut lines = vec!["## Technical Indicators".to_string()];

    match ctx.indicators {
        Some(ref val) if val.is_object() => {
            let obj = val.as_object().unwrap();
            // Render in a deterministic, readable order for the key indicators.
            let preferred_order = ["rsi", "macd", "bb", "adx", "volume"];
            for &key in &preferred_order {
                if let Some(v) = obj.get(key) {
                    lines.push(format!("- {}: {}", key.to_uppercase(), format_indicator(v)));
                }
            }
            // Any remaining keys not in the preferred order.
            for (k, v) in obj {
                let lower = k.to_lowercase();
                if !preferred_order.contains(&lower.as_str()) {
                    lines.push(format!("- {}: {}", k.to_uppercase(), format_indicator(v)));
                }
            }
            if lines.len() == 1 {
                lines.push("(no indicator data)".to_string());
            }
        }
        _ => {
            lines.push("(no indicator data available)".to_string());
        }
    }

    lines.join("\n")
}

/// Format a single indicator JSON value into a compact human-readable string.
fn format_indicator(val: &serde_json::Value) -> String {
    match val {
        serde_json::Value::Number(n) => format!("{}", n),
        serde_json::Value::String(s) => s.clone(),
        serde_json::Value::Object(map) => {
            let parts: Vec<String> = map.iter().map(|(k, v)| format!("{}={}", k, v)).collect();
            parts.join(", ")
        }
        other => other.to_string(),
    }
}

fn build_regime_section(ctx: &AdjusterContext) -> String {
    format!(
        "## Current Regime\nRegime: {} (held for {})",
        ctx.current_regime,
        format_duration(ctx.regime_duration_secs),
    )
}

fn build_strategy_section(ctx: &AdjusterContext) -> String {
    let pretty = serde_json::to_string_pretty(&ctx.strategy_params).unwrap_or_default();
    format!("## Current Strategy Parameters\n```json\n{}\n```", pretty)
}

fn build_performance_section(ctx: &AdjusterContext) -> String {
    format!(
        "## Recent Performance\nDaily P&L: ${:.2}\nTotal P&L: ${:.2}",
        ctx.daily_pnl, ctx.total_pnl,
    )
}

fn build_signals_section(ctx: &AdjusterContext) -> String {
    let mut lines = vec!["## Recent Signals (last 10)".to_string()];
    if ctx.recent_signals.is_empty() {
        lines.push("(none)".to_string());
    } else {
        for s in ctx.recent_signals.iter().take(10) {
            lines.push(format!("- {}", s));
        }
    }
    lines.join("\n")
}

fn build_trades_section(ctx: &AdjusterContext) -> String {
    let mut lines = vec!["## Recent Trades (last 5)".to_string()];
    for t in ctx.recent_trades.iter().take(5) {
        lines.push(format!("- {}", t));
    }
    lines.join("\n")
}

fn build_positions_section(ctx: &AdjusterContext) -> String {
    let mut lines = vec!["## Open Positions".to_string()];
    if ctx.current_positions.is_empty() {
        lines.push("(no open positions)".to_string());
    } else {
        for p in &ctx.current_positions {
            lines.push(format!("- {}", p));
        }
    }
    lines.join("\n")
}

fn build_task_section() -> String {
    "## Your Task\n\
     Analyze the market conditions and strategy performance above.\n\
     Suggest parameter adjustments as a JSON `StrategyAdjustment` object, \
     or `{}` if no changes are needed."
        .to_string()
}

// ---------------------------------------------------------------------------
// Helpers
// ---------------------------------------------------------------------------

/// Format a duration in seconds into a compact human-readable string.
fn format_duration(secs: u64) -> String {
    if secs < 60 {
        format!("{}s", secs)
    } else if secs < 3600 {
        format!("{} minutes", secs / 60)
    } else if secs < 86400 {
        let h = secs / 3600;
        let m = (secs % 3600) / 60;
        if m == 0 {
            format!("{} hours", h)
        } else {
            format!("{}h {}m", h, m)
        }
    } else {
        let d = secs / 86400;
        let h = (secs % 86400) / 3600;
        if h == 0 {
            format!("{} days", d)
        } else {
            format!("{}d {}h", d, h)
        }
    }
}

// ---------------------------------------------------------------------------
// Tests
// ---------------------------------------------------------------------------

#[cfg(test)]
mod tests {
    use super::*;
    use serde_json::json;

    fn full_context() -> AdjusterContext {
        AdjusterContext {
            symbol: "BTC-PERP".to_string(),
            current_price: Some(67344.0),
            indicators: Some(json!({
                "rsi": 62.3,
                "macd": {"value": 150.2, "signal": 120.1, "hist": 30.1},
                "bb": {"upper": 68000, "mid": 66500, "lower": 65000},
                "adx": {"adx": 28.5, "plus_di": 35.2, "minus_di": 18.7},
                "volume": "1.2M"
            })),
            current_regime: "trending_up".to_string(),
            regime_duration_secs: 2700,
            recent_signals: vec![
                "trending_up | OrderPlaced buy 0.001 BTC".to_string(),
                "trending_up | None (hold)".to_string(),
            ],
            recent_trades: vec![
                "buy 0.001 BTC @ $67000".to_string(),
                "sell 0.001 BTC @ $67200".to_string(),
            ],
            current_positions: vec!["BTC-PERP long 0.001 entry=$67000 pnl=+$3.44".to_string()],
            total_pnl: 125.50,
            daily_pnl: -30.0,
            strategy_params: json!({"name": "momentum_v1", "interval_secs": 300}),
            max_position_usdc: 10000.0,
        }
    }

    fn minimal_context() -> AdjusterContext {
        AdjusterContext {
            symbol: "ETH-PERP".to_string(),
            current_price: None,
            indicators: None,
            current_regime: "neutral".to_string(),
            regime_duration_secs: 0,
            recent_signals: vec![],
            recent_trades: vec![],
            current_positions: vec![],
            total_pnl: 0.0,
            daily_pnl: 0.0,
            strategy_params: json!({}),
            max_position_usdc: 5000.0,
        }
    }

    // --- build_system_prompt tests ---

    #[test]
    fn system_prompt_contains_key_constraints() {
        let prompt = build_system_prompt(10000.0);
        assert!(
            prompt.contains("10000.00"),
            "should embed max_position_usdc"
        );
        assert!(prompt.contains("strategy parameter optimizer"));
        assert!(prompt.contains("StrategyAdjustment"));
        assert!(prompt.contains("conservative"));
        assert!(prompt.contains("small, incremental"));
        assert!(
            prompt.contains("{}"),
            "should mention empty object for no changes"
        );
        assert!(prompt.contains("reasoning"));
        assert!(prompt.contains("stop_loss_pct"));
        assert!(prompt.contains("take_profit_pct"));
    }

    #[test]
    fn system_prompt_varies_with_limit() {
        let a = build_system_prompt(5000.0);
        let b = build_system_prompt(20000.0);
        assert!(a.contains("5000.00"));
        assert!(b.contains("20000.00"));
        assert!(!a.contains("20000.00"));
    }

    // --- build_user_message with full context ---

    #[test]
    fn user_message_full_context_contains_all_sections() {
        let ctx = full_context();
        let msg = build_user_message(&ctx);

        assert!(msg.contains("## Current Price"));
        assert!(msg.contains("BTC-PERP: $67344.00"));
        assert!(msg.contains("## Technical Indicators"));
        assert!(msg.contains("RSI"));
        assert!(msg.contains("MACD"));
        assert!(msg.contains("## Current Regime"));
        assert!(msg.contains("trending_up"));
        assert!(msg.contains("45 minutes"));
        assert!(msg.contains("## Current Strategy Parameters"));
        assert!(msg.contains("momentum_v1"));
        assert!(msg.contains("## Recent Performance"));
        assert!(msg.contains("Daily P&L: $-30.00"));
        assert!(msg.contains("Total P&L: $125.50"));
        assert!(msg.contains("## Recent Signals"));
        assert!(msg.contains("OrderPlaced buy 0.001 BTC"));
        assert!(msg.contains("## Recent Trades"));
        assert!(msg.contains("buy 0.001 BTC @ $67000"));
        assert!(msg.contains("## Open Positions"));
        assert!(msg.contains("BTC-PERP long 0.001"));
        assert!(msg.contains("## Your Task"));
    }

    #[test]
    fn user_message_full_context_is_non_empty() {
        let ctx = full_context();
        let msg = build_user_message(&ctx);
        assert!(!msg.is_empty());
        // Should be a reasonable size (not gigantic).
        assert!(msg.len() < 10_000, "prompt should be token-efficient");
    }

    // --- build_user_message with minimal context ---

    #[test]
    fn user_message_minimal_context_does_not_panic() {
        let ctx = minimal_context();
        let msg = build_user_message(&ctx);
        assert!(!msg.is_empty());
    }

    #[test]
    fn user_message_minimal_context_handles_none_indicators() {
        let ctx = minimal_context();
        let msg = build_user_message(&ctx);
        assert!(msg.contains("no indicator data"));
    }

    #[test]
    fn user_message_minimal_context_handles_none_price() {
        let ctx = minimal_context();
        let msg = build_user_message(&ctx);
        assert!(msg.contains("(unavailable)"));
    }

    #[test]
    fn user_message_minimal_context_handles_empty_signals() {
        let ctx = minimal_context();
        let msg = build_user_message(&ctx);
        assert!(msg.contains("(none)"));
    }

    #[test]
    fn user_message_minimal_context_handles_empty_positions() {
        let ctx = minimal_context();
        let msg = build_user_message(&ctx);
        assert!(msg.contains("no open positions"));
    }

    #[test]
    fn user_message_minimal_context_omits_trades_section() {
        let ctx = minimal_context();
        let msg = build_user_message(&ctx);
        assert!(!msg.contains("## Recent Trades"));
    }

    // --- Section-level tests ---

    #[test]
    fn indicators_section_renders_object_values() {
        let ctx = full_context();
        let section = build_indicators_section(&ctx);
        // MACD is an object, should expand its keys.
        assert!(section.contains("MACD"));
        assert!(section.contains("signal"));
    }

    #[test]
    fn indicators_section_with_empty_object() {
        let mut ctx = minimal_context();
        ctx.indicators = Some(json!({}));
        let section = build_indicators_section(&ctx);
        assert!(section.contains("no indicator data"));
    }

    #[test]
    fn format_duration_ranges() {
        assert_eq!(format_duration(30), "30s");
        assert_eq!(format_duration(120), "2 minutes");
        assert_eq!(format_duration(2700), "45 minutes");
        assert_eq!(format_duration(3600), "1 hours");
        assert_eq!(format_duration(5400), "1h 30m");
        assert_eq!(format_duration(86400), "1 days");
        assert_eq!(format_duration(90000), "1d 1h");
    }

    #[test]
    fn signals_capped_at_ten() {
        let mut ctx = full_context();
        ctx.recent_signals = (0..20).map(|i| format!("signal_{}", i)).collect();
        let msg = build_user_message(&ctx);
        // signal_9 should appear, signal_10 should not.
        assert!(msg.contains("signal_9"));
        assert!(!msg.contains("signal_10"));
    }

    #[test]
    fn trades_capped_at_five() {
        let mut ctx = full_context();
        ctx.recent_trades = (0..10).map(|i| format!("trade_{}", i)).collect();
        let msg = build_user_message(&ctx);
        assert!(msg.contains("trade_4"));
        assert!(!msg.contains("trade_5"));
    }
}