@farazirfan/costar-server-executor 1.7.19 → 1.7.21

package/skills/coinbase/references/order-types.md

@@ -0,0 +1,150 @@
+# Coinbase Order Types — Complete Reference
+
+> Agent-editable. Update with patterns and quirks discovered from real trading.
+> Last updated: Initial version
+
+## Order Configuration Keys
+
+Every order uses `order_configuration` with exactly ONE of these keys:
+
+### Market Orders (Immediate Execution)
+
+**`market_market_ioc`** — Market Immediate-or-Cancel (most common)
+```typescript
+// Buy by dollar amount (quote currency)
+order_configuration: {
+  market_market_ioc: { quote_size: '100.00' }  // spend $100
+}
+
+// Sell by quantity (base currency)
+order_configuration: {
+  market_market_ioc: { base_size: '0.5' }  // sell 0.5 ETH
+}
+```
+- Use `quote_size` for BUY (how much USD to spend)
+- Use `base_size` for SELL (how many units to sell)
+- Can use `base_size` for BUY too (buy exact amount of asset)
+
+### Limit Orders
+
+**`limit_limit_gtc`** — Good Till Cancelled
+```typescript
+order_configuration: {
+  limit_limit_gtc: {
+    base_size: '0.001',
+    limit_price: '95000.00',
+    post_only: false,  // true = maker only (lower fees)
+  }
+}
+```
+
+**`limit_limit_gtd`** — Good Till Date (expires)
+```typescript
+order_configuration: {
+  limit_limit_gtd: {
+    base_size: '0.001',
+    limit_price: '95000.00',
+    end_time: '2026-03-01T00:00:00Z',  // RFC3339
+    post_only: false,
+  }
+}
+```
+
+**`limit_limit_fok`** — Fill or Kill (all or nothing)
+```typescript
+order_configuration: {
+  limit_limit_fok: {
+    base_size: '0.001',
+    limit_price: '95000.00',
+  }
+}
+```
+
+### Stop-Limit Orders
+
+**`stop_limit_stop_limit_gtc`** — Stop-Limit GTC
+```typescript
+// Stop-loss sell: triggers when price drops to stop_price
+order_configuration: {
+  stop_limit_stop_limit_gtc: {
+    base_size: '0.001',
+    limit_price: '93000.00',    // limit order price after trigger
+    stop_price: '94000.00',     // trigger price
+    stop_direction: 'STOP_DIRECTION_STOP_DOWN',  // triggers when price goes DOWN
+  }
+}
+
+// Stop-buy: triggers when price rises to stop_price
+order_configuration: {
+  stop_limit_stop_limit_gtc: {
+    base_size: '0.001',
+    limit_price: '101000.00',
+    stop_price: '100000.00',
+    stop_direction: 'STOP_DIRECTION_STOP_UP',
+  }
+}
+```
+
+**`stop_limit_stop_limit_gtd`** — Stop-Limit with expiry (same fields + `end_time`)
+
+### Bracket Orders (Entry + Take-Profit + Stop-Loss)
+
+**`trigger_bracket_gtc`** — Bracket GTC
+```typescript
+order_configuration: {
+  trigger_bracket_gtc: {
+    base_size: '0.001',
+    limit_price: '105000.00',        // take-profit price
+    stop_trigger_price: '93000.00',  // stop-loss trigger
+  }
+}
+```
+
+**`trigger_bracket_gtd`** — Bracket with expiry (same fields + `end_time`)
+
+### Smart Order Router
+
+**`sor_limit_ioc`** — SOR Limit IOC (routes across venues for best price)
+```typescript
+order_configuration: {
+  sor_limit_ioc: {
+    base_size: '0.001',
+    limit_price: '100000.00',
+  }
+}
+```
+
+## Stop Direction Values
+
+| Value | Meaning | Use Case |
+|-------|---------|----------|
+| `STOP_DIRECTION_STOP_DOWN` | Trigger when price drops below stop | Stop-loss for long positions |
+| `STOP_DIRECTION_STOP_UP` | Trigger when price rises above stop | Stop-loss for shorts, breakout buys |
+
+## Order Sides
+
+| Side | Meaning |
+|------|---------|
+| `BUY` | Buy base currency, spend quote currency |
+| `SELL` | Sell base currency, receive quote currency |
+
+## Order Statuses
+
+| Status | Meaning |
+|--------|---------|
+| `PENDING` | Order received, not yet on book |
+| `OPEN` | Active on order book |
+| `FILLED` | Completely filled |
+| `CANCELLED` | Cancelled by user or system |
+| `EXPIRED` | GTD order expired |
+| `FAILED` | Order rejected |
+| `UNKNOWN_ORDER_STATUS` | Unknown |
+
+## Key Gotchas
+
+1. **All numeric values must be strings**: `"100.00"` not `100`
+2. **Market buys use `quote_size`** (dollar amount), **market sells use `base_size`** (quantity)
+3. **HTTP 200 doesn't mean success**: Always check `response.success === true`
+4. **Duplicate `client_order_id`**: Returns existing order, doesn't create new one
+5. **`post_only: true`**: Ensures you're a maker (lower fees) but order may be rejected if it would immediately fill
+6. **Minimum order sizes**: Vary by product. Check `base_min_size` in product details.

