clodds 1.2.9 → 1.4.0

package/dist/skills/bundled/feeds/SKILL.md

@@ -0,0 +1,288 @@
+---
+name: feeds
+description: "Real-time market data feeds from 8 prediction market platforms"
+emoji: "📡"
+---
+
+# Market Feeds - Complete API Reference
+
+Real-time and historical market data from Polymarket, Kalshi, Manifold, Metaculus, PredictIt, Drift, Betfair, and Smarkets.
+
+## Supported Platforms
+
+| Platform | Feed Type | Trading | Data |
+|----------|-----------|---------|------|
+| Polymarket | WebSocket + RTDS | Yes | Prices, orderbook, trades |
+| Kalshi | WebSocket | Yes | Prices, orderbook |
+| Betfair | WebSocket | Yes | Odds, volume |
+| Smarkets | WebSocket | Yes | Odds, volume |
+| Drift | REST | Yes | Prices, funding |
+| Manifold | WebSocket | Read-only | Prices, comments |
+| Metaculus | REST | Read-only | Forecasts |
+| PredictIt | REST | Read-only | Prices |
+
+---
+
+## Chat Commands
+
+### Search Markets
+
+```
+/feed search "trump"                        # Search all platforms
+/feed search "election" --platform poly     # Search specific platform
+/feed search "fed rate" --limit 20          # Limit results
+```
+
+### Get Prices
+
+```
+/feed price poly <market-id>                # Get current price
+/feed price kalshi TRUMP-WIN                # Kalshi market
+/feed prices "trump"                        # Prices for all matching markets
+```
+
+### Orderbook
+
+```
+/feed orderbook poly <market-id>            # Get orderbook
+/feed orderbook poly <market-id> --depth 10 # Limit depth
+```
+
+### Subscribe (Real-time)
+
+```
+/feed subscribe poly <market-id>            # Subscribe to price updates
+/feed unsubscribe poly <market-id>          # Unsubscribe
+/feed subscriptions                         # List active subscriptions
+```
+
+### News
+
+```
+/feed news "trump"                          # Get news for topic
+/feed news <market-id>                      # News for specific market
+/feed news --recent 10                      # Last 10 news items
+```
+
+### Edge Analysis
+
+```
+/feed edge poly <market-id>                 # Analyze edge vs models
+/feed kelly poly <market-id> --prob 0.55    # Calculate Kelly fraction
+```
+
+---
+
+## TypeScript API Reference
+
+### Create Feed Manager
+
+```typescript
+import { createFeedManager } from 'clodds/feeds';
+
+const feeds = createFeedManager({
+  platforms: ['polymarket', 'kalshi', 'manifold', 'betfair'],
+
+  // Enable real-time
+  enableRealtime: true,
+
+  // Platform credentials (optional for read-only)
+  polymarket: { apiKey },
+  kalshi: { apiKey },
+  betfair: { appKey, sessionToken },
+});
+```
+
+### Search Markets
+
+```typescript
+// Search across all platforms
+const results = await feeds.searchMarkets('trump election', {
+  platforms: ['polymarket', 'kalshi'],
+  limit: 20,
+  sortBy: 'volume',
+});
+
+for (const market of results) {
+  console.log(`[${market.platform}] ${market.question}`);
+  console.log(`  Price: ${market.price}`);
+  console.log(`  Volume: $${market.volume.toLocaleString()}`);
+}
+```
+
+### Get Single Market
+
+```typescript
+// Get specific market
+const market = await feeds.getMarket('polymarket', 'market-123');
+
+console.log(`Question: ${market.question}`);
+console.log(`YES: ${market.yesPrice} / NO: ${market.noPrice}`);
+console.log(`Volume: $${market.volume.toLocaleString()}`);
+console.log(`End date: ${market.endDate}`);
+```
+
+### Get Price
+
+```typescript
+// Get current price
+const price = await feeds.getPrice('polymarket', 'market-123');
+
+console.log(`YES: ${price.yes}`);
+console.log(`NO: ${price.no}`);
+console.log(`Spread: ${price.spread}`);
+console.log(`Updated: ${price.timestamp}`);
+```
+
+### Get Orderbook
+
+```typescript
+// Get orderbook
+const orderbook = await feeds.getOrderbook('polymarket', 'market-123', {
+  depth: 10,
+});
+
+console.log('Bids (YES):');
+for (const bid of orderbook.bids) {
+  console.log(`  ${bid.price}: $${bid.size}`);
+}
+
+console.log('Asks (YES):');
+for (const ask of orderbook.asks) {
+  console.log(`  ${ask.price}: $${ask.size}`);
+}
+```
+
+### Subscribe to Real-time Updates
+
+```typescript
+// Subscribe to price updates
+const subscription = await feeds.subscribePrice('polymarket', 'market-123');
+
+subscription.on('price', (update) => {
+  console.log(`Price update: YES=${update.yes}, NO=${update.no}`);
+});
+
+subscription.on('trade', (trade) => {
+  console.log(`Trade: ${trade.side} ${trade.size} @ ${trade.price}`);
+});
+
+// Unsubscribe
+await subscription.unsubscribe();
+```
+
+### News
+
+```typescript
+// Get recent news
+const news = await feeds.getRecentNews('trump', { limit: 10 });
+
+for (const article of news) {
+  console.log(`[${article.source}] ${article.title}`);
+  console.log(`  ${article.summary}`);
+  console.log(`  ${article.url}`);
+}
+
+// Search news
+const searchResults = await feeds.searchNews('federal reserve', {
+  from: '2024-01-01',
+  sources: ['reuters', 'bloomberg'],
+});
+```
+
+### Edge Analysis
+
+```typescript
+// Analyze edge vs external models
+const edge = await feeds.analyzeEdge('polymarket', 'market-123');
+
+console.log(`Market price: ${edge.marketPrice}`);
+console.log(`Model estimates:`);
+for (const model of edge.models) {
+  console.log(`  ${model.name}: ${model.estimate}`);
+  console.log(`    Edge: ${model.edge > 0 ? '+' : ''}${model.edge.toFixed(1)}%`);
+}
+console.log(`Consensus edge: ${edge.consensusEdge.toFixed(1)}%`);
+```
+
+### Kelly Criterion
+
+```typescript
+// Calculate optimal position size
+const kelly = await feeds.calculateKelly({
+  platform: 'polymarket',
+  marketId: 'market-123',
+  estimatedProbability: 0.55,  // Your estimate
+  bankroll: 10000,             // Your bankroll
+  kellyFraction: 0.5,          // Half-Kelly for safety
+});
+
+console.log(`Market price: ${kelly.marketPrice}`);
+console.log(`Your estimate: ${kelly.estimatedProb}`);
+console.log(`Edge: ${kelly.edge.toFixed(1)}%`);
+console.log(`Full Kelly: ${kelly.fullKelly.toFixed(1)}%`);
+console.log(`Recommended size: $${kelly.recommendedSize}`);
+```
+
+---
+
+## Platform-Specific Features
+
+### Polymarket RTDS (Real-time Data Service)
+
+```typescript
+// Connect to RTDS for ultra-low-latency updates
+const rtds = await feeds.connectRTDS('polymarket');
+
+rtds.on('tick', (tick) => {
+  console.log(`${tick.market}: ${tick.price} (${tick.side})`);
+});
+
+rtds.subscribe(['market-123', 'market-456']);
+```
+
+### Betfair Odds
+
+```typescript
+// Get Betfair odds
+const odds = await feeds.getBetfairOdds('event-123');
+
+for (const runner of odds.runners) {
+  console.log(`${runner.name}: ${runner.backOdds} / ${runner.layOdds}`);
+}
+```
+
+### Metaculus Forecasts
+
+```typescript
+// Get Metaculus community forecast
+const forecast = await feeds.getMetaculusForecast('question-123');
+
+console.log(`Community median: ${forecast.median}`);
+console.log(`25th percentile: ${forecast.q25}`);
+console.log(`75th percentile: ${forecast.q75}`);
+console.log(`Forecasters: ${forecast.forecasterCount}`);
+```
+
+---
+
+## Data Refresh Rates
+
+| Platform | REST | WebSocket |
+|----------|------|-----------|
+| Polymarket | 5s | Real-time |
+| Kalshi | 10s | Real-time |
+| Betfair | 1s | Real-time |
+| Manifold | 30s | Real-time |
+| Metaculus | 60s | N/A |
+| PredictIt | 30s | N/A |
+
+---
+
+## Best Practices
+
+1. **Use WebSocket** for real-time trading decisions
+2. **Cache responses** for non-time-sensitive queries
+3. **Respect rate limits** - batch requests when possible
+4. **Subscribe selectively** - only to markets you need
+5. **Handle reconnections** - WebSocket connections can drop

