@nexstone/rift-cli 0.1.1

package/dist/commands/config.js

@@ -0,0 +1,143 @@
+import { Args } from '@oclif/core';
+import { GatedCommand } from '../lib/base-command.js';
+import * as fs from 'node:fs';
+import * as path from 'node:path';
+const green = (s) => `\x1b[32m${s}\x1b[0m`;
+const dim = (s) => `\x1b[2m${s}\x1b[0m`;
+const bold = (s) => `\x1b[1m${s}\x1b[0m`;
+const cyan = (s) => `\x1b[36m${s}\x1b[0m`;
+function getConfigPath() {
+    const dir = path.join(process.env.HOME || '~', '.rift');
+    if (!fs.existsSync(dir))
+        fs.mkdirSync(dir, { recursive: true });
+    return path.join(dir, 'config.json');
+}
+function loadConfig() {
+    const p = getConfigPath();
+    if (!fs.existsSync(p))
+        return {};
+    return JSON.parse(fs.readFileSync(p, 'utf-8'));
+}
+function saveConfig(config) {
+    fs.writeFileSync(getConfigPath(), JSON.stringify(config, null, 2), { mode: 0o600 });
+}
+function getNestedValue(obj, keyPath) {
+    const parts = keyPath.split('.');
+    let current = obj;
+    for (const part of parts) {
+        if (current == null || typeof current !== 'object')
+            return undefined;
+        current = current[part];
+    }
+    return current;
+}
+function setNestedValue(obj, keyPath, value) {
+    const parts = keyPath.split('.');
+    let current = obj;
+    for (let i = 0; i < parts.length - 1; i++) {
+        if (!(parts[i] in current) || typeof current[parts[i]] !== 'object') {
+            current[parts[i]] = {};
+        }
+        current = current[parts[i]];
+    }
+    current[parts[parts.length - 1]] = value;
+}
+function maskSensitive(key, value) {
+    if (key.includes('key') || key.includes('secret') || key.includes('token') || key.includes('password')) {
+        if (value.length <= 10)
+            return '****';
+        return value.slice(0, 8) + '...' + value.slice(-4);
+    }
+    return value;
+}
+export default class Config extends GatedCommand {
+    static description = 'View and set RIFT configuration';
+    static examples = [
+        '$ rift config list',
+        '$ rift config set ai.api_key sk-ant-...',
+        '$ rift config get ai.api_key',
+        '$ rift config set ai.model claude-sonnet-4-20250514',
+    ];
+    static strict = false;
+    static args = {
+        action: Args.string({
+            description: 'Action: list, get, set',
+            required: false,
+            options: ['list', 'get', 'set'],
+        }),
+        key: Args.string({ description: 'Config key (dot-notation, e.g. ai.api_key)', required: false }),
+        value: Args.string({ description: 'Value to set', required: false }),
+    };
+    async run() {
+        const { args } = await this.parse(Config);
+        if (!args.action || args.action === 'list') {
+            return this.listConfig();
+        }
+        if (args.action === 'get') {
+            if (!args.key) {
+                this.log(`  Usage: rift config get <key>`);
+                return;
+            }
+            return this.getConfig(args.key);
+        }
+        if (args.action === 'set') {
+            if (!args.key || args.value === undefined) {
+                this.log(`  Usage: rift config set <key> <value>`);
+                this.log('');
+                this.log(`  ${dim('Common keys:')}`);
+                this.log(`    ${cyan('ai.api_key')}       ${dim('Anthropic API key for --analyze')}`);
+                this.log(`    ${cyan('ai.model')}         ${dim('Model to use (default: claude-sonnet-4-20250514)')}`);
+                this.log(`    ${cyan('network.proxy')}    ${dim('Proxy URL for Hyperliquid API')}`);
+                return;
+            }
+            return this.setConfig(args.key, args.value);
+        }
+    }
+    listConfig() {
+        const config = loadConfig();
+        if (Object.keys(config).length === 0) {
+            this.log('');
+            this.log(`  ${dim('No configuration set.')}`);
+            this.log('');
+            this.log(`  ${dim('Get started:')}`);
+            this.log(`    ${cyan('rift config set ai.api_key sk-ant-...')}`);
+            this.log('');
+            return;
+        }
+        this.log('');
+        this.log(`  ${bold('RIFT Configuration')} ${dim('(~/.rift/config.json)')}`);
+        this.log('');
+        this.printObject(config, '  ');
+        this.log('');
+    }
+    printObject(obj, indent) {
+        for (const [key, value] of Object.entries(obj)) {
+            if (typeof value === 'object' && value !== null && !Array.isArray(value)) {
+                this.log(`${indent}${bold(key)}:`);
+                this.printObject(value, indent + '  ');
+            }
+            else {
+                const display = typeof value === 'string' ? maskSensitive(key, value) : String(value);
+                this.log(`${indent}${key}: ${dim(display)}`);
+            }
+        }
+    }
+    getConfig(key) {
+        const config = loadConfig();
+        const value = getNestedValue(config, key);
+        if (value === undefined) {
+            this.log(`  ${dim('Not set:')} ${key}`);
+        }
+        else {
+            const display = typeof value === 'string' ? maskSensitive(key, value) : JSON.stringify(value, null, 2);
+            this.log(`  ${key}: ${display}`);
+        }
+    }
+    setConfig(key, value) {
+        const config = loadConfig();
+        setNestedValue(config, key, value);
+        saveConfig(config);
+        const display = maskSensitive(key, value);
+        this.log(`  ${green('✔')} ${key} = ${dim(display)}`);
+    }
+}

