@invizi/cli 0.1.4 → 0.1.6

package/dist/commands/index.js

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

package/dist/commands/trades.js

@@ -0,0 +1,253 @@
+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');
+}
+export async function trades(args) {
+    const config = loadConfig();
+    const address = args.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;
+    }
+    // Parse flags
+    const daysIdx = args.indexOf('--days');
+    const days = daysIdx !== -1 ? parseInt(args[daysIdx + 1], 10) : null;
+    const coinIdx = args.indexOf('--coin');
+    const coinFilter = coinIdx !== -1 ? args[coinIdx + 1]?.toUpperCase() : null;
+    const jsonMode = args.includes('--json');
+    // 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,6 +3,7 @@ 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
@@ -12,6 +13,7 @@ Commands:
   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 trades                Analyze past trades (P&L by coin)
   invizi setup                 Install skills into your AI tool
   invizi config                Show current config
   invizi version               Show CLI version
@@ -103,6 +105,15 @@ async function executeRemote(args, options = {}) {
 export async function main(rawArgs = process.argv.slice(2)) {
     const args = rawArgs;
     const command = args[0];
+    // First-run: if no config exists and user isn't running setup/version/config, prompt
+    if (command && !['setup', 'version', 'config', '--version', '-v', '--help', '-h'].includes(command)) {
+        const config = loadConfig();
+        if (!config.apiUrl) {
+            console.log('First run detected. Running setup...\n');
+            await setup([]);
+            console.log('');
+        }
+    }
     if (!command || command === '--help' || command === '-h') {
         showLocalHelp();
         const header = await getAuthorizationHeader();
@@ -118,6 +129,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/dist/setup.js

@@ -89,6 +89,16 @@ export async function setup(args) {
     }
     const skills = (await listRes.json());
     for (const name of skills) {
+        const skillPath = join(skillsDir, name, 'SKILL.md');
+        const exists = existsSync(skillPath);
+        if (exists) {
+            console.log(`  [exists] ${name} — overwrite? (y/n) `);
+            const answer = await promptYN();
+            if (!answer) {
+                console.log(`  [skip] ${name}`);
+                continue;
+            }
+        }
         const res = await fetch(`${SKILLS_URL}/${name}/SKILL.md`);
         if (!res.ok) {
             console.error(`  [x] ${name} (download failed)`);
@@ -98,7 +108,7 @@ export async function setup(args) {
         if (!dryRun) {
             const dir = join(skillsDir, name);
             mkdirSync(dir, { recursive: true });
-            writeFileSync(join(dir, 'SKILL.md'), content);
+            writeFileSync(skillPath, content);
         }
         console.log(`  [ok] ${name}`);
     }
@@ -107,8 +117,27 @@ export async function setup(args) {
         console.log('Dry run complete. No files written.');
     }
     else {
-        console.log(`Installed ${skills.length} skills to ${skillsDir}`);
+        console.log(`Skills installed to ${skillsDir}`);
         console.log('Try /invizi-trade in your AI tool.');
     }
     return 0;
 }
+function promptYN() {
+    return new Promise(resolve => {
+        const { stdin, stdout } = process;
+        if (!stdin.isTTY) {
+            // Non-interactive (CI, piped) — don't overwrite by default
+            resolve(false);
+            return;
+        }
+        stdin.setRawMode(true);
+        stdin.resume();
+        stdin.once('data', (data) => {
+            stdin.setRawMode(false);
+            stdin.pause();
+            const key = data.toString().toLowerCase();
+            stdout.write(key === 'y' ? 'yes\n' : 'no\n');
+            resolve(key === 'y');
+        });
+    });
+}

package/package.json

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