package/dist/skills/bundled/harden/SKILL.md

@@ -0,0 +1,74 @@
+---
+name: harden
+description: VPS security auditing and hardening
+emoji: "🔒"
+commands:
+  - /harden
+---
+
+# VPS Hardening
+
+Security auditing and automated hardening for remote servers.
+
+## Commands
+
+### `/harden audit <host>`
+Run security audit against a server. Checks:
+- System updates
+- Auto-updates configuration
+- SSH root login status
+- Password authentication
+- Firewall status
+- Fail2ban status
+- System uptime
+- Listening services
+- Sudo user configuration
+
+### `/harden fix <host>`
+Apply safe fixes that won't lock you out:
+- Install system updates
+- Enable unattended-upgrades
+- Configure UFW firewall
+- Install and enable fail2ban
+- Set SSH MaxAuthTries
+
+### `/harden emergency <host>`
+Quick 10-minute hardening for new servers:
+- Full system update
+- Firewall setup
+- Fail2ban installation
+- Root password lock
+
+### `/harden report <host>`
+Generate markdown security report.
+
+## Options
+
+| Option | Description |
+|--------|-------------|
+| `--user=NAME` | SSH user (default: root) |
+| `--dry-run` | Preview changes without applying |
+
+## Examples
+
+```
+/harden audit 192.168.1.100
+/harden fix myserver.com --user=admin
+/harden emergency vps.example.com --dry-run
+/harden report server.io > security-report.md
+```
+
+## Security Checks
+
+| Check | Pass Criteria |
+|-------|---------------|
+| System Updates | 0 pending updates |
+| Auto Updates | unattended-upgrades installed |
+| Root Login | PermitRootLogin no |
+| Password Auth | PasswordAuthentication no |
+| Firewall | UFW active or iptables configured |
+| Fail2ban | Service running |
+| Uptime | < 90 days |
+| Services | < 10 listening ports |
+| Sudo Users | At least one non-root sudo user |
+| MaxAuthTries | Set to 3 or less |