package/dist/commands/cost.d.ts

@@ -0,0 +1,20 @@
+import { GatedCommand } from '../lib/base-command.js';
+export default class Cost extends GatedCommand {
+    static description: string;
+    static examples: string[];
+    static args: {
+        pair: import("@oclif/core/interfaces").Arg<string, Record<string, unknown>>;
+        notional: import("@oclif/core/interfaces").Arg<string, Record<string, unknown>>;
+    };
+    static flags: {
+        side: import("@oclif/core/interfaces").OptionFlag<string, import("@oclif/core/interfaces").CustomOptions>;
+        tf: import("@oclif/core/interfaces").OptionFlag<string, import("@oclif/core/interfaces").CustomOptions>;
+        hold: import("@oclif/core/interfaces").OptionFlag<string, import("@oclif/core/interfaces").CustomOptions>;
+        maker: import("@oclif/core/interfaces").BooleanFlag<boolean>;
+        spot: import("@oclif/core/interfaces").BooleanFlag<boolean>;
+        'no-builder-fee': import("@oclif/core/interfaces").BooleanFlag<boolean>;
+        'tier-vol-14d': import("@oclif/core/interfaces").OptionFlag<string, import("@oclif/core/interfaces").CustomOptions>;
+        json: import("@oclif/core/interfaces").BooleanFlag<boolean>;
+    };
+    run(): Promise<void>;
+}

package/dist/commands/cost.js

