@farazirfan/costar-server-executor 1.7.20 → 1.7.21

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