package/skills/coinbase/references/products.md

@@ -0,0 +1,93 @@
+# Coinbase Trading Products
+
+> Agent-editable. Add notes about products as you trade them.
+> Last updated: Initial version
+
+## Product ID Format
+
+Always `{BASE}-{QUOTE}`, e.g. `BTC-USD`, `ETH-USD`
+
+## Common Trading Pairs
+
+### Major Crypto (High Liquidity)
+
+| Product ID | Base | Quote | Notes |
+|-----------|------|-------|-------|
+| `BTC-USD` | Bitcoin | USD | Most liquid, tightest spreads |
+| `ETH-USD` | Ethereum | USD | Second most liquid |
+| `SOL-USD` | Solana | USD | High volatility |
+| `DOGE-USD` | Dogecoin | USD | Meme coin, volatile |
+| `XRP-USD` | Ripple | USD | |
+| `ADA-USD` | Cardano | USD | |
+| `AVAX-USD` | Avalanche | USD | |
+| `LINK-USD` | Chainlink | USD | |
+| `DOT-USD` | Polkadot | USD | |
+| `MATIC-USD` | Polygon | USD | |
+| `UNI-USD` | Uniswap | USD | |
+| `LTC-USD` | Litecoin | USD | |
+
+### Stablecoins
+
+| Product ID | Base | Quote | Notes |
+|-----------|------|-------|-------|
+| `USDT-USD` | Tether | USD | |
+| `BTC-USDT` | Bitcoin | Tether | |
+| `ETH-USDT` | Ethereum | Tether | |
+
+### Crypto-to-Crypto
+
+| Product ID | Base | Quote | Notes |
+|-----------|------|-------|-------|
+| `ETH-BTC` | Ethereum | Bitcoin | ETH/BTC ratio trading |
+| `SOL-BTC` | Solana | Bitcoin | |
+
+## Discovering Products
+
+Always verify product availability before trading:
+
+```typescript
+// List all products
+const products = await client.getProducts({});
+
+// Filter for USD pairs
+const usdPairs = products.products.filter(p => p.quote_currency_id === 'USD');
+
+// Get specific product details
+const btc = await client.getProduct({ product_id: 'BTC-USD' });
+// Returns: price, volume_24h, price_percentage_change_24h,
+//          base_min_size, base_max_size, quote_min_size, quote_increment, etc.
+```
+
+## Key Product Fields
+
+| Field | Description | Important For |
+|-------|-------------|---------------|
+| `price` | Current price | All orders |
+| `base_min_size` | Minimum base order size | Validating order size |
+| `base_max_size` | Maximum base order size | Validating order size |
+| `quote_min_size` | Minimum quote order size | Market buy minimum |
+| `quote_increment` | Price precision | Formatting limit prices |
+| `base_increment` | Size precision | Formatting order sizes |
+| `status` | Product trading status | Check before ordering |
+| `trading_disabled` | Whether trading is halted | Check before ordering |
+| `volume_24h` | 24-hour trading volume | Liquidity assessment |
+
+## Pre-Trade Checklist
+
+Before placing any order on a product:
+
+1. **Verify product exists**: `getProduct({ product_id })`
+2. **Check `trading_disabled !== true`**
+3. **Check `status === 'online'`**
+4. **Verify order size >= `base_min_size`** (for base_size orders)
+5. **Verify order size >= `quote_min_size`** (for quote_size orders)
+6. **Round to correct precision** using `base_increment` / `quote_increment`
+
+## Product Notes from Trading
+
+*(Add observations as you trade different pairs)*
+<!--
+- [DATE] PRODUCT: observation about spreads, liquidity, or behavior
+Example:
+- [2026-02-14] BTC-USD: Spreads widen significantly during weekends. Avoid large market orders Sat/Sun.
+-->