@@ -0,0 +1,104 @@
+import { Args, Flags } from '@oclif/core';
+import { GatedCommand } from '../lib/base-command.js';
+import { runEngine } from '../lib/python-bridge.js';
+const bold = (s) => `\x1b[1m${s}\x1b[0m`;
+const green = (s) => `\x1b[32m${s}\x1b[0m`;
+const yellow = (s) => `\x1b[33m${s}\x1b[0m`;
+const dim = (s) => `\x1b[2m${s}\x1b[0m`;
+export default class Cost extends GatedCommand {
+    static description = 'Estimate pre-trade cost for a hypothetical trade: fees + funding + impact + slippage';
+    static examples = [
+        '$ rift cost BTC 50000',
+        '$ rift cost ETH 10000 --side sell --hold 24',
+        '$ rift cost BTC 100000 --maker --tier-vol-14d 5000000',
+    ];
+    static args = {
+        pair: Args.string({ description: 'Trading pair (e.g. BTC, ETH-PERP)', required: true }),
+        notional: Args.string({
+            description: 'Trade size in USD notional (e.g. 50000)',
+            required: true,
+        }),
+    };
+    static flags = {
+        side: Flags.string({ description: 'buy / sell / long / short', default: 'buy' }),
+        tf: Flags.string({ description: 'Candle interval for ADV / vol calc', default: '1h' }),
+        hold: Flags.string({ description: 'Holding period in hours (for funding accrual)', default: '0' }),
+        maker: Flags.boolean({ description: 'Treat as maker (post-only)', default: false }),
+        spot: Flags.boolean({ description: 'Treat as spot trade instead of perp', default: false }),
+        'no-builder-fee': Flags.boolean({ description: 'Exclude RIFT builder fee', default: false }),
+        'tier-vol-14d': Flags.string({
+            description: 'Your 14d HL volume USD (fee-tier lookup)',
+            default: '0',
+        }),
+        json: Flags.boolean({ description: 'Emit raw JSON instead of human format', default: false }),
+    };
+    async run() {
+        const { args, flags } = await this.parse(Cost);
+        const engineArgs = [args.pair, args.notional];
+        engineArgs.push('--side', flags.side);
+        engineArgs.push('--tf', flags.tf);
+        engineArgs.push('--hold', flags.hold);
+        if (flags.maker)
+            engineArgs.push('--maker');
+        if (flags.spot)
+            engineArgs.push('--spot');
+        if (flags['no-builder-fee'])
+            engineArgs.push('--no-builder-fee');
+        engineArgs.push('--tier-vol-14d', flags['tier-vol-14d']);
+        let result = null;
+        await runEngine('cost', engineArgs, (msg) => {
+            if (msg.type === 'result') {
+                result = msg;
+            }
+            else if (msg.type === 'error') {
+                this.error(msg.msg);
+            }
+        });
+        if (!result) {
+            this.error('No result returned from engine');
+        }
+        if (flags.json) {
+            this.log(JSON.stringify(result, null, 2));
+            return;
+        }
+        // Pretty render
+        const r = result;
+        const c = r.cost;
+        const pair = r.pair;
+        const side = r.side;
+        const notional = r.notional_usd;
+        const mid = r.mid_price;
+        const advPct = r.adv_pct;
+        this.log('');
+        this.log(`  ${bold('Pre-trade cost estimate')}  ${dim(`${pair} ${side}`)}`);
+        this.log(`  ${dim('─'.repeat(56))}`);
+        this.log(`  Notional       $${notional.toLocaleString()}`);
+        if (mid > 0) {
+            this.log(`  Mid price      $${mid.toLocaleString()}`);
+        }
+        if (advPct !== null && advPct !== undefined) {
+            this.log(`  % of ADV       ${advPct.toFixed(3)}%`);
+        }
+        this.log('');
+        this.log(`  Component        bps      USD`);
+        this.log(`  ${dim('─'.repeat(40))}`);
+        this.log(`  Fees           ${c.fee_bps.toFixed(2).padStart(6)}   $${c.fee_usd.toFixed(2).padStart(8)}`);
+        if (c.funding_bps !== 0) {
+            this.log(`  Funding        ${c.funding_bps.toFixed(2).padStart(6)}   $${c.funding_usd.toFixed(2).padStart(8)}`);
+        }
+        this.log(`  Impact         ${c.impact_bps.toFixed(2).padStart(6)}   $${c.impact_usd.toFixed(2).padStart(8)}   ${dim('[' + (c.impact_model || '?') + ']')}`);
+        if (c.slippage_bps !== 0) {
+            this.log(`  Slippage       ${c.slippage_bps.toFixed(2).padStart(6)}   $${c.slippage_usd.toFixed(2).padStart(8)}`);
+        }
+        this.log(`  ${dim('─'.repeat(40))}`);
+        this.log(`  ${bold('TOTAL')}          ${c.total_bps.toFixed(2).padStart(6)}   $${c.total_usd.toFixed(2).padStart(8)}`);
+        this.log('');
+        const warnings = r.warnings || [];
+        if (warnings.length > 0) {
+            for (const w of warnings) {
+                this.log(`  ${yellow('!')} ${w}`);
+            }
+            this.log('');
+        }
+    }
+}

