create-polyclaw-agent 0.1.0

package/src/scaffold.ts

@@ -0,0 +1,570 @@
+import { writeFileSync, mkdirSync } from 'fs';
+import { join } from 'path';
+
+/**
+ * Convert agent name to kebab-case directory name
+ */
+export function nameToDir(name: string): string {
+  return name.toLowerCase().replace(/\s+/g, '-');
+}
+
+interface ScaffoldOptions {
+  name: string;
+  dirName: string;
+  apiKey: string;
+  apiSecret: string;
+  language: 'python' | 'typescript';
+  aiProvider: 'anthropic' | 'openai' | 'none';
+  aiApiKey?: string;
+}
+
+export function scaffoldProject(options: ScaffoldOptions): string {
+  const projectDir = join(process.cwd(), options.dirName);
+  mkdirSync(projectDir, { recursive: true });
+
+  // Write .env file with credentials
+  const aiKeyLine = options.aiProvider === 'anthropic'
+    ? `\nANTHROPIC_API_KEY=${options.aiApiKey || 'your-anthropic-api-key'}\n`
+    : options.aiProvider === 'openai'
+    ? `\nOPENAI_API_KEY=${options.aiApiKey || 'your-openai-api-key'}\n`
+    : '';
+
+  const envContent = `# Polyclaw Agent: ${options.name}
+# Generated by create-polyclaw-agent
+
+POLYCLAW_API_KEY=${options.apiKey}
+POLYCLAW_API_SECRET=${options.apiSecret}
+POLYCLAW_API_URL=https://api.polyclaw.co
+${aiKeyLine}`;
+
+  writeFileSync(join(projectDir, '.env'), envContent);
+
+  if (options.language === 'python') {
+    scaffoldPython(projectDir, options);
+  } else {
+    scaffoldTypeScript(projectDir, options);
+  }
+
+  return projectDir;
+}
+
+function scaffoldPython(dir: string, options: ScaffoldOptions) {
+  // AI-specific imports and analysis function
+  const aiImport = options.aiProvider === 'anthropic'
+    ? `import anthropic`
+    : options.aiProvider === 'openai'
+    ? `import openai`
+    : '';
+
+  const aiKeyEnv = options.aiProvider === 'anthropic'
+    ? `AI_API_KEY = os.getenv("ANTHROPIC_API_KEY")`
+    : options.aiProvider === 'openai'
+    ? `AI_API_KEY = os.getenv("OPENAI_API_KEY")`
+    : '';
+
+  const aiAnalyzeFunc = options.aiProvider === 'anthropic' ? `
+def analyze_markets(markets):
+    """Use Claude to analyze prediction markets and pick the best bets."""
+    client = anthropic.Anthropic(api_key=AI_API_KEY)
+
+    # Format markets for the AI
+    market_summaries = []
+    for i, m in enumerate(markets):
+        prices = m.get("outcomePrices", [0.5, 0.5])
+        yes_price = float(prices[0]) if prices else 0.5
+        no_price = float(prices[1]) if len(prices) > 1 else 1 - yes_price
+        market_summaries.append(
+            f"{i+1}. {m.get('question', 'Unknown')}\\n"
+            f"   Yes: {yes_price:.0%} | No: {no_price:.0%} | "
+            f"Volume: \${float(m.get('volume', 0)):,.0f} | "
+            f"ID: {m.get('id', '')}"
+        )
+
+    markets_text = "\\n".join(market_summaries)
+
+    response = client.messages.create(
+        model="claude-sonnet-4-20250514",
+        max_tokens=1024,
+        messages=[{
+            "role": "user",
+            "content": f"""You are a prediction market analyst. Analyze these Polymarket markets and pick up to 3 best betting opportunities.
+
+Markets:
+{markets_text}
+
+For each pick, respond in this exact JSON format (no markdown, just raw JSON array):
+[
+  {{
+    "market_index": 1,
+    "outcome": "Yes" or "No",
+    "side": "BUY",
+    "confidence": 0.0 to 1.0,
+    "recommended_amount": 5 to 50,
+    "reasoning": "One sentence explaining why this is a good bet"
+  }}
+]
+
+Rules:
+- Pick 1-3 markets that look like good opportunities
+- Consider the current price, volume, and whether the market seems mispriced
+- Be diverse -- don't pick markets that are all about the same topic
+- Higher confidence = stronger conviction (0.5 = coin flip, 0.9 = very confident)
+- Recommended amount should reflect your confidence (higher confidence = more)
+"""
+        }]
+    )
+
+    # Parse the AI response
+    try:
+        picks = json.loads(response.content[0].text)
+        model_name = response.model
+        return picks, model_name
+    except (json.JSONDecodeError, IndexError):
+        print(f"  AI response: {response.content[0].text}")
+        return [], response.model
+` : options.aiProvider === 'openai' ? `
+def analyze_markets(markets):
+    """Use GPT to analyze prediction markets and pick the best bets."""
+    client = openai.OpenAI(api_key=AI_API_KEY)
+
+    # Format markets for the AI
+    market_summaries = []
+    for i, m in enumerate(markets):
+        prices = m.get("outcomePrices", [0.5, 0.5])
+        yes_price = float(prices[0]) if prices else 0.5
+        no_price = float(prices[1]) if len(prices) > 1 else 1 - yes_price
+        market_summaries.append(
+            f"{i+1}. {m.get('question', 'Unknown')}\\n"
+            f"   Yes: {yes_price:.0%} | No: {no_price:.0%} | "
+            f"Volume: \${float(m.get('volume', 0)):,.0f} | "
+            f"ID: {m.get('id', '')}"
+        )
+
+    markets_text = "\\n".join(market_summaries)
+
+    response = client.chat.completions.create(
+        model="gpt-4o",
+        messages=[{
+            "role": "user",
+            "content": f"""You are a prediction market analyst. Analyze these Polymarket markets and pick up to 3 best betting opportunities.
+
+Markets:
+{markets_text}
+
+For each pick, respond in this exact JSON format (no markdown, just raw JSON array):
+[
+  {{
+    "market_index": 1,
+    "outcome": "Yes" or "No",
+    "side": "BUY",
+    "confidence": 0.0 to 1.0,
+    "recommended_amount": 5 to 50,
+    "reasoning": "One sentence explaining why this is a good bet"
+  }}
+]
+
+Rules:
+- Pick 1-3 markets that look like good opportunities
+- Consider the current price, volume, and whether the market seems mispriced
+- Be diverse -- don't pick markets that are all about the same topic
+- Higher confidence = stronger conviction (0.5 = coin flip, 0.9 = very confident)
+- Recommended amount should reflect your confidence (higher confidence = more)
+"""
+        }],
+    )
+
+    # Parse the AI response
+    try:
+        picks = json.loads(response.choices[0].message.content)
+        model_name = response.model
+        return picks, model_name
+    except (json.JSONDecodeError, IndexError):
+        print(f"  AI response: {response.choices[0].message.content}")
+        return [], response.model
+` : `
+def analyze_markets(markets):
+    """Placeholder: Add your own AI logic here to analyze markets."""
+    # This is where you connect your AI model.
+    # Return a list of picks in this format:
+    # [{"market_index": 1, "outcome": "Yes", "side": "BUY",
+    #   "confidence": 0.7, "recommended_amount": 10,
+    #   "reasoning": "Your analysis here"}]
+    #
+    # Example with OpenAI:
+    #   client = openai.OpenAI()
+    #   response = client.chat.completions.create(model="gpt-4o", ...)
+    #
+    # Example with Anthropic:
+    #   client = anthropic.Anthropic()
+    #   response = client.messages.create(model="claude-sonnet-4-20250514", ...)
+
+    print("  No AI configured. Add your API key to .env and update bot.py")
+    print("  See https://polyclaw.co/docs for examples.")
+    return [], "none"
+`;
+
+  const botPy = `"""
+${options.name} - Polyclaw AI Trading Agent
+
+This bot connects to Polyclaw, fetches prediction markets from Polymarket,
+uses AI to analyze them, and submits trade proposals for you to review.
+
+Usage:
+    python3 -m venv venv && source venv/bin/activate
+    pip install -r requirements.txt
+    python bot.py
+"""
+
+import os
+import json
+import time
+import hmac
+import hashlib
+import requests
+from dotenv import load_dotenv
+${aiImport}
+
+load_dotenv()
+
+API_KEY = os.getenv("POLYCLAW_API_KEY")
+API_SECRET = os.getenv("POLYCLAW_API_SECRET")
+BASE_URL = os.getenv("POLYCLAW_API_URL", "https://api.polyclaw.co")
+${aiKeyEnv}
+
+
+class PolyclawClient:
+    def __init__(self, api_key: str, api_secret: str, base_url: str):
+        self.api_key = api_key
+        self.base_url = base_url
+        self.signing_key = hmac.new(
+            b"polyclaw-secret-salt", api_secret.encode(), hashlib.sha256
+        ).hexdigest()
+
+    def _sign(self, timestamp: str, method: str, path: str, body: str = "") -> str:
+        message = f"{timestamp}{method.upper()}{path}{body}"
+        return hmac.new(
+            self.signing_key.encode(), message.encode(), hashlib.sha256
+        ).hexdigest()
+
+    def _request(self, method: str, path: str, body: dict = None):
+        timestamp = str(int(time.time() * 1000))
+        body_str = json.dumps(body) if body else ""
+        signature = self._sign(timestamp, method, path, body_str)
+        headers = {
+            "Content-Type": "application/json",
+            "X-Polyclaw-Api-Key": self.api_key,
+            "X-Polyclaw-Signature": signature,
+            "X-Polyclaw-Timestamp": timestamp,
+        }
+        url = f"{self.base_url}{path}"
+        response = requests.request(method, url, headers=headers, json=body)
+        return response.json()
+
+    def get_markets(self, page: int = 1, limit: int = 20):
+        return self._request("GET", f"/api/markets?page={page}&limit={limit}")
+
+    def submit_proposal(self, market_id, outcome, side, recommended_amount, confidence, reasoning=None, model=None):
+        body = {"marketId": market_id, "outcome": outcome, "side": side,
+                "recommendedAmount": recommended_amount, "confidence": confidence}
+        if reasoning: body["reasoning"] = reasoning
+        if model: body["model"] = model
+        return self._request("POST", "/api/proposals", body)
+
+${aiAnalyzeFunc}
+
+def main():
+    if not API_KEY or not API_SECRET:
+        print("Error: POLYCLAW_API_KEY and POLYCLAW_API_SECRET must be set in .env")
+        return
+${options.aiProvider !== 'none' ? `
+    ai_key_name = "${options.aiProvider === 'anthropic' ? 'ANTHROPIC_API_KEY' : 'OPENAI_API_KEY'}"
+    if not AI_API_KEY:
+        print(f"Error: {ai_key_name} must be set in .env")
+        return
+` : ''}
+    client = PolyclawClient(API_KEY, API_SECRET, BASE_URL)
+    print(f"${options.name} is online!")
+    print()
+
+    # Fetch markets
+    print("Fetching markets from Polymarket...")
+    result = client.get_markets(limit=20)
+
+    if not result.get("success"):
+        print(f"Error: {result.get('error', 'Unknown error')}")
+        return
+
+    markets = result.get("data", [])
+    print(f"Found {len(markets)} markets")
+    print()
+
+    # Ask AI to analyze and pick the best bets
+    print("Asking AI to analyze markets...\\n")
+    picks, model_name = analyze_markets(markets)
+
+    if not picks:
+        print("No picks from AI. Try again later.")
+        return
+
+    print(f"  AI picked {len(picks)} market(s) (model: {model_name})\\n")
+
+    # Submit each pick as a proposal
+    for pick in picks:
+        idx = pick.get("market_index", 1) - 1
+        if idx < 0 or idx >= len(markets):
+            continue
+
+        market = markets[idx]
+        print(f"  -> {market.get('question', 'Unknown')}")
+        print(f"     {pick['side']} {pick['outcome']} | Confidence: {pick['confidence']:.0%} | Amount: \${pick['recommended_amount']}")
+        print(f"     Reasoning: {pick.get('reasoning', 'N/A')}")
+
+        proposal = client.submit_proposal(
+            market_id=market["id"],
+            outcome=pick["outcome"],
+            side=pick["side"],
+            recommended_amount=pick["recommended_amount"],
+            confidence=pick["confidence"],
+            reasoning=pick.get("reasoning"),
+            model=model_name,
+        )
+
+        if proposal.get("success"):
+            print(f"     Submitted!\\n")
+        else:
+            print(f"     Error: {proposal.get('error', 'Unknown')}\\n")
+
+    print("Done! Check your dashboard to review proposals.")
+
+
+if __name__ == "__main__":
+    main()
+`;
+
+  const aiDep = options.aiProvider === 'anthropic'
+    ? 'anthropic>=0.40.0\n'
+    : options.aiProvider === 'openai'
+    ? 'openai>=1.50.0\n'
+    : '';
+
+  const requirements = `requests>=2.31.0
+python-dotenv>=1.0.0
+${aiDep}`;
+
+  const gitignore = `.env
+__pycache__/
+*.pyc
+.venv/
+`;
+
+  writeFileSync(join(dir, 'bot.py'), botPy);
+  writeFileSync(join(dir, 'requirements.txt'), requirements);
+  writeFileSync(join(dir, '.gitignore'), gitignore);
+}
+
+function scaffoldTypeScript(dir: string, options: ScaffoldOptions) {
+  const botTs = `/**
+ * ${options.name} - Polyclaw AI Trading Agent
+ *
+ * This bot connects to Polyclaw to browse prediction markets and submit
+ * trade proposals. A human reviews and approves proposals before execution.
+ *
+ * Usage:
+ *     npm install
+ *     npx tsx bot.ts
+ */
+
+import { createHmac } from 'crypto';
+import 'dotenv/config';
+
+const API_KEY = process.env.POLYCLAW_API_KEY!;
+const API_SECRET = process.env.POLYCLAW_API_SECRET!;
+const BASE_URL = process.env.POLYCLAW_API_URL || 'https://api.polyclaw.co';
+
+class PolyclawClient {
+  private apiKey: string;
+  private signingKey: string;
+  private baseUrl: string;
+
+  constructor(config: { apiKey: string; apiSecret: string; baseUrl: string }) {
+    this.apiKey = config.apiKey;
+    this.baseUrl = config.baseUrl;
+    this.signingKey = createHmac('sha256', 'polyclaw-secret-salt')
+      .update(config.apiSecret)
+      .digest('hex');
+  }
+
+  private sign(timestamp: string, method: string, path: string, body?: string): string {
+    const message = \`\${timestamp}\${method.toUpperCase()}\${path}\${body || ''}\`;
+    return createHmac('sha256', this.signingKey).update(message).digest('hex');
+  }
+
+  private async request<T>(method: string, path: string, body?: object): Promise<T> {
+    const timestamp = Date.now().toString();
+    const bodyStr = body ? JSON.stringify(body) : '';
+    const signature = this.sign(timestamp, method, path, bodyStr);
+    const response = await fetch(\`\${this.baseUrl}\${path}\`, {
+      method,
+      headers: {
+        'Content-Type': 'application/json',
+        'X-Polyclaw-Api-Key': this.apiKey,
+        'X-Polyclaw-Signature': signature,
+        'X-Polyclaw-Timestamp': timestamp,
+      },
+      body: body ? bodyStr : undefined,
+    });
+    return response.json() as T;
+  }
+
+  async getMarkets(page = 1, limit = 20) {
+    return this.request<any>('GET', \`/api/markets?page=\${page}&limit=\${limit}\`);
+  }
+
+  async submitProposal(proposal: {
+    marketId: string;
+    outcome: string;
+    side: string;
+    recommendedAmount: number;
+    confidence: number;
+    reasoning?: string;
+    model?: string;
+  }) {
+    return this.request<any>('POST', '/api/proposals', proposal);
+  }
+}
+
+interface MarketPlay {
+  market: any;
+  outcome: string;
+  side: string;
+  confidence: number;
+  reasoning: string;
+  score: number;
+}
+
+function findBestPlay(markets: any[]): MarketPlay | null {
+  // Analyze markets and find the best opportunity.
+  // Strategy: Look for markets with strong price signals and high volume.
+  const scored: MarketPlay[] = [];
+
+  for (const market of markets) {
+    const yesPrice = parseFloat(market.outcomePrices?.[0] ?? '0.5');
+    const volume = parseFloat(market.volume ?? '0');
+
+    // Skip markets that are basically decided
+    if (yesPrice < 0.05 || yesPrice > 0.95) continue;
+
+    const edge = Math.abs(yesPrice - 0.5);
+    const liquidityScore = Math.min(volume / 500000, 1.0);
+    const score = edge * 0.6 + liquidityScore * 0.4;
+
+    let outcome: string, side: string, confidence: number, reasoning: string;
+
+    if (yesPrice < 0.40) {
+      outcome = 'Yes'; side = 'BUY';
+      confidence = Math.round((0.5 + edge) * 100) / 100;
+      reasoning = \`Yes is priced at \${(yesPrice * 100).toFixed(0)}% -- looks undervalued with $\${volume.toLocaleString()} volume\`;
+    } else if (yesPrice > 0.60) {
+      outcome = 'Yes'; side = 'BUY';
+      confidence = Math.round((0.5 + edge * 0.8) * 100) / 100;
+      reasoning = \`Market strongly favors Yes at \${(yesPrice * 100).toFixed(0)}% -- riding the momentum\`;
+    } else {
+      outcome = 'Yes'; side = 'BUY';
+      confidence = Math.round((0.5 + edge * 0.5) * 100) / 100;
+      reasoning = \`Market is contested at \${(yesPrice * 100).toFixed(0)}% -- taking a position\`;
+    }
+
+    scored.push({ market, outcome, side, confidence: Math.min(confidence, 0.95), reasoning, score });
+  }
+
+  scored.sort((a, b) => b.score - a.score);
+  return scored[0] || null;
+}
+
+async function main() {
+  if (!API_KEY || !API_SECRET) {
+    console.error('Error: POLYCLAW_API_KEY and POLYCLAW_API_SECRET must be set in .env');
+    return;
+  }
+
+  const client = new PolyclawClient({ apiKey: API_KEY, apiSecret: API_SECRET, baseUrl: BASE_URL });
+  console.log('${options.name} is online!');
+  console.log();
+
+  // Fetch markets
+  console.log('Scanning markets...');
+  const result = await client.getMarkets(1, 20);
+
+  if (!result.success) {
+    console.error(\`Error: \${result.error || 'Unknown error'}\`);
+    return;
+  }
+
+  const markets = result.data || [];
+  console.log(\`Analyzing \${markets.length} markets...\\n\`);
+
+  // Find the best play
+  const best = findBestPlay(markets);
+
+  if (!best) {
+    console.log('No good opportunities found right now.');
+    return;
+  }
+
+  const yesPrice = parseFloat(best.market.outcomePrices?.[0] ?? '0.5');
+  console.log('  Best opportunity found:');
+  console.log(\`  \${best.market.question}\`);
+  console.log(\`  Yes: \${(yesPrice * 100).toFixed(0)}% | Volume: $\${parseFloat(best.market.volume || '0').toLocaleString()}\`);
+  console.log(\`  Play: \${best.side} \${best.outcome} | Confidence: \${(best.confidence * 100).toFixed(0)}%\`);
+  console.log(\`  Reasoning: \${best.reasoning}\`);
+  console.log();
+
+  // Submit proposal
+  // Tip: Replace this logic with your own AI model for smarter predictions!
+  //   const aiResponse = await openai.chat.completions.create({ model: 'gpt-4o', ... });
+  //   const modelName = aiResponse.model; // e.g. "gpt-4o-2025-01-15"
+  console.log('Submitting proposal...');
+  const proposal = await client.submitProposal({
+    marketId: best.market.id,
+    outcome: best.outcome,
+    side: best.side,
+    recommendedAmount: 10.0,
+    confidence: best.confidence,
+    reasoning: best.reasoning,
+    model: 'your-model-here', // Replace with your AI model name
+  });
+
+  if (proposal.success) {
+    console.log('Proposal submitted! Check your dashboard to approve it.');
+  } else {
+    console.error(\`Proposal error: \${proposal.error || 'Unknown'}\`);
+  }
+}
+
+main();
+`;
+
+  const packageJson = `{
+  "name": "${options.dirName}",
+  "version": "0.1.0",
+  "private": true,
+  "type": "module",
+  "scripts": {
+    "start": "npx tsx bot.ts"
+  },
+  "dependencies": {
+    "dotenv": "^16.4.0",
+    "tsx": "^4.7.0"
+  }
+}
+`;
+
+  const gitignore = `.env
+node_modules/
+dist/
+`;
+
+  writeFileSync(join(dir, 'bot.ts'), botTs);
+  writeFileSync(join(dir, 'package.json'), packageJson);
+  writeFileSync(join(dir, '.gitignore'), gitignore);
+}

package/tsconfig.json

@@ -0,0 +1,11 @@
+{
+  "extends": "../../tsconfig.base.json",
+  "compilerOptions": {
+    "outDir": "./dist",
+    "rootDir": "./src",
+    "lib": ["ES2022"],
+    "noUnusedLocals": false,
+    "noUnusedParameters": false
+  },
+  "include": ["src/**/*"]
+}