package/dist/skills/bundled/history/SKILL.md

@@ -0,0 +1,257 @@
+---
+name: history
+description: "Trade history tracking, sync, and performance analytics"
+emoji: "📊"
+gates:
+  envs:
+    anyOf:
+      - POLY_API_KEY
+      - KALSHI_API_KEY
+---
+
+# Trade History - Complete API Reference
+
+Fetch, sync, and analyze trade history from Polymarket and Kalshi with detailed performance metrics.
+
+---
+
+## Chat Commands
+
+### Fetch & Sync
+
+```
+/history fetch                              # Fetch all trades from APIs
+/history fetch poly                         # Fetch Polymarket only
+/history fetch --from 2024-01-01            # From specific date
+/history sync                               # Sync to local database
+```
+
+### View History
+
+```
+/history list                               # Recent trades
+/history list --limit 50                    # Last 50 trades
+/history list --platform poly               # Polymarket only
+/history list --market <id>                 # Specific market
+```
+
+### Statistics
+
+```
+/history stats                              # Overall statistics
+/history stats --period 30d                 # Last 30 days
+/history stats --platform kalshi            # Platform-specific
+```
+
+### P&L Analysis
+
+```
+/history daily-pnl                          # Daily P&L
+/history weekly-pnl                         # Weekly P&L
+/history monthly-pnl                        # Monthly P&L
+/history by-market                          # P&L by market category
+```
+
+### Export
+
+```
+/history export                             # Export to CSV
+/history export --format json               # Export as JSON
+/history export --from 2024-01-01           # Date range
+```
+
+### Filtering
+
+```
+/history filter --side buy                  # Only buys
+/history filter --pnl positive              # Only winners
+/history filter --pnl negative              # Only losers
+/history filter --min-size 100              # Min $100 trades
+```
+
+---
+
+## TypeScript API Reference
+
+### Create History Service
+
+```typescript
+import { createTradeHistoryService } from 'clodds/history';
+
+const history = createTradeHistoryService({
+  polymarket: {
+    apiKey: process.env.POLY_API_KEY,
+    address: process.env.POLY_ADDRESS,
+  },
+  kalshi: {
+    apiKey: process.env.KALSHI_API_KEY,
+  },
+
+  // Local storage
+  dbPath: './trade-history.db',
+});
+```
+
+### Fetch Trades from APIs
+
+```typescript
+// Fetch all trades from exchange APIs
+const trades = await history.fetchTrades({
+  platforms: ['polymarket', 'kalshi'],
+  from: '2024-01-01',
+});
+
+console.log(`Fetched ${trades.length} trades`);
+
+// Fetch from specific platform
+const polyTrades = await history.fetchTrades({
+  platforms: ['polymarket'],
+  limit: 100,
+});
+```
+
+### Sync to Database
+
+```typescript
+// Sync fetched trades to local database
+await history.syncToDatabase();
+
+console.log('Trades synced to database');
+```
+
+### Get Trades
+
+```typescript
+// Get trades from local storage
+const trades = await history.getTrades({
+  platform: 'polymarket',
+  from: '2024-01-01',
+  to: '2024-12-31',
+  limit: 100,
+});
+
+for (const trade of trades) {
+  console.log(`${trade.timestamp}: ${trade.side} ${trade.market}`);
+  console.log(`  Size: $${trade.size}`);
+  console.log(`  Price: ${trade.price}`);
+  console.log(`  P&L: $${trade.pnl?.toFixed(2) || 'open'}`);
+}
+```
+
+### Statistics
+
+```typescript
+// Get comprehensive statistics
+const stats = await history.getStats({
+  period: '30d',
+  platform: 'polymarket',
+});
+
+console.log(`=== Trading Statistics (30d) ===`);
+console.log(`Total trades: ${stats.totalTrades}`);
+console.log(`Winning trades: ${stats.winningTrades}`);
+console.log(`Losing trades: ${stats.losingTrades}`);
+console.log(`Win rate: ${(stats.winRate * 100).toFixed(1)}%`);
+console.log(`\nP&L:`);
+console.log(`  Total: $${stats.totalPnl.toLocaleString()}`);
+console.log(`  Gross profit: $${stats.grossProfit.toLocaleString()}`);
+console.log(`  Gross loss: $${stats.grossLoss.toLocaleString()}`);
+console.log(`  Profit factor: ${stats.profitFactor.toFixed(2)}`);
+console.log(`\nTrade sizes:`);
+console.log(`  Average: $${stats.avgTradeSize.toFixed(2)}`);
+console.log(`  Largest win: $${stats.largestWin.toFixed(2)}`);
+console.log(`  Largest loss: $${stats.largestLoss.toFixed(2)}`);
+console.log(`\nRisk metrics:`);
+console.log(`  Sharpe ratio: ${stats.sharpeRatio.toFixed(2)}`);
+console.log(`  Max drawdown: ${(stats.maxDrawdown * 100).toFixed(1)}%`);
+```
+
+### Daily P&L
+
+```typescript
+// Get daily P&L breakdown
+const dailyPnl = await history.getDailyPnL({
+  days: 30,
+  platform: 'polymarket',
+});
+
+console.log('=== Daily P&L ===');
+for (const day of dailyPnl) {
+  const sign = day.pnl >= 0 ? '+' : '';
+  const bar = day.pnl >= 0
+    ? '█'.repeat(Math.min(Math.floor(day.pnl / 10), 20))
+    : '▓'.repeat(Math.min(Math.floor(Math.abs(day.pnl) / 10), 20));
+
+  console.log(`${day.date} | ${sign}$${day.pnl.toFixed(2).padStart(8)} | ${bar}`);
+}
+```
+
+### Performance by Market
+
+```typescript
+// Get performance breakdown by market category
+const byMarket = await history.getPerformanceByMarket({
+  period: '30d',
+});
+
+console.log('=== Performance by Market Category ===');
+for (const [category, data] of Object.entries(byMarket)) {
+  console.log(`\n${category}:`);
+  console.log(`  Trades: ${data.trades}`);
+  console.log(`  Win rate: ${(data.winRate * 100).toFixed(1)}%`);
+  console.log(`  P&L: $${data.pnl.toLocaleString()}`);
+  console.log(`  Avg trade: $${data.avgTrade.toFixed(2)}`);
+}
+```
+
+### Export
+
+```typescript
+// Export to CSV
+await history.exportCsv({
+  path: './trades.csv',
+  from: '2024-01-01',
+  to: '2024-12-31',
+  columns: ['timestamp', 'platform', 'market', 'side', 'size', 'price', 'pnl'],
+});
+
+// Export to JSON
+const json = await history.exportJson({
+  from: '2024-01-01',
+});
+```
+
+---
+
+## Database Schema
+
+```sql
+CREATE TABLE trades (
+  id TEXT PRIMARY KEY,
+  platform TEXT NOT NULL,
+  market_id TEXT NOT NULL,
+  market_question TEXT,
+  side TEXT NOT NULL,  -- 'buy' or 'sell'
+  outcome TEXT,        -- 'YES' or 'NO'
+  size REAL NOT NULL,
+  price REAL NOT NULL,
+  fee REAL DEFAULT 0,
+  pnl REAL,
+  timestamp INTEGER NOT NULL,
+  created_at INTEGER DEFAULT (strftime('%s', 'now'))
+);
+
+CREATE INDEX idx_trades_platform ON trades(platform);
+CREATE INDEX idx_trades_timestamp ON trades(timestamp);
+CREATE INDEX idx_trades_market ON trades(market_id);
+```
+
+---
+
+## Best Practices
+
+1. **Sync regularly** - Keep local database up to date
+2. **Export backups** - Periodically export to CSV
+3. **Review weekly** - Analyze performance patterns
+4. **Track by category** - Identify strong/weak areas
+5. **Monitor drawdown** - Set alerts for max drawdown