package/dist/commands/cross-asset.d.ts

@@ -0,0 +1,14 @@
+import { GatedCommand } from '../lib/base-command.js';
+export default class CrossAsset extends GatedCommand {
+    static description: string;
+    static examples: string[];
+    static flags: {
+        coins: import("@oclif/core/interfaces").OptionFlag<string, import("@oclif/core/interfaces").CustomOptions>;
+        tf: import("@oclif/core/interfaces").OptionFlag<string, import("@oclif/core/interfaces").CustomOptions>;
+        lookback: import("@oclif/core/interfaces").OptionFlag<string, import("@oclif/core/interfaces").CustomOptions>;
+        benchmark: import("@oclif/core/interfaces").OptionFlag<string, import("@oclif/core/interfaces").CustomOptions>;
+        'max-lag': import("@oclif/core/interfaces").OptionFlag<string, import("@oclif/core/interfaces").CustomOptions>;
+        json: import("@oclif/core/interfaces").BooleanFlag<boolean>;
+    };
+    run(): Promise<void>;
+}

package/dist/commands/cross-asset.js

@@ -0,0 +1,39 @@
+import { Flags } from '@oclif/core';
+import { GatedCommand } from '../lib/base-command.js';
+import { passthroughToEngine } from '../lib/engine-passthrough.js';
+export default class CrossAsset extends GatedCommand {
+    static description = 'Cross-asset correlation matrix + lead-lag + beta-vs-benchmark';
+    static examples = [
+        '$ rift cross-asset',
+        '$ rift cross-asset --coins BTC,ETH,SOL --tf 4h --benchmark BTC',
+    ];
+    static flags = {
+        coins: Flags.string({
+            description: 'Comma-separated coin list',
+            default: 'BTC,ETH,SOL,SUI,AVAX,NEAR,LINK,DOGE',
+        }),
+        tf: Flags.string({ description: 'Timeframe', default: '1h' }),
+        lookback: Flags.string({ description: 'Candles to use (720 = 30d at 1h)', default: '720' }),
+        benchmark: Flags.string({ description: 'Beta-vs-benchmark coin', default: 'BTC' }),
+        'max-lag': Flags.string({ description: 'Lead-lag search window (candles)', default: '6' }),
+        json: Flags.boolean({ description: 'Emit raw JSON only', default: false }),
+    };
+    async run() {
+        const { flags } = await this.parse(CrossAsset);
+        const args = [
+            '--coins', flags.coins,
+            '--tf', flags.tf,
+            '--lookback', flags.lookback,
+            '--benchmark', flags.benchmark,
+            '--max-lag', flags['max-lag'],
+        ];
+        await passthroughToEngine({
+            command: 'cross-asset',
+            args,
+            log: (m) => this.log(m),
+            error: (m) => this.error(m),
+            exit: (c) => this.exit(c),
+            jsonOnly: flags.json,
+        });
+    }
+}

package/dist/commands/data/fetch.d.ts

