@vike-io/cli 0.13.1 → 0.15.0

package/src/auth.js

@@ -40,7 +40,7 @@ export function clearApiKey() {
 }
 
 export function getEndpoint() {
-  return process.env.VIKE_MCP_URL || 'https://vike.io/mcp';
+  return process.env.VIKE_MCP_URL || 'https://data.vike.io/mcp';
 }
 
 export function requireApiKey() {

package/src/commands/alerts.js

@@ -1,11 +1,45 @@
 import { callTool } from '../mcp-client.js';
 import { emit, emitError } from '../format.js';
 import { parseBool, parseInt10 } from '../util.js';
+import { addTool } from './tool-command.js';
+
+// What a rule watches beyond token and USD bounds: a transfer alert's address, and the Hyperliquid
+// parameters. Which alert type takes which is the server's to check; it names the fix.
+const TARGET_OPTIONS = [
+  ['--address <a>', 'transfer: one wallet to watch (0x + 40 hex), sent or received'],
+  ['--address-role <r>', 'transfer: any | from | to (default any; needs --address)'],
+  ['--wallet <a>', 'Hyperliquid account (0x + 40 hex): required by hl_wallet and hl_liq_proximity, optional for hl_liquidation'],
+  ['--actions <a...>', 'hl_wallet: open close flip increase reduce (default all but reduce)'],
+  ['--pnl-cohorts <c...>', 'hl_cohort_fill, hl_liquidation: PnL cohorts, e.g. "3x smart" "2x smart"'],
+  ['--size-cohorts <c...>', 'hl_cohort_fill, hl_liquidation: size cohorts, e.g. "4x whale" whale'],
+  ['--index <i>', 'hl_cohort_bias (required): smi | wsi | smart_bias | whale_bias | smi_wsi_gap'],
+  ['--threshold <n>', 'hl_cohort_bias: level to cross (default 0); hl_liq_proximity: share of the way to liquidation, 0-1 (default 0.8)'],
+  ['--band <n>', 'hl_cohort_bias, hl_liq_proximity: hysteresis, > 0 (default 0.1)'],
+  ['--direction <d>', 'hl_cohort_bias: up | down | both (default both)'],
+];
+
+// `--pnl-cohorts ''` clears the list: send [] (the server refuses ['']).
+const list = (v) => (Array.isArray(v) && v.every((x) => x === '') ? [] : v);
+
+function targetArgs(opts) {
+  return {
+    address: opts.address,
+    address_role: opts.addressRole,
+    wallet: opts.wallet,
+    actions: list(opts.actions),
+    pnl_cohorts: list(opts.pnlCohorts),
+    size_cohorts: list(opts.sizeCohorts),
+    index: opts.index,
+    threshold: opts.threshold,
+    band: opts.band,
+    direction: opts.direction,
+  };
+}
 
 export function registerAlerts(program) {
   const cmd = program
     .command('alerts')
-    .description('Manage on-chain transfer alerts');
+    .description('Manage alerts: on-chain transfers and Hyperliquid fills, liquidations, cohort bias and liquidation proximity');
 
   cmd
     .command('list')
@@ -38,7 +72,7 @@ export function registerAlerts(program) {
 
   cmd
     .command('channels')
-    .description('List your enabled notification channels (email/discord/webhook)')
+    .description('List your enabled notification channels (email/webhook)')
     .option('--json', 'Emit JSON')
     .action(async (opts) => {
       try {
@@ -47,25 +81,31 @@ export function registerAlerts(program) {
       } catch (err) { emitError(err, opts); }
     });
 
-  cmd
+  const create = cmd
     .command('create')
-    .description('Create a new on-chain transfer alert')
+    .description('Create an alert: an on-chain transfer alert (default) or a Hyperliquid alert (--type)')
     .requiredOption('--label <l>', 'Alert label (user-visible name)')
-    .option('--token <sym>', 'Token ticker, UPPERCASE (e.g. USDC, ETH)')
-    .option('--chain <c>', 'eth | bsc', 'eth')
-    .option('--min-usd <n>', 'Minimum transfer USD value')
-    .option('--max-usd <n>', 'Maximum transfer USD value')
-    .option('--channel <c...>', 'Notification channel(s): email, discord')
-    .option('--cooldown <min>', 'Minimum gap between triggers (minutes)', '60')
+    .option('--type <t>', 'transfer | hl_wallet | hl_cohort_fill | hl_liquidation | hl_cohort_bias | hl_liq_proximity (default transfer)')
+    .option('--token <sym>', 'transfer: token ticker, UPPERCASE (e.g. USDC); Hyperliquid: the coin (BTC, kPEPE), required by hl_cohort_bias')
+    // No default chain: a Hyperliquid alert refuses one.
+    .option('--chain <c>', 'transfer only: eth | bsc | base | hyperevm (default eth)')
+    .option('--min-usd <n>', 'transfer: minimum USD value; Hyperliquid: fill or liquidation floor (hl_cohort_fill: required, >= 10000)')
+    .option('--max-usd <n>', 'transfer only: maximum USD value');
+  for (const [flags, text] of TARGET_OPTIONS) create.option(flags, text);
+  create
+    .option('--channel <c...>', 'Notification channel(s): email, webhook (Hyperliquid: webhook, or none and read them with `alerts events`)')
+    .option('--cooldown <min>', 'Token-wide transfer alerts: minimum gap between notifications (minutes)', '60')
     .option('--json', 'Emit JSON')
     .action(async (opts) => {
       try {
         const r = await callTool('alerts_create', {
           label: opts.label,
+          alert_type: opts.type,
           token_symbol: opts.token,
           chain: opts.chain,
           min_value_usd: opts.minUsd,
           max_value_usd: opts.maxUsd,
+          ...targetArgs(opts),
           channels: opts.channel,
           cooldown_minutes: parseInt10(opts.cooldown, 60),
         });
@@ -73,27 +113,29 @@ export function registerAlerts(program) {
       } catch (err) { emitError(err, opts); }
     });
 
-  cmd
+  const edit = cmd
     .command('edit <alert_id>')
-    .description('Update an alert (only fields you pass are modified)')
+    .description('Update an alert (only fields you pass are modified; \'\' clears an optional one)')
     .option('--label <l>')
     .option('--token <sym>')
     .option('--chain <c>')
     .option('--min-usd <n>')
-    .option('--max-usd <n>')
+    .option('--max-usd <n>');
+  for (const [flags, text] of TARGET_OPTIONS) edit.option(flags, text);
+  edit
     .option('--channel <c...>')
     .option('--cooldown <min>')
     .option('--active <bool>', 'Pause/resume (true|false)')
     .option('--json', 'Emit JSON')
     .action(async (alertId, opts) => {
       try {
-        const payload = { alert_id: alertId };
+        const payload = { alert_id: alertId, ...targetArgs(opts) };
         if (opts.label !== undefined) payload.label = opts.label;
         if (opts.token !== undefined) payload.token_symbol = opts.token;
         if (opts.chain !== undefined) payload.chain = opts.chain;
         if (opts.minUsd !== undefined) payload.min_value_usd = opts.minUsd;
         if (opts.maxUsd !== undefined) payload.max_value_usd = opts.maxUsd;
-        if (opts.channel !== undefined) payload.channels = opts.channel;
+        if (opts.channel !== undefined) payload.channels = list(opts.channel);
         if (opts.cooldown !== undefined) payload.cooldown_minutes = opts.cooldown;
         if (opts.active !== undefined) payload.is_active = parseBool(opts.active, true);
         const r = await callTool('alerts_edit', payload);
@@ -115,4 +157,32 @@ export function registerAlerts(program) {
         emit(r, opts);
       } catch (err) { emitError(err, opts); }
     });
+
+  addTool(cmd, 'events', {
+    tool: 'alerts_events',
+    desc: 'Events your alerts produced, oldest first, with each delivery\'s status (kept 15 days)',
+    options: [
+      ['--cursor <c>', 'next_cursor from the previous page (an empty page returns the same one)'],
+      ['--limit <n>', 'Events per page, 1-500 (default 100)'],
+      ['--rule-id <id>', 'Only the events of this alert'],
+    ],
+  });
+
+  addTool(cmd, 'resend <delivery_id>', {
+    tool: 'alerts_resend_delivery',
+    args: ['delivery_id'],
+    desc: 'Send one delivery again (its id from an event\'s delivery list in `alerts events`)',
+  });
+
+  addTool(cmd, 'rotate-secret <channel_id>', {
+    tool: 'alerts_rotate_webhook_secret',
+    args: ['channel_id'],
+    desc: 'New signing secret for a webhook channel; the old one keeps signing for 24 hours',
+  });
+
+  addTool(cmd, 'test-webhook <channel_id>', {
+    tool: 'alerts_test_webhook',
+    args: ['channel_id'],
+    desc: 'Send the signed test event to a webhook channel again',
+  });
 }

package/src/commands/call.js

@@ -0,0 +1,32 @@
+import { readFileSync } from 'node:fs';
+import { callTool } from '../mcp-client.js';
+import { emitError } from '../format.js';
+
+export function registerCall(program) {
+  program
+    .command('call <tool>')
+    .description('Call any MCP tool by name and print its raw result (see `vike-data schema --pretty` for the tools and their arguments)')
+    .option('--args <json>', 'Tool arguments as a JSON object, e.g. \'{"symbol":"BTC"}\'')
+    .option('--args-file <path>', 'Read the arguments JSON from a file (- for stdin)')
+    .option('--timeout <s>', 'Seconds to wait for the answer', '60')
+    .option('--json', 'Errors as JSON on stdout (the result is JSON either way)')
+    .action(async (tool, opts) => {
+      try {
+        const text = (opts.argsFile !== undefined
+          ? readFileSync(opts.argsFile === '-' ? 0 : opts.argsFile, 'utf8')
+          : (opts.args ?? '{}')).replace(/^/, '').trim();     // a file saved with a UTF-8 BOM
+        let args;
+        try { args = JSON.parse(text); } catch (err) {
+          throw new Error(`arguments are not valid JSON: ${err.message}`);
+        }
+        if (!args || typeof args !== 'object' || Array.isArray(args)) {
+          throw new Error('arguments must be a JSON object, e.g. {"address":"0x..."}');
+        }
+        const seconds = Number(opts.timeout);
+        if (!(seconds > 0)) throw new Error(`--timeout must be a positive number of seconds, got ${opts.timeout}`);
+        // Parsed only to check it; the text itself is sent, so numbers above 2^53 are not rounded.
+        const r = await callTool(tool, args, { raw: true, argsText: text, timeoutMs: seconds * 1000 });
+        process.stdout.write((typeof r === 'string' ? r : JSON.stringify(r)) + '\n');
+      } catch (err) { emitError(err, opts); }
+    });
+}

package/src/commands/candles.js

@@ -8,26 +8,22 @@ export function registerCandles(program) {
     .description('Historical OHLCV candles — Hyperliquid markets and Polymarket outcome tokens');
 
   cmd
-    .command('hl <symbol>')
-    .description('Hyperliquid candles (perp or spot), aggregated from HL executed fills')
-    .option('--interval <i>', '1m | 5m | 15m | 30m | 1h | 4h | 1d', '1h')
-    .option('--market <m>', 'perp | spot', 'perp')
-    .option('--dex <d>', 'Perp DEX (default HL, the core venue; others are HIP-3 builder DEXs)')
+    .command('hl [symbol]')
+    .description('Hyperliquid candles (perp or spot), aggregated from HL executed fills; --view latest = the newest 1m bar of every symbol')
+    .option('--view <v>', 'candles (default; needs <symbol>) | export (the same, limit defaults to 5000) | latest (every symbol, no <symbol>)')
+    .option('--interval <i>', '1m | 5m | 15m | 30m | 1h | 4h | 1d (default 1h; latest: 1m only)')
+    .option('--market <m>', 'perp | spot (default perp)')
+    .option('--dex <d>', 'Perp DEX (default HL, the core venue; others are HIP-3 builder DEXs; latest: omit for every DEX)')
     .option('--start <t>', 'ISO-8601 UTC or epoch ms (inclusive)')
     .option('--end <t>', 'ISO-8601 UTC or epoch ms (exclusive)')
-    .option('--limit <n>', 'Max candles (default 500, max 5000)', '500')
+    .option('--limit <n>', 'Max candles (default 500, export 5000; max 5000)')
     .option('--json', 'Emit JSON')
     .action(async (symbol, opts) => {
       try {
-        const args = {
-          symbol,
-          interval: opts.interval,
-          market: opts.market,
-          limit: parseInt10(opts.limit, 500),
-        };
-        if (opts.dex !== undefined) args.dex = opts.dex;
-        if (opts.start !== undefined) args.start = opts.start;
-        if (opts.end !== undefined) args.end = opts.end;
+        // Only what was given: the server's defaults stay the defaults. `latest` takes only market, dex and
+        // interval, so a symbol, window or limit is not sent with it.
+        const args = { view: opts.view, interval: opts.interval, market: opts.market, dex: opts.dex };
+        if (opts.view !== 'latest') Object.assign(args, { symbol, start: opts.start, end: opts.end, limit: opts.limit });
         const r = await callTool('hl_ohlcv', args);
         emit(r, opts);
       } catch (err) { emitError(err, opts); }

package/src/commands/doctor.js

@@ -8,13 +8,13 @@ export function registerDoctor(program) {
     .action(async () => {
       const checks = [];
 
-      // 1. Node version
+      // 1. Node version: package.json engines is >=22.12.0
       const nodeVer = process.version;
-      const major = parseInt(nodeVer.slice(1).split('.')[0], 10);
+      const [major, minor] = process.versions.node.split('.').map(Number);
       checks.push({
         name: 'Node runtime',
-        ok: major >= 20,
-        detail: `${nodeVer} (need >= 20.0.0)`,
+        ok: major > 22 || (major === 22 && minor >= 12),
+        detail: `${nodeVer} (need >= 22.12.0)`,
       });
 
       // 2. API key

package/src/commands/hl.js

@@ -0,0 +1,274 @@
+import { addTool } from './tool-command.js';
+
+// One subcommand per Hyperliquid MCP tool; each takes `--view` (the first view is the default).
+// `hl_perp_top_traders` and `hl_position_match` stay under `perp`, candles under `candles`.
+// Flags carry the tool's own parameter names (--opened-within -> opened_within).
+const view = (views) => ['--view <v>', `${views.join(' | ')} (default ${views[0]})`];
+const SYMBOL = ['--symbol <s>', 'Instrument, e.g. BTC; a HIP-3 market is dex:TICKER (xyz:TSLA)'];
+const START = ['--start <t>', 'ISO-8601 UTC lower bound, e.g. 2026-10-01T00:00:00Z'];
+const END = ['--end <t>', 'ISO-8601 UTC upper bound'];
+const CURSOR = ['--cursor <c>', 'nextCursor from the previous page, verbatim'];
+const LIMIT = ['--limit <n>', 'Rows per page'];
+const OPENED = ['--opened-within <w>', 'Only positions opened within: 24h | 7d | 30d | all'];
+const AXIS = ['--axis <a>', 'Cohort ladder: size | pnl | pnl_abs'];
+const COHORT = ['--cohort <c>', 'One cohort label on --axis, e.g. whale or "3x smart" (`hl segments --view cohorts` lists them)'];
+const WINDOW = ['--window <w>', '1d | 7d | 30d | all'];
+const VAULT_WINDOW = ['--window <w>', '7d | 30d | 90d | 365d | all'];
+const ORDER = ['--order <o>', 'desc | asc'];
+const SIDE = ['--side <s>', 'buy | sell'];
+const WALLET = ['--wallet <a>', 'One wallet (0x + 40 hex)'];
+
+export function registerHl(program) {
+  const hl = program
+    .command('hl')
+    .description('Hyperliquid: cohort positioning, wallets, leaderboards, liquidations, markets, builders, vaults');
+
+  addTool(hl, 'cohort-metrics <symbol>', {
+    tool: 'hl_cohort_metrics',
+    args: ['symbol'],
+    desc: 'Hourly long/short positioning of one perp split by cohort (are whales / smart money long or short)',
+    options: [
+      ['--axis <a>', 'size | pnl | pnl_abs | tier | trade_size | pnl_unrealized (default size)'],
+      ['--hours <n>', 'Hourly buckets, newest first, max 8760 (default 168; 1-24 for a current read)'],
+      START, END, OPENED,
+      ['--label-basis <b>', 'current | point_in_time (point_in_time for any backtest)'],
+      ['--grading <g>', 'realized | realized-pit | unrealized (pnl axes only)'],
+      ['--include <list>', 'Comma list: volume, median_pnl (newest hour only)'],
+      CURSOR,
+    ],
+  });
+
+  addTool(hl, 'segments', {
+    tool: 'hl_segments',
+    desc: 'Cohort vocabulary, one cohort now, the symbol x cohort board, or one cohort hour by hour',
+    options: [
+      view(['segments', 'cohorts', 'summary', 'heatmap', 'history']),
+      ['--cohort <c>', 'One label (required by summary and history)'],
+      ['--axis <a>', 'size | pnl | pnl_abs (history: size or pnl, required)'],
+      OPENED, START, END,
+      ['--hours <n>', 'history: window length in hours (default 168)'],
+      ['--limit <n>', 'history: max hourly rows (default 5000)'],
+      ['--include <list>', 'history: leverage'],
+    ],
+  });
+
+  addTool(hl, 'wallet <address>', {
+    tool: 'hl_wallet',
+    args: ['address'],
+    desc: 'One wallet: equity, open positions, cohort labels, risk metrics and lifetime flow (or closed-trade stats)',
+    options: [view(['summary', 'trades_summary']), WINDOW, OPENED],
+  });
+
+  addTool(hl, 'wallet-activity <address>', {
+    tool: 'hl_wallet_activity',
+    args: ['address'],
+    desc: 'One wallet\'s fills, funding, ledger (deposits, withdrawals, transfers, vault events) or builder routing',
+    options: [
+      view(['fills', 'funding', 'ledger', 'builders']),
+      SYMBOL, START, END, SIDE,
+      ['--event-type <t>', 'ledger: one event type, e.g. deposit, withdraw, vaultDeposit'],
+      ['--window <w>', 'builders: 1d | 7d | 30d | all'],
+      ['--limit <n>', 'Rows per page (default 100, max 5000; builders 50, max 500)'],
+      CURSOR,
+    ],
+  });
+
+  addTool(hl, 'leaderboard', {
+    tool: 'hl_leaderboard',
+    desc: 'Traders ranked on any of 20 metrics with the full risk set, or on fills-derived trading PnL',
+    options: [
+      view(['ranking', 'flow_adjusted']),
+      ['--window <w>', '1d | 7d | 30d | all (default 30d)'],
+      ['--sort <s>', 'pnl | realized_pnl | roi | volume | trades | win_rate | profit_factor | calmar | max_drawdown | ... (default pnl)'],
+      ORDER, COHORT, AXIS,
+      ['--min-trades <n>', 'Minimum closed trades (default 3; 0 = no floor)'],
+      ['--min-win-rate <f>', 'FRACTION 0-1 (0.6 = 60%), unlike `perp top-traders`'],
+      ['--min-volume <usd>', 'Minimum total volume in USD'],
+      ['--limit <n>', 'Rows per page (default 25, max 500)'],
+      CURSOR,
+    ],
+  });
+
+  addTool(hl, 'liquidations', {
+    tool: 'hl_liquidations',
+    desc: 'Liquidation events, the share of open notional near liquidation per symbol, or one symbol\'s liquidation heatmap',
+    options: [
+      view(['fills', 'risk', 'heatmap']),
+      ['--symbol <s>', 'One symbol (required by heatmap)'],
+      ['--wallet <a>', 'fills: has this wallet been liquidated'],
+      START, END,
+      ['--direction <d>', 'fills: long | short, the side that was closed'],
+      AXIS, COHORT,
+      ['--min-value-usd <usd>', 'risk: smallest open notional a symbol needs to be ranked'],
+      ['--bins <n>', 'heatmap: price bins, 5-500 (default 50)'],
+      ['--limit <n>', 'Rows per page (fills max 5000, risk max 500)'],
+      CURSOR,
+    ],
+  });
+
+  addTool(hl, 'market', {
+    tool: 'hl_market',
+    desc: 'Open interest per symbol, one symbol\'s hourly series, size breakdown, positions, indices or large fills',
+    options: [
+      view(['open_interest', 'symbol_metrics', 'size_breakdown', 'positions', 'indices', 'large_fills', 'hourly']),
+      ['--symbol <s>', 'One symbol (required by every view but open_interest, positions and hourly)'],
+      ['--symbols <list>', 'hourly: comma-separated perps, at most 64 (close, open interest, funding, premium)'],
+      ['--days <n>', 'hourly: days back from --end, 1-400 (default 120)'],
+      WALLET, AXIS, COHORT, OPENED, START, END,
+      ['--open-only <bool>', 'positions: true (default) = latest open; false needs --start'],
+      ['--sort <s>', 'positions: size = biggest positions of one --symbol first'],
+      ['--resolution <r>', 'positions history: 5m | 1h'],
+      ['--label-basis <b>', 'symbol_metrics: current'],
+      ['--hours <n>', 'indices: window in hours; large_fills: look-back, max 24'],
+      ['--min-usd <usd>', 'large_fills: smallest fill, at least 50000'],
+      LIMIT, CURSOR,
+    ],
+  });
+
+  addTool(hl, 'builders', {
+    tool: 'hl_builders',
+    desc: 'Builder codes: leaderboard, venue-wide stats, one builder\'s profile, users, fills or series',
+    options: [
+      view(['leaderboard', 'stats', 'profile', 'users', 'fills', 'series']),
+      ['--builder <a>', 'Builder address (required by profile, users, fills, series)'],
+      ['--window <w>', '1d | 7d | 30d | all (default 30d)'],
+      ['--sort <s>', 'leaderboard: fee | volume | users | fills; users: volume | fees | pnl'],
+      ORDER, SYMBOL, SIDE, START, END,
+      ['--bucket <b>', 'series: 1h | 1d'],
+      ['--breakdown-limit <n>', 'profile: rows per breakdown, max 1000'],
+      LIMIT, CURSOR,
+    ],
+  });
+
+  addTool(hl, 'vaults', {
+    tool: 'hl_vaults',
+    desc: 'Every vault with TVL, APR, PnL and flows, platform vault stats, or deposits and withdrawals across vaults',
+    options: [
+      view(['list', 'stats', 'flows']),
+      VAULT_WINDOW,
+      ['--sort <s>', 'list: tvl | apr | pnl | return | net_flow | volume | age | leverage | top5_share'],
+      ORDER,
+      ['--status <s>', 'list: open | closed | all'],
+      ['--deposits <d>', 'list: any | open | closed'],
+      ['--min-tvl <usd>', 'list: minimum TVL in USD'],
+      ['--q <text>', 'list: part of a vault name, or an address prefix'],
+      ['--min-usd <usd>', 'flows: smallest flow in USD (default 10000)'],
+      ['--type <t>', 'flows: all | deposit | withdraw | distribution | commission'],
+      ['--smart-only <bool>', 'flows: only top-1000 all-time PnL depositors'],
+      LIMIT, CURSOR,
+    ],
+  });
+
+  addTool(hl, 'vault <vault>', {
+    tool: 'hl_vault',
+    args: ['vault'],
+    desc: 'One vault: profile, depositors, its own flows, or an equity / PnL series',
+    options: [
+      view(['profile', 'depositors', 'flows', 'series']),
+      ['--sort <s>', 'depositors: share | pnl | all_time_pnl | entered'],
+      ORDER,
+      ['--smart-only <bool>', 'depositors: only top-1000 all-time PnL wallets'],
+      ['--min-equity-usd <usd>', 'depositors: smallest equity, at least 1'],
+      VAULT_WINDOW,
+      ['--type <t>', 'flows: all | deposit | withdraw | distribution | commission'],
+      ['--bucket <b>', 'series: 1h | 1d'],
+      START, END, LIMIT, CURSOR,
+    ],
+  });
+
+  // The cross-wallet feeds (twaps, ledger, leverage-changes): `--order asc` follows a feed; resend the same
+  // filters with each nextCursor and stop on an empty page.
+  const FEED_ORDER = ['--order <o>', 'desc (default) | asc (to follow the feed)'];
+  const FEED_WINDOW = ['--start <t>', 'ISO-8601 UTC lower bound (default: 24 hours before --end, unless --wallet)'];
+
+  addTool(hl, 'orders', {
+    tool: 'hl_orders',
+    desc: 'Standing orders: resting at one instant, one wallet\'s orders over a window, or one symbol\'s order clusters',
+    options: [
+      view(['open', 'wallet', 'clusters']),
+      ['--symbol <s>', 'open: symbol and/or --wallet required; clusters: required'],
+      ['--wallet <a>', 'open: one wallet\'s resting orders'],
+      ['--address <a>', 'wallet: the wallet (required)'],
+      ['--at <t>', 'open, clusters: ISO-8601 UTC instant (default the newest snapshot)'],
+      ['--oid <n>', 'open: one order id'],
+      ['--order-type <t>', 'open: Limit | Stop Market | Stop Limit | Take Profit Market | Take Profit Limit | Trailing Stop Market'],
+      ['--created-from <t>', 'open: placed at or after (ISO-8601 UTC)'],
+      ['--created-to <t>', 'open: placed at or before (ISO-8601 UTC)'],
+      ['--from <t>', 'wallet: window start (default 7 days before --to)'],
+      ['--to <t>', 'wallet: window end (default the newest snapshot; at most 30 days)'],
+      ['--status <s>', 'wallet: open | filled | partially_filled | canceled_or_expired'],
+      ['--step-bps <n>', 'clusters: bucket width in basis points (default 10)'],
+      ['--range-pct <n>', 'clusters: half-width around the mid in percent (default 10)'],
+      ['--cohort-axis <a>', 'clusters: size | pnl | pnl_abs'],
+      ['--cohort <c>', 'clusters: one cohort label (current labels; not with --at)'],
+      LIMIT, CURSOR,
+    ],
+  });
+
+  addTool(hl, 'twaps', {
+    tool: 'hl_twaps',
+    desc: 'TWAP status lines across wallets, or one wallet\'s or one TWAP\'s',
+    options: [
+      WALLET,
+      ['--twap-id <n>', 'One TWAP: every status line of it'],
+      SYMBOL,
+      ['--status <s>', 'activated | waitingForTrigger | finished | terminated | stopped | error'],
+      FEED_WINDOW, END, FEED_ORDER, LIMIT, CURSOR,
+    ],
+  });
+
+  addTool(hl, 'ledger', {
+    tool: 'hl_ledger',
+    desc: 'Deposits, withdrawals, transfers and vault events across wallets',
+    options: [
+      WALLET,
+      ['--event-type <t>', 'One event type, e.g. deposit, withdraw, send, vaultDeposit'],
+      ['--min-usd <usd>', 'Smallest absolute amount_usd'],
+      FEED_WINDOW, END, FEED_ORDER, LIMIT, CURSOR,
+    ],
+  });
+
+  addTool(hl, 'leverage-changes', {
+    tool: 'hl_leverage_changes',
+    desc: 'Positions whose leverage or margin mode changed between two snapshots',
+    options: [
+      WALLET, SYMBOL,
+      ['--change <c>', 'up | down | mode'],
+      ['--min-leverage <x>', 'Smallest new leverage'],
+      FEED_WINDOW, END, FEED_ORDER, LIMIT, CURSOR,
+    ],
+  });
+
+  addTool(hl, 'wallet-trades <address>', {
+    tool: 'hl_wallet_trades',
+    args: ['address'],
+    desc: 'One wallet\'s closed round-trip trades, newest close first',
+    options: [SYMBOL, START, END, LIMIT, CURSOR],
+  });
+
+  addTool(hl, 'stats', {
+    tool: 'hl_stats',
+    desc: 'Hourly venue-wide perp equity, open interest and positions, or hourly perp volume',
+    options: [
+      view(['ecosystem', 'volume']),
+      ['--symbol <s>', 'volume: one symbol (omit for the whole venue)'],
+      START, END, LIMIT, CURSOR,
+    ],
+  });
+
+  addTool(hl, 'hype-holders', {
+    tool: 'hl_hype_holders',
+    desc: 'HYPE holders ranked by spot balance plus staked',
+    options: [['--order <o>', 'desc (default) | asc'], LIMIT, CURSOR],
+  });
+
+  addTool(hl, 'archive', {
+    tool: 'hl_archive',
+    desc: 'Index of the Hyperliquid Parquet archive (fills, positions), or a 7-day download link for one file (--view url)',
+    options: [
+      view(['datasets', 'url']),
+      ['--dataset <d>', 'url: fills | positions'],
+      ['--date <d>', 'url: the UTC day, YYYY-MM-DD, or latest (positions only)'],
+    ],
+  });
+}

package/src/commands/init.js

@@ -31,7 +31,7 @@ export function registerInit(program) {
       const path = saveApiKey(key);
       console.log(`Saved to ${path}`);
 
-      console.log('Verifying connection to vike.io/mcp ...');
+      console.log('Verifying connection to data.vike.io/mcp ...');
       const { status, body } = await ping({ apiKey: key });
       if (status !== 200 || body?.error) {
         console.error(`Endpoint returned HTTP ${status}: ${JSON.stringify(body)}`);

package/src/commands/labels.js

@@ -5,7 +5,7 @@ export function registerLabels(program) {
   // `vike-data labels <address>` — multi-source label provenance for one wallet
   program
     .command('labels <address>')
-    .description('Multi-source label cascade for a wallet (10+ providers + in-house heuristic + consensus view)')
+    .description('Multi-source label cascade for an Ethereum wallet (up to 6 label sources + in-house heuristic + consensus view)')
     .option('--json', 'Emit JSON')
     .action(async (address, opts) => {
       try {

package/src/commands/perp.js

@@ -9,7 +9,7 @@ export function registerPerp(program) {
 
   cmd
     .command('funding')
-    .description('Funding rates per venue, or cross-venue funding-arb opportunities')
+    .description('Funding rates per venue (raw per-interval rate + interval_h), or the top 5 cross-venue funding-arb rows')
     .option('--symbol <s>', 'Specific symbol (e.g. BTC). Omit for top arb opportunities.')
     .option('--json', 'Emit JSON')
     .action(async (opts) => {
@@ -21,8 +21,8 @@ export function registerPerp(program) {
 
   cmd
     .command('spreads')
-    .description('Cross-venue spot-perp spread arbitrage opportunities')
-    .option('--symbol <s>', 'Specific symbol. Omit for full matrix.')
+    .description('Cross-venue perp price gaps: the 10 widest (buy on one venue, sell on another)')
+    .option('--symbol <s>', 'Filter those 10 to one symbol (often empty). Omit for all.')
     .option('--json', 'Emit JSON')
     .action(async (opts) => {
       try {
@@ -39,17 +39,18 @@ export function registerPerp(program) {
     .requiredOption('--leverage <x>', 'Leverage from the share card (e.g. 25)')
     .requiredOption('--entry <p>', 'Entry price from the share card')
     .option('--mark <p>', 'Optional current mark price (sharpens tie-break)')
-    .option('--limit <n>', 'Max matches (default 10, max 50)', '10')
+    .option('--limit <n>', 'Max matches (default 50, max 500)', '50')
     .option('--json', 'Emit JSON')
     .action(async (opts) => {
       try {
+        // The tool renamed `coin` to `symbol` on 2026-10-19; `--coin` stays the flag users know.
         const r = await callTool('hl_position_match', {
-          coin: opts.coin,
+          symbol: opts.coin,
           side: opts.side,
           leverage: Number(opts.leverage),
           entry_price: Number(opts.entry),
           mark_price: opts.mark != null ? Number(opts.mark) : undefined,
-          limit: parseInt10(opts.limit, 10),
+          limit: parseInt10(opts.limit, 50),
         });
         emit(r, opts);
       } catch (err) { emitError(err, opts); }
@@ -59,12 +60,12 @@ export function registerPerp(program) {
     .command('top-traders')
     .description('Top Hyperliquid perp wallets by PnL / ROI / win rate / volume')
     .option('--window <w>', '1d | 7d | 30d | all', '30d')
-    .option('--sort <s>', 'pnl | roi | win_rate | volume | trade_count | drawdown', 'pnl')
+    .option('--sort <s>', 'pnl | roi | win_rate | volume | trade_count | drawdown | account_value | long_pnl | short_pnl', 'pnl')
     .option('--order <o>', 'asc | desc', 'desc')
     .option('--min-trades <n>', 'Minimum trade count', '3')
     .option('--min-win-rate <p>', 'Minimum win rate percent (0-100)', '0')
     .option('--min-volume <usd>', 'Minimum volume USD', '0')
-    .option('--size <n>', 'Page size (max 20)', '10')
+    .option('--size <n>', 'Page size (default 20, max 100)', '20')
     .option('--json', 'Emit JSON')
     .action(async (opts) => {
       try {
@@ -75,7 +76,7 @@ export function registerPerp(program) {
           min_trades: parseInt10(opts.minTrades, 3),
           min_win_rate: opts.minWinRate,
           min_volume: opts.minVolume,
-          size: parseInt10(opts.size, 10),
+          size: parseInt10(opts.size, 20),
         });
         emit(r, opts);
       } catch (err) { emitError(err, opts); }