@invizi/cli 0.1.5 → 0.1.7

package/dist/commands/index.js

@@ -0,0 +1 @@
+export { trades } from './trades.js';

package/dist/commands/trades.js

@@ -0,0 +1,289 @@
+import { parseArgs } from 'node:util';
+import { loadConfig } from '../config.js';
+const HLP_API = 'https://api.hyperliquid.xyz/info';
+const MAX_FILLS_PER_REQUEST = 2000;
+const REQUEST_DELAY_MS = 200;
+async function fetchFills(address, startTime, endTime) {
+    const body = {
+        type: 'userFillsByTime',
+        user: address,
+        startTime,
+        aggregateByTime: true,
+    };
+    if (endTime)
+        body.endTime = endTime;
+    const res = await fetch(HLP_API, {
+        method: 'POST',
+        headers: { 'Content-Type': 'application/json' },
+        body: JSON.stringify(body),
+    });
+    if (!res.ok) {
+        throw new Error(`Hyperliquid API error: ${res.status}`);
+    }
+    return (await res.json());
+}
+async function fetchAllFills(address, startTime) {
+    const allFills = [];
+    let cursor = startTime;
+    while (true) {
+        const fills = await fetchFills(address, cursor);
+        if (fills.length === 0)
+            break;
+        allFills.push(...fills);
+        if (fills.length < MAX_FILLS_PER_REQUEST)
+            break;
+        // Next page: start after last fill's time
+        cursor = fills[fills.length - 1].time + 1;
+        // Rate limit courtesy
+        await new Promise(r => setTimeout(r, REQUEST_DELAY_MS));
+    }
+    return allFills;
+}
+function computeStats(fills) {
+    const byCoin = new Map();
+    for (const fill of fills) {
+        const existing = byCoin.get(fill.coin) || [];
+        existing.push(fill);
+        byCoin.set(fill.coin, existing);
+    }
+    const stats = [];
+    for (const [coin, coinFills] of byCoin) {
+        let grossPnl = 0;
+        let fees = 0;
+        let volume = 0;
+        let trades = 0;
+        let wins = 0;
+        let losses = 0;
+        // Track trade cycles: accumulate closedPnl until position flips through zero
+        let cyclePnl = 0;
+        let inTrade = false;
+        for (const fill of coinFills) {
+            const pnl = parseFloat(fill.closedPnl);
+            const fee = parseFloat(fill.fee);
+            const size = parseFloat(fill.sz);
+            const price = parseFloat(fill.px);
+            const startPos = parseFloat(fill.startPosition);
+            grossPnl += pnl;
+            fees += fee;
+            volume += size * price;
+            if (pnl !== 0) {
+                // This is a closing fill
+                cyclePnl += pnl - fee;
+                // Check if position went to zero (trade cycle complete)
+                const endPos = fill.side === 'B'
+                    ? startPos + size
+                    : startPos - size;
+                if (Math.abs(endPos) < 0.0000001 || Math.sign(endPos) !== Math.sign(startPos)) {
+                    // Position closed or flipped
+                    trades++;
+                    if (cyclePnl > 0)
+                        wins++;
+                    else
+                        losses++;
+                    cyclePnl = 0;
+                    inTrade = false;
+                }
+                else {
+                    inTrade = true;
+                }
+            }
+            else if (!inTrade) {
+                inTrade = true;
+            }
+        }
+        // If there's an unclosed cycle with realized P&L, count it
+        if (inTrade && cyclePnl !== 0) {
+            trades++;
+            if (cyclePnl > 0)
+                wins++;
+            else
+                losses++;
+        }
+        // Fallback: if no trade cycles detected but there's P&L, count closing fills
+        if (trades === 0 && grossPnl !== 0) {
+            const closingFills = coinFills.filter(f => parseFloat(f.closedPnl) !== 0);
+            trades = closingFills.length;
+            wins = closingFills.filter(f => parseFloat(f.closedPnl) > 0).length;
+            losses = closingFills.filter(f => parseFloat(f.closedPnl) <= 0).length;
+        }
+        if (trades > 0 || grossPnl !== 0) {
+            stats.push({
+                coin,
+                trades,
+                wins,
+                losses,
+                grossPnl,
+                fees,
+                netPnl: grossPnl - fees,
+                volume,
+                lastTrade: coinFills[coinFills.length - 1].time,
+            });
+        }
+    }
+    // Sort by absolute net P&L descending
+    stats.sort((a, b) => Math.abs(b.netPnl) - Math.abs(a.netPnl));
+    return stats;
+}
+function formatUsd(n) {
+    if (n >= 0)
+        return `+$${n.toFixed(2)}`;
+    return `-$${Math.abs(n).toFixed(2)}`;
+}
+function formatTable(stats, address, days) {
+    const lines = [];
+    const addrShort = `${address.slice(0, 6)}...${address.slice(-4)}`;
+    lines.push(`Trade Analysis for ${addrShort} (Hyperliquid)`);
+    if (days)
+        lines.push(`Period: last ${days} days`);
+    lines.push('');
+    if (stats.length === 0) {
+        lines.push('  No closed trades found.');
+        return lines.join('\n');
+    }
+    // Header
+    const header = '  Coin         Trades  Win%    Gross P&L      Fees     Net P&L';
+    lines.push(header);
+    lines.push('  ' + '─'.repeat(header.length - 2));
+    let totalTrades = 0;
+    let totalWins = 0;
+    let totalGross = 0;
+    let totalFees = 0;
+    let totalNet = 0;
+    for (const s of stats) {
+        const winPct = s.trades > 0 ? Math.round((s.wins / s.trades) * 100) : 0;
+        const feeStr = `-$${s.fees.toFixed(2)}`;
+        const line = `  ${s.coin.padEnd(12)} ${String(s.trades).padStart(6)}  ${String(winPct + '%').padStart(4)}  ${formatUsd(s.grossPnl).padStart(12)}  ${feeStr.padStart(8)}  ${formatUsd(s.netPnl).padStart(12)}`;
+        lines.push(line);
+        totalTrades += s.trades;
+        totalWins += s.wins;
+        totalGross += s.grossPnl;
+        totalFees += s.fees;
+        totalNet += s.netPnl;
+    }
+    lines.push('  ' + '─'.repeat(header.length - 2));
+    const totalWinPct = totalTrades > 0 ? Math.round((totalWins / totalTrades) * 100) : 0;
+    const totalFeeStr = `-$${totalFees.toFixed(2)}`;
+    lines.push(`  ${'Total'.padEnd(12)} ${String(totalTrades).padStart(6)}  ${String(totalWinPct + '%').padStart(4)}  ${formatUsd(totalGross).padStart(12)}  ${totalFeeStr.padStart(8)}  ${formatUsd(totalNet).padStart(12)}`);
+    lines.push('');
+    // Top winner / loser
+    const best = stats.reduce((a, b) => a.netPnl > b.netPnl ? a : b);
+    const worst = stats.reduce((a, b) => a.netPnl < b.netPnl ? a : b);
+    if (best.netPnl > 0)
+        lines.push(`  Best:  ${best.coin} ${formatUsd(best.netPnl)}`);
+    if (worst.netPnl < 0)
+        lines.push(`  Worst: ${worst.coin} ${formatUsd(worst.netPnl)}`);
+    return lines.join('\n');
+}
+function formatCoinDetail(fills, coin) {
+    const coinFills = fills
+        .filter(f => f.coin.toUpperCase() === coin.toUpperCase())
+        .filter(f => parseFloat(f.closedPnl) !== 0);
+    if (coinFills.length === 0) {
+        return `No closed trades found for ${coin}.`;
+    }
+    const lines = [];
+    lines.push(`${coin} Trade History`);
+    lines.push('');
+    lines.push('  Date                 Dir             Size        Price      P&L        Fee');
+    lines.push('  ' + '─'.repeat(78));
+    for (const f of coinFills) {
+        const date = new Date(f.time).toISOString().replace('T', ' ').slice(0, 19);
+        const pnl = parseFloat(f.closedPnl);
+        const fee = parseFloat(f.fee);
+        const line = `  ${date}  ${f.dir.padEnd(14)}  ${parseFloat(f.sz).toFixed(4).padStart(10)}  ${parseFloat(f.px).toFixed(2).padStart(10)}  ${formatUsd(pnl).padStart(9)}  ${formatUsd(-fee).padStart(8)}`;
+        lines.push(line);
+    }
+    return lines.join('\n');
+}
+function showHelp() {
+    console.log(`
+invizi trades — Analyze past trades from Hyperliquid
+
+Usage:
+  invizi trades [address] [options]
+
+Options:
+  --days <n>       Only show trades from the last N days
+  --coin <COIN>    Show per-fill detail for a specific coin
+  --json           Output as JSON (for piping to AI tools)
+  --help           Show this help
+
+Examples:
+  invizi trades                              P&L by coin (connected address)
+  invizi trades --days 30                    Last 30 days only
+  invizi trades --coin SOL                   SOL fill-by-fill detail
+  invizi trades 0xABC...123                  Analyze any public address
+  invizi trades --days 7 --json              JSON output for AI tools
+
+Data is read from the public Hyperliquid blockchain. No auth required.
+`);
+}
+export async function trades(args) {
+    const { values, positionals } = parseArgs({
+        args,
+        options: {
+            days: { type: 'string', short: 'd' },
+            coin: { type: 'string', short: 'c' },
+            json: { type: 'boolean', default: false },
+            help: { type: 'boolean', short: 'h', default: false },
+        },
+        allowPositionals: true,
+        strict: false,
+    });
+    if (values.help) {
+        showHelp();
+        return 0;
+    }
+    const config = loadConfig();
+    const address = positionals.find(a => /^0x[0-9a-fA-F]{40}$/.test(a)) || config.address;
+    if (!address) {
+        console.error('No address found. Run: invizi connect <address>');
+        console.error('Or pass directly: invizi trades 0x...');
+        return 1;
+    }
+    const days = typeof values.days === 'string' ? parseInt(values.days, 10) : null;
+    const coinFilter = typeof values.coin === 'string' ? values.coin.toUpperCase() : null;
+    const jsonMode = values.json === true;
+    // Calculate start time
+    const now = Date.now();
+    const startTime = days ? now - days * 24 * 60 * 60 * 1000 : 0;
+    const addrShort = `${address.slice(0, 6)}...${address.slice(-4)}`;
+    if (!jsonMode) {
+        console.log(`Fetching trades for ${addrShort}...`);
+    }
+    try {
+        const fills = await fetchAllFills(address, startTime);
+        if (fills.length === 0) {
+            console.log('No trades found.');
+            return 0;
+        }
+        if (!jsonMode) {
+            console.log(`  ${fills.length} fills loaded.\n`);
+        }
+        if (coinFilter) {
+            if (jsonMode) {
+                const coinFills = fills.filter(f => f.coin.toUpperCase() === coinFilter);
+                const stats = computeStats(coinFills);
+                console.log(JSON.stringify(stats, null, 2));
+            }
+            else {
+                console.log(formatCoinDetail(fills, coinFilter));
+            }
+        }
+        else {
+            const stats = computeStats(fills);
+            if (jsonMode) {
+                console.log(JSON.stringify(stats, null, 2));
+            }
+            else {
+                console.log(formatTable(stats, address, days));
+            }
+        }
+        return 0;
+    }
+    catch (error) {
+        const message = error instanceof Error ? error.message : String(error);
+        console.error(`Error: ${message}`);
+        return 1;
+    }
+}