@@ -0,0 +1,15 @@
+import { GatedCommand } from '../../lib/base-command.js';
+export default class DataFetch extends GatedCommand {
+    static description: string;
+    static examples: string[];
+    static flags: {
+        pair: import("@oclif/core/interfaces").OptionFlag<string, import("@oclif/core/interfaces").CustomOptions>;
+        tf: import("@oclif/core/interfaces").OptionFlag<string, import("@oclif/core/interfaces").CustomOptions>;
+        start: import("@oclif/core/interfaces").OptionFlag<string | undefined, import("@oclif/core/interfaces").CustomOptions>;
+        all: import("@oclif/core/interfaces").BooleanFlag<boolean>;
+        top: import("@oclif/core/interfaces").OptionFlag<number | undefined, import("@oclif/core/interfaces").CustomOptions>;
+    };
+    run(): Promise<void>;
+    private fetchSingle;
+    private fetchMulti;
+}

package/dist/commands/data/fetch.js

@@ -0,0 +1,82 @@
+import { Flags } from '@oclif/core';
+import { GatedCommand } from '../../lib/base-command.js';
+import { runEngine } from '../../lib/python-bridge.js';
+const green = (s) => `\x1b[32m${s}\x1b[0m`;
+const red = (s) => `\x1b[31m${s}\x1b[0m`;
+const bold = (s) => `\x1b[1m${s}\x1b[0m`;
+const dim = (s) => `\x1b[2m${s}\x1b[0m`;
+export default class DataFetch extends GatedCommand {
+    static description = 'Fetch and cache candle data from Hyperliquid';
+    static examples = [
+        '$ rift data fetch --pair BTC-PERP --tf 15m',
+        '$ rift data fetch --pair ETH-PERP --tf 1h --start 2025-01-01',
+        '$ rift data fetch --all --tf 1h',
+        '$ rift data fetch --top 10 --tf 4h',
+    ];
+    static flags = {
+        pair: Flags.string({ description: 'Trading pair (e.g. BTC-PERP)', default: 'BTC-PERP' }),
+        tf: Flags.string({ description: 'Timeframe / candle interval', default: '1h' }),
+        start: Flags.string({ description: 'Start date (YYYY-MM-DD)' }),
+        all: Flags.boolean({ description: 'Fetch top 20 pairs by volume', default: false }),
+        top: Flags.integer({ description: 'Fetch top N pairs by volume' }),
+    };
+    async run() {
+        const { flags } = await this.parse(DataFetch);
+        if (flags.all || flags.top) {
+            return this.fetchMulti(flags);
+        }
+        return this.fetchSingle(flags);
+    }
+    async fetchSingle(flags) {
+        const args = [flags.pair, '--tf', flags.tf];
+        if (flags.start)
+            args.push('--start', flags.start);
+        this.log(`\n  Fetching ${bold(flags.pair)} ${flags.tf} candles...`);
+        await runEngine('fetch', args, (msg) => {
+            if (msg.type === 'progress' && msg.msg) {
+                process.stdout.write(`\r  ${dim(String(msg.msg))}${''.padEnd(20)}`);
+            }
+            else if (msg.type === 'result') {
+                process.stdout.write('\r' + ' '.repeat(60) + '\r');
+                this.log(`  ${green('✔')} ${bold(String(msg.pair))} — ${msg.candles} candles`);
+            }
+            else if (msg.type === 'error') {
+                this.error(msg.msg);
+            }
+        });
+        this.log('');
+    }
+    async fetchMulti(flags) {
+        const n = flags.top || 20;
+        const topArg = `top${n}`;
+        const args = [topArg, '--tf', flags.tf];
+        if (flags.start)
+            args.push('--start', flags.start);
+        args.push('--top', String(n));
+        this.log(`\n  Fetching top ${bold(String(n))} pairs by volume (${flags.tf})...\n`);
+        await runEngine('fetch-multi', args, (msg) => {
+            if (msg.type === 'progress' && msg.msg) {
+                process.stdout.write(`\r  ${dim(String(msg.msg))}${''.padEnd(30)}`);
+            }
+            else if (msg.type === 'result') {
+                process.stdout.write('\r' + ' '.repeat(60) + '\r');
+                const results = msg.results;
+                let succeeded = 0;
+                let failed = 0;
+                for (const r of results) {
+                    if (r.status === 'ok') {
+                        this.log(`  ${green('✔')} ${bold(r.pair.padEnd(10))} ${dim(`${r.candles} candles`)}`);
+                        succeeded++;
+                    }
+                    else {
+                        this.log(`  ${red('✘')} ${bold(r.pair.padEnd(10))} ${dim(r.error || 'failed')}`);
+                        failed++;
+                    }
+                }
+                this.log('');
+                this.log(`  ${dim(`${succeeded} succeeded${failed > 0 ? `, ${failed} failed` : ''}`)}`);
+            }
+        });
+        this.log('');
+    }
+}

