AI Skills System

---
id: "arbitrage-sumtoone"
name: "Sum-to-One Arbitrage Strategy"
version: "1.0.0"
description: "Detect and execute sum-to-one arbitrage opportunities across exchanges"
category: "arbitrage"
author: "NeuraTrade"
tags: ["arbitrage", "cross-exchange", "low-risk"]
dependencies: ["risk-management", "position-sizing"]
parameters:
  min_spread:
    type: "float"
    description: "Minimum profit spread percentage"
    required: true
    default: 0.5
  max_position:
    type: "float"
    description: "Maximum position size as % of portfolio"
    required: true
    default: 0.1
examples:
  - name: "Basic arbitrage"
    description: "Simple two-exchange arbitrage"
    inputs:
      symbol: "BTC/USDT"
      buy_exchange: "binance"
      sell_exchange: "kraken"
      spread: 0.8
    expected:
      action: "execute"
      confidence: 0.9
---

# Sum-to-One Arbitrage Strategy

## Overview
Sum-to-one arbitrage exploits price discrepancies across exchanges...

## Detection
1. Monitor ticker prices across all configured exchanges
2. Calculate spread: `(highest_bid - lowest_ask) / lowest_ask`
3. Subtract fees: `spread - (buy_fee + sell_fee + transfer_fee)`
4. If net spread > min_spread, trigger opportunity

## Execution
1. Verify sufficient balance on both exchanges
2. Place simultaneous buy and sell orders
3. Monitor fills and adjust if partial fills occur
4. Transfer funds if needed for balance

## Risk Factors
- **Execution Risk**: Prices move before orders fill
- **Transfer Risk**: Delays in fund transfers between exchanges
- **Liquidity Risk**: Insufficient order book depth

## Example

// services/backend-api/internal/skill/loader.go:52-98
type Skill struct {
    ID           string                 `yaml:"id"`
    Name         string                 `yaml:"name"`
    Version      string                 `yaml:"version"`
    Description  string                 `yaml:"description"`
    Category     string                 `yaml:"category"`
    Tags         []string               `yaml:"tags"`
    Dependencies []string               `yaml:"dependencies"`
    Parameters   map[string]Param       `yaml:"parameters"`
    Examples     []Example              `yaml:"examples"`
    Content      string                 // Markdown content
    SourcePath   string                 // File path
}

loader := skill.NewLoader("./skills")
skills, err := loader.LoadAll()

type PromptBuilder struct {
    skillLoader  *skill.Loader
    contextLimit int  // Max tokens for context
}

func (pb *PromptBuilder) BuildPrompt(opts PromptOptions) (string, error) {
    // 1. Load required skills
    skills := pb.loadSkills(opts.RequiredSkills)
    
    // 2. Build system prompt
    systemPrompt := pb.buildSystemPrompt(opts.AgentRole)
    
    // 3. Add skill content (progressive disclosure)
    skillContent := pb.addSkills(skills, opts.Priority)
    
    // 4. Add market context
    marketContext := pb.addMarketContext(opts.Symbol, opts.Timeframe)
    
    // 5. Add user instruction
    userInstruction := opts.Instruction
    
    return fmt.Sprintf("%s\n\n%s\n\n%s\n\n%s",
        systemPrompt, skillContent, marketContext, userInstruction)
}

func (pb *PromptBuilder) rankSkills(skills []*Skill, context Context) []*RankedSkill {
    ranked := make([]*RankedSkill, 0, len(skills))
    
    for _, skill := range skills {
        score := 0.0
        
        // Required skills get highest priority
        if contains(context.RequiredSkills, skill.ID) {
            score += 100.0
        }
        
        // Category match
        if skill.Category == context.Category {
            score += 50.0
        }
        
        // Tag match
        for _, tag := range skill.Tags {
            if contains(context.Tags, tag) {
                score += 10.0
            }
        }
        
        // Recently used skills get bonus
        if wasRecentlyUsed(skill.ID) {
            score += 20.0
        }
        
        ranked = append(ranked, &RankedSkill{
            Skill: skill,
            Score: score,
        })
    }
    
    sort.Slice(ranked, func(i, j int) bool {
        return ranked[i].Score > ranked[j].Score
    })
    
    return ranked
}

// Compose arbitrage + risk management
prompt := builder.BuildPrompt(PromptOptions{
    AgentRole: "trader",
    RequiredSkills: []string{
        "arbitrage-sumtoone",
        "risk-management",
        "position-sizing",
    },
    Instruction: "Evaluate this arbitrage opportunity and recommend position size",
    Symbol: "BTC/USDT",
    Context: arbitrageOpportunity,
})