package/dist/invizi.js

@@ -3,20 +3,27 @@ import { auth, getAuthorizationHeader } from './auth.js';
 import { connect } from './connect.js';
 import { getApiUrl, getConfigPath, loadConfig, redactConfig } from './config.js';
 import { setup } from './setup.js';
+import { trades } from './commands/index.js';
 function showLocalHelp() {
     console.log(`
 Invizi CLI
 
-Commands:
-  invizi auth login            Login via Auth0 device flow
-  invizi auth status           Show current auth identity
-  invizi auth logout           Clear local Auth0 session
-  invizi connect <address>     Connect a wallet address (auto-detects exchange)
-  invizi setup                 Install skills into your AI tool
+Data:
+  invizi context               Market regime, macro, yields, options, HLP
+  invizi context -c SOL        + coin data, flow, positions, trade history
+  invizi scout <COIN>          Quick coin scan (price, funding, RSI, OBI)
+  invizi market                BTC/ETH/SOL prices, fear/greed, funding extremes
+  invizi trades                Analyze past trades — P&L by coin (local)
+
+Account:
+  invizi auth login            Login
+  invizi auth status           Show current identity
+  invizi connect <address>     Connect a wallet address
+
+Setup:
+  invizi setup                 Configure API + install AI skills
   invizi config                Show current config
   invizi version               Show CLI version
-
-Run invizi --help after login for the remote command list.
 `);
 }
 async function executeProtocol(args, authHeader) {
@@ -74,13 +81,12 @@ async function showRemoteHelp(authHeader) {
         console.log('No commands available for this user.');
         return;
     }
-    console.log('Invizi Remote Commands\n');
     for (const cmd of commands) {
         const name = Array.isArray(cmd.tokens) ? cmd.tokens.join(' ') : cmd.id || '(unknown)';
         const desc = cmd.description || '';
-        console.log(`  ${name.padEnd(20)} ${desc}`);
+        console.log(`  invizi ${name.padEnd(22)} ${desc}`);
     }
-    console.log('\nUse: invizi <command> --help (if supported)');
+    console.log('');
 }
 async function executeRemote(args, options = {}) {
     const authHeader = await getAuthorizationHeader();
@@ -127,6 +133,8 @@ export async function main(rawArgs = process.argv.slice(2)) {
         return auth(args.slice(1));
     if (command === 'connect')
         return connect(args.slice(1));
+    if (command === 'trades')
+        return trades(args.slice(1));
     if (command === 'setup')
         return setup(args.slice(1));
     if (command === 'config') {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@invizi/cli",
-  "version": "0.1.5",
+  "version": "0.1.7",
   "description": "Invizi CLI",
   "type": "module",
   "bin": {