package/dist/commands/data/list.d.ts

@@ -0,0 +1,6 @@
+import { GatedCommand } from '../../lib/base-command.js';
+export default class DataList extends GatedCommand {
+    static description: string;
+    static examples: string[];
+    run(): Promise<void>;
+}

package/dist/commands/data/list.js

@@ -0,0 +1,28 @@
+import { GatedCommand } from '../../lib/base-command.js';
+import { runEngine } from '../../lib/python-bridge.js';
+export default class DataList extends GatedCommand {
+    static description = 'List cached candle data';
+    static examples = [
+        '$ rift data list',
+    ];
+    async run() {
+        await runEngine('list-data', [], (msg) => {
+            if (msg.type === 'result') {
+                const data = msg.data;
+                if (!data || data.length === 0) {
+                    this.log('No cached data. Run: rift data fetch --pair BTC-PERP');
+                    return;
+                }
+                this.log('');
+                this.log('  Pair          Interval    Candles     Start                  End');
+                this.log('  ──────────────────────────────────────────────────────────────────');
+                for (const d of data) {
+                    const start = new Date(d.start).toISOString().slice(0, 16);
+                    const end = new Date(d.end).toISOString().slice(0, 16);
+                    this.log(`  ${d.pair.padEnd(14)} ${d.interval.padEnd(12)} ${String(d.rows).padEnd(12)} ${start}  ${end}`);
+                }
+                this.log('');
+            }
+        });
+    }
+}

package/dist/commands/data-inventory.d.ts

@@ -0,0 +1,9 @@
+import { GatedCommand } from '../lib/base-command.js';
+export default class DataInventory extends GatedCommand {
+    static description: string;
+    static examples: string[];
+    static flags: {
+        json: import("@oclif/core/interfaces").BooleanFlag<boolean>;
+    };
+    run(): Promise<void>;
+}

package/dist/commands/data-inventory.js

@@ -0,0 +1,24 @@
+import { Flags } from '@oclif/core';
+import { GatedCommand } from '../lib/base-command.js';
+import { passthroughToEngine } from '../lib/engine-passthrough.js';
+export default class DataInventory extends GatedCommand {
+    static description = 'Inventory of locally cached candles, funding, fills — counts + freshness';
+    static examples = [
+        '$ rift data-inventory',
+        '$ rift data-inventory --json',
+    ];
+    static flags = {
+        json: Flags.boolean({ description: 'Emit raw JSON only', default: false }),
+    };
+    async run() {
+        const { flags } = await this.parse(DataInventory);
+        await passthroughToEngine({
+            command: 'data-inventory',
+            args: [],
+            log: (m) => this.log(m),
+            error: (m) => this.error(m),
+            exit: (c) => this.exit(c),
+            jsonOnly: flags.json,
+        });
+    }
+}

package/dist/commands/deposit.d.ts

@@ -0,0 +1,10 @@
+import { GatedCommand } from '../lib/base-command.js';
+export default class Deposit extends GatedCommand {
+    static description: string;
+    static examples: string[];
+    static args: {
+        amount: import("@oclif/core/interfaces").Arg<string, Record<string, unknown>>;
+    };
+    static flags: {};
+    run(): Promise<void>;
+}