---
id: "arbitrage-sumtoone"
dependencies: ["risk-management", "position-sizing"]
---

parameters:
  min_spread:
    type: "float"
    description: "Minimum profit spread percentage"
    required: true
    default: 0.5
  max_position:
    type: "float"
    description: "Maximum position size as % of portfolio"
    required: true
    default: 0.1
  exchanges:
    type: "array"
    description: "List of exchanges to monitor"
    required: false
    default: ["binance", "kraken", "coinbase"]

params := map[string]interface{}{
    "min_spread": 0.8,
    "max_position": 0.05,
}

prompt := builder.BuildPrompt(PromptOptions{
    RequiredSkills: []string{"arbitrage-sumtoone"},
    Parameters: params,
})

examples:
  - name: "Basic arbitrage"
    description: "Simple two-exchange arbitrage"
    inputs:
      symbol: "BTC/USDT"
      buy_exchange: "binance"
      sell_exchange: "kraken"
      spread: 0.8
    expected:
      action: "execute"
      confidence: 0.9
      reasoning: "Spread exceeds minimum threshold after fees"
  
  - name: "Rejected arbitrage"
    description: "Spread too small after fees"
    inputs:
      symbol: "ETH/USDT"
      buy_exchange: "binance"
      sell_exchange: "kraken"
      spread: 0.3
    expected:
      action: "skip"
      confidence: 0.95
      reasoning: "Net spread (0.0%) below minimum threshold (0.5%) after fees"

Here are some examples of how to apply this skill:

Example 1: Basic arbitrage
Input: {"symbol": "BTC/USDT", "buy_exchange": "binance", ...}
Output: {"action": "execute", "confidence": 0.9, ...}
Reasoning: Spread exceeds minimum threshold after fees

Example 2: Rejected arbitrage
Input: {"symbol": "ETH/USDT", "buy_exchange": "binance", ...}
Output: {"action": "skip", "confidence": 0.95, ...}
Reasoning: Net spread (0.0%) below minimum threshold (0.5%) after fees

type PromptBudget struct {
    MaxTokens        int  // Total token limit (e.g., 8000)
    SystemPrompt     int  // Reserved for system prompt (e.g., 500)
    MarketContext    int  // Reserved for market data (e.g., 1000)
    UserInstruction  int  // Reserved for user message (e.g., 500)
    SkillsAvailable  int  // Remaining for skills (6000)
}

func (pb *PromptBuilder) fitSkills(skills []*RankedSkill, budget int) []*Skill {
    fitted := []*Skill{}
    usedTokens := 0
    
    for _, ranked := range skills {
        skillTokens := estimateTokens(ranked.Skill.Content)
        if usedTokens + skillTokens <= budget {
            fitted = append(fitted, ranked.Skill)
            usedTokens += skillTokens
        } else {
            break  // Budget exhausted
        }
    }
    
    return fitted
}

---
id: "arbitrage-sumtoone"
version: "1.2.0"
---

type SkillVersion struct {
    Version     string
    Content     string
    CreatedAt   time.Time
    Deprecated  bool
    UpgradePath string  // Next version ID
}

// Load specific version
skill, err := loader.LoadVersion("arbitrage-sumtoone", "1.0.0")

// Load latest
skill, err := loader.LoadByID("arbitrage-sumtoone")

---
id: "my-custom-strategy"
name: "My Custom Trading Strategy"
version: "1.0.0"
description: "Brief description of what this skill does"
category: "trading"  # arbitrage, scalping, swing, etc.
author: "Your Name"
tags: ["custom", "experimental"]
dependencies: []  # Other skill IDs
parameters:
  param1:
    type: "float"
    description: "Parameter description"
    required: true
    default: 1.0
examples:
  - name: "Example 1"
    description: "What this example demonstrates"
    inputs:
      symbol: "BTC/USDT"
    expected:
      action: "buy"
---

# My Custom Trading Strategy

## Overview
Detailed explanation of the strategy...

## Entry Criteria
1. Condition 1
2. Condition 2
3. Condition 3

## Exit Criteria
1. Stop-loss: X%
2. Take-profit: Y%
3. Time-based: Z hours

## Risk Management
- Max position size: A%
- Max concurrent positions: B
- Daily loss limit: $C

## Example Trade