package/skills/coinbase/scripts/coinbase-trade.ts

@@ -0,0 +1,274 @@
+#!/usr/bin/env npx tsx
+/**
+ * Coinbase Trade Helper — CLI tool for common Coinbase operations.
+ * Agent can use this directly or create new scripts based on this pattern.
+ *
+ * Usage:
+ *   npx tsx scripts/coinbase-trade.ts balances
+ *   npx tsx scripts/coinbase-trade.ts price BTC-USD
+ *   npx tsx scripts/coinbase-trade.ts preview buy BTC-USD 100
+ *   npx tsx scripts/coinbase-trade.ts market-buy BTC-USD 100
+ *   npx tsx scripts/coinbase-trade.ts market-sell BTC-USD 0.001
+ *   npx tsx scripts/coinbase-trade.ts limit-buy BTC-USD 0.001 95000
+ *   npx tsx scripts/coinbase-trade.ts limit-sell BTC-USD 0.001 105000
+ *   npx tsx scripts/coinbase-trade.ts status <order-id>
+ *   npx tsx scripts/coinbase-trade.ts cancel <order-id>
+ *   npx tsx scripts/coinbase-trade.ts open-orders
+ *   npx tsx scripts/coinbase-trade.ts products
+ *   npx tsx scripts/coinbase-trade.ts fees
+ *
+ * Requires: COINBASE_API_KEY and COINBASE_API_SECRET env vars
+ * Install:  npm install coinbase-api
+ */
+
+import { CBAdvancedTradeClient } from 'coinbase-api';
+import * as crypto from 'crypto';
+
+// --- Init Client ---
+
+const apiKey = process.env.COINBASE_API_KEY;
+const apiSecret = process.env.COINBASE_API_SECRET;
+
+if (!apiKey || !apiSecret) {
+  console.error('ERROR: COINBASE_API_KEY and COINBASE_API_SECRET must be set');
+  process.exit(1);
+}
+
+const client = new CBAdvancedTradeClient({
+  apiKey,
+  apiSecret,
+});
+
+// --- Commands ---
+
+const [command, ...args] = process.argv.slice(2);
+
+async function run() {
+  switch (command) {
+    case 'balances':
+      return showBalances();
+    case 'price':
+      return showPrice(args[0]);
+    case 'preview':
+      return previewOrder(args[0], args[1], args[2]);
+    case 'market-buy':
+      return marketBuy(args[0], args[1]);
+    case 'market-sell':
+      return marketSell(args[0], args[1]);
+    case 'limit-buy':
+      return limitBuy(args[0], args[1], args[2]);
+    case 'limit-sell':
+      return limitSell(args[0], args[1], args[2]);
+    case 'status':
+      return orderStatus(args[0]);
+    case 'cancel':
+      return cancelOrder(args[0]);
+    case 'open-orders':
+      return openOrders();
+    case 'products':
+      return listProducts();
+    case 'fees':
+      return showFees();
+    default:
+      console.log(`Unknown command: ${command}`);
+      console.log('Commands: balances, price, preview, market-buy, market-sell, limit-buy, limit-sell, status, cancel, open-orders, products, fees');
+      process.exit(1);
+  }
+}
+
+async function showBalances() {
+  const accounts = await client.getAccounts();
+  const nonZero = accounts.accounts.filter(
+    (a: any) => parseFloat(a.available_balance.value) > 0 || parseFloat(a.hold?.value || '0') > 0
+  );
+  console.log(JSON.stringify(nonZero.map((a: any) => ({
+    currency: a.currency,
+    available: a.available_balance.value,
+    hold: a.hold?.value || '0',
+  })), null, 2));
+}
+
+async function showPrice(productId: string) {
+  if (!productId) { console.error('Usage: price <product-id>'); process.exit(1); }
+  const product = await client.getProduct({ product_id: productId });
+  const spread = await client.getBestBidAsk({ product_ids: [productId] });
+  console.log(JSON.stringify({
+    product_id: productId,
+    price: product.price,
+    change_24h: product.price_percentage_change_24h + '%',
+    volume_24h: product.volume_24h,
+    bid: spread.pricebooks?.[0]?.bids?.[0]?.price,
+    ask: spread.pricebooks?.[0]?.asks?.[0]?.price,
+    base_min_size: product.base_min_size,
+    quote_min_size: product.quote_min_size,
+  }, null, 2));
+}
+
+async function previewOrder(side: string, productId: string, amount: string) {
+  if (!side || !productId || !amount) {
+    console.error('Usage: preview <buy|sell> <product-id> <amount>');
+    process.exit(1);
+  }
+  const isBuy = side.toUpperCase() === 'BUY';
+  const preview = await client.previewOrder({
+    product_id: productId,
+    side: isBuy ? 'BUY' : 'SELL',
+    order_configuration: {
+      market_market_ioc: isBuy
+        ? { quote_size: amount }
+        : { base_size: amount },
+    },
+  });
+  console.log(JSON.stringify(preview, null, 2));
+}
+
+async function marketBuy(productId: string, quoteSize: string) {
+  if (!productId || !quoteSize) {
+    console.error('Usage: market-buy <product-id> <usd-amount>');
+    process.exit(1);
+  }
+  const order = await client.submitOrder({
+    client_order_id: crypto.randomUUID(),
+    product_id: productId,
+    side: 'BUY',
+    order_configuration: {
+      market_market_ioc: { quote_size: quoteSize },
+    },
+  });
+  console.log(JSON.stringify(order, null, 2));
+  if (order.success) {
+    const status = await client.getOrder({
+      order_id: order.success_response.order_id,
+    });
+    console.log('\nFill details:');
+    console.log(JSON.stringify({
+      order_id: status.order.order_id,
+      status: status.order.status,
+      filled_size: status.order.filled_size,
+      filled_value: status.order.filled_value,
+      average_filled_price: status.order.average_filled_price,
+      total_fees: status.order.total_fees,
+    }, null, 2));
+  }
+}
+
+async function marketSell(productId: string, baseSize: string) {
+  if (!productId || !baseSize) {
+    console.error('Usage: market-sell <product-id> <base-amount>');
+    process.exit(1);
+  }
+  const order = await client.submitOrder({
+    client_order_id: crypto.randomUUID(),
+    product_id: productId,
+    side: 'SELL',
+    order_configuration: {
+      market_market_ioc: { base_size: baseSize },
+    },
+  });
+  console.log(JSON.stringify(order, null, 2));
+  if (order.success) {
+    const status = await client.getOrder({
+      order_id: order.success_response.order_id,
+    });
+    console.log('\nFill details:');
+    console.log(JSON.stringify({
+      order_id: status.order.order_id,
+      status: status.order.status,
+      filled_size: status.order.filled_size,
+      filled_value: status.order.filled_value,
+      average_filled_price: status.order.average_filled_price,
+      total_fees: status.order.total_fees,
+    }, null, 2));
+  }
+}
+
+async function limitBuy(productId: string, baseSize: string, limitPrice: string) {
+  if (!productId || !baseSize || !limitPrice) {
+    console.error('Usage: limit-buy <product-id> <base-size> <limit-price>');
+    process.exit(1);
+  }
+  const order = await client.submitOrder({
+    client_order_id: crypto.randomUUID(),
+    product_id: productId,
+    side: 'BUY',
+    order_configuration: {
+      limit_limit_gtc: {
+        base_size: baseSize,
+        limit_price: limitPrice,
+        post_only: false,
+      },
+    },
+  });
+  console.log(JSON.stringify(order, null, 2));
+}
+
+async function limitSell(productId: string, baseSize: string, limitPrice: string) {
+  if (!productId || !baseSize || !limitPrice) {
+    console.error('Usage: limit-sell <product-id> <base-size> <limit-price>');
+    process.exit(1);
+  }
+  const order = await client.submitOrder({
+    client_order_id: crypto.randomUUID(),
+    product_id: productId,
+    side: 'SELL',
+    order_configuration: {
+      limit_limit_gtc: {
+        base_size: baseSize,
+        limit_price: limitPrice,
+        post_only: false,
+      },
+    },
+  });
+  console.log(JSON.stringify(order, null, 2));
+}
+
+async function orderStatus(orderId: string) {
+  if (!orderId) { console.error('Usage: status <order-id>'); process.exit(1); }
+  const order = await client.getOrder({ order_id: orderId });
+  console.log(JSON.stringify(order, null, 2));
+}
+
+async function cancelOrder(orderId: string) {
+  if (!orderId) { console.error('Usage: cancel <order-id>'); process.exit(1); }
+  const result = await client.cancelOrders({ order_ids: [orderId] });
+  console.log(JSON.stringify(result, null, 2));
+}
+
+async function openOrders() {
+  const orders = await client.getOrders({ order_status: ['OPEN', 'PENDING'] });
+  console.log(JSON.stringify(orders.orders?.map((o: any) => ({
+    order_id: o.order_id,
+    product_id: o.product_id,
+    side: o.side,
+    status: o.status,
+    created_time: o.created_time,
+    order_configuration: o.order_configuration,
+  })) || [], null, 2));
+}
+
+async function listProducts() {
+  const products = await client.getProducts({});
+  const usdPairs = products.products
+    .filter((p: any) => p.quote_currency_id === 'USD' && !p.trading_disabled)
+    .sort((a: any, b: any) => parseFloat(b.volume_24h || '0') - parseFloat(a.volume_24h || '0'))
+    .slice(0, 30);
+  console.log(JSON.stringify(usdPairs.map((p: any) => ({
+    product_id: p.product_id,
+    price: p.price,
+    change_24h: p.price_percentage_change_24h + '%',
+    volume_24h: p.volume_24h,
+    base_min_size: p.base_min_size,
+    quote_min_size: p.quote_min_size,
+  })), null, 2));
+}
+
+async function showFees() {
+  const summary = await client.getTransactionSummary({});
+  console.log(JSON.stringify(summary, null, 2));
+}
+
+// --- Run ---
+run().catch((err) => {
+  console.error('Error:', err.message || err);
+  process.exit(1);
+});

package/skills/trading/SKILL.md

@@ -54,7 +54,7 @@ Task Progress:
 - [ ] Step 5: Choose strategy based on regime + learnings
 - [ ] Step 6: Calculate position size and risk parameters
 - [ ] Step 7: Define entry, stop-loss, and take-profit
-- [ ] Step 8: Execute trade (present plan to user first)
+- [ ] Step 8: Execute trade
 - [ ] Step 9: Monitor and manage position
 - [ ] Step 10: Log trade and UPDATE LEARNING.md
 ```
@@ -135,9 +135,7 @@ Every trade MUST have BEFORE entry:
 
 ### Step 8: Execute
 
-Present the trade plan to the user with: asset, direction, entry/stop/target, position size, dollar risk, R:R ratio, rationale, confidence level.
-
-**Always wait for user confirmation before executing.**
+Execute the trade based on your analysis. Log the trade plan: asset, direction, entry/stop/target, position size, dollar risk, R:R ratio, rationale, confidence level.
 
 ### Step 9: Monitor