minara 0.2.4 → 0.2.6

package/README.md

@@ -19,9 +19,10 @@
 ## Features
 
 - **AI Chat** — Crypto-native AI for on-chain analysis, market research, and DeFi due diligence. Interactive REPL & single-shot queries with `fast` / `quality` / `thinking` modes
-- **Wallet & Balance** — Unified balance view, spot holdings with PnL, perps account overview, deposits and withdrawals
+- **Wallet & Balance** — Unified balance view, spot holdings with PnL, perps account overview, deposits, withdrawals, and credit card on-ramp via MoonPay
 - **Chain-Abstracted Trading** — Cross-chain swaps with automatic chain detection, perpetual futures, and limit orders. Accepts `$TICKER`, token name, or contract address
-- **Market Discovery** — Trending tokens, Fear & Greed Index, on-chain metrics, and token / stock search
+- **AI Autopilot & Analysis** — Fully managed AI trading strategies for perps, plus on-demand long/short analysis with one-click quick order
+- **Market Discovery** — Trending tokens & stocks, Fear & Greed Index, on-chain metrics, and search
 
 ## Installation
 
@@ -68,7 +69,7 @@ minara discover trending
 
 | Command          | Description                                 |
 | ---------------- | ------------------------------------------- |
-| `minara login`   | Login via device code or email               |
+| `minara login`   | Login via device code or email              |
 | `minara logout`  | Logout and clear local credentials          |
 | `minara account` | View your account info and wallet addresses |
 
@@ -80,23 +81,25 @@ minara login -e user@mail.com # Email verification code
 
 ### Wallet & Funds
 
-| Command               | Description                                     |
-| --------------------- | ----------------------------------------------- |
-| `minara balance`      | Combined USDC/USDT balance across spot and perps |
-| `minara assets`       | Full overview: spot holdings + perps account     |
-| `minara assets spot`  | Spot wallet: portfolio value, cost, PnL, holdings |
-| `minara assets perps` | Perps account: equity, margin, positions         |
-| `minara deposit`      | Deposit to spot (view addresses) or perps (direct / from spot) |
-| `minara withdraw`     | Withdraw tokens to an external wallet            |
+| Command               | Description                                                    |
+| --------------------- | -------------------------------------------------------------- |
+| `minara balance`      | Combined USDC/USDT balance across spot and perps               |
+| `minara assets`       | Full overview: spot holdings + perps account                   |
+| `minara assets spot`  | Spot wallet: portfolio value, cost, PnL, holdings              |
+| `minara assets perps` | Perps account: equity, margin, positions                       |
+| `minara deposit`      | Deposit to spot, perps, or buy crypto with credit card         |
+| `minara deposit buy`  | Buy crypto with credit card via MoonPay                        |
+| `minara withdraw`     | Withdraw tokens to an external wallet                          |
 
 ```bash
 minara balance                    # Quick total: Spot + Perps available balance
 minara assets                     # Full overview (spot + perps)
 minara assets spot                # Spot wallet with PnL breakdown
 minara assets perps               # Perps equity, margin, positions
-minara deposit                    # Interactive: Spot (addresses) or Perps (address / transfer)
+minara deposit                    # Interactive: Spot / Perps / Buy with credit card
 minara deposit spot               # Show spot wallet deposit addresses (EVM + Solana)
 minara deposit perps              # Perps: show Arbitrum deposit address, or transfer from Spot → Perps
+minara deposit buy                # Buy crypto with credit card via MoonPay (opens browser)
 minara withdraw -c solana -t '$SOL' -a 10 --to <address>
 minara withdraw                   # Interactive mode (accepts ticker or address)
 ```
@@ -121,25 +124,35 @@ minara swap --dry-run              # Simulate without executing
 
 ### Perpetual Futures
 
-| Command                     | Description                               |
-| --------------------------- | ----------------------------------------- |
+| Command                     | Description                                           |
+| --------------------------- | ----------------------------------------------------- |
+| `minara perps positions`    | View all open positions with PnL                      |
+| `minara perps order`        | Place an order (interactive builder)                  |
+| `minara perps cancel`       | Cancel open orders                                    |
+| `minara perps leverage`     | Update leverage for a symbol                          |
+| `minara perps trades`       | View trade history (Hyperliquid fills)                |
 | `minara perps deposit`      | Deposit USDC to perps (or use `minara deposit perps`) |
-| `minara perps withdraw`     | Withdraw USDC from perps account          |
-| `minara perps positions`    | View all open positions                   |
-| `minara perps order`        | Place an order (interactive builder)      |
-| `minara perps cancel`       | Cancel open orders                        |
-| `minara perps leverage`     | Update leverage for a symbol              |
-| `minara perps trades`       | View completed trade history              |
-| `minara perps fund-records` | View fund deposit/withdrawal records      |
+| `minara perps withdraw`     | Withdraw USDC from perps account                      |
+| `minara perps fund-records` | View fund deposit/withdrawal records                  |
+| `minara perps autopilot`    | Manage AI autopilot trading strategy (on/off/config)  |
+| `minara perps ask`          | AI long/short analysis with quick order               |
 
 ```bash
+minara perps positions             # List positions with equity, margin, PnL
+minara perps order                 # Interactive: symbol selector → side → size → confirm
+minara perps leverage              # Interactive: shows max leverage per asset
+minara perps trades                # Recent fills from Hyperliquid (default 7 days)
+minara perps trades -d 30          # Last 30 days of trade history
 minara perps deposit -a 100        # Deposit 100 USDC to perps
 minara perps withdraw -a 50        # Withdraw 50 USDC from perps
-minara perps positions             # List current positions
-minara perps order                 # Interactive: choose symbol, side, size, price
-minara perps leverage              # Interactive: set leverage for a trading pair
+minara perps autopilot             # Toggle AI autopilot, create/update strategy
+minara perps ask                   # AI analysis → optional quick order
 ```
 
+> **Autopilot:** When autopilot is ON, manual order placement (`minara perps order`) is blocked to prevent conflicts with AI-managed trades. Turn off autopilot first via `minara perps autopilot`.
+>
+> **Ask AI → Quick Order:** After the AI analysis, you can instantly place a market order based on the recommended direction, entry price, and position size — no need to re-enter parameters.
+
 ### Limit Orders
 
 | Command                          | Description                          |

package/dist/api/payment.d.ts

@@ -15,3 +15,7 @@ export declare function checkoutPackage(token: string, packageId: string, succes
 export declare function cryptoCheckoutPackage(token: string, packageId: string): Promise<import("../types.js").ApiResponse<CryptoCheckout>>;
 /** Cancel current subscription */
 export declare function cancelSubscription(token: string): Promise<import("../types.js").ApiResponse<Record<string, unknown>>>;
+/** Sign a MoonPay widget URL (backend appends HMAC signature). */
+export declare function getMoonPaySignature(token: string, url: string): Promise<import("../types.js").ApiResponse<{
+    signature: string;
+}>>;

package/dist/api/payment.js

@@ -1,4 +1,4 @@
-import { get, del } from './client.js';
+import { get, post, del } from './client.js';
 /** Get all subscription plans and credit packages */
 export function getPlans() {
     return get('/payment/plans');
@@ -37,3 +37,7 @@ export function cryptoCheckoutPackage(token, packageId) {
 export function cancelSubscription(token) {
     return del('/payment/subscription', { token });
 }
+/** Sign a MoonPay widget URL (backend appends HMAC signature). */
+export function getMoonPaySignature(token, url) {
+    return post('/payment/moonpay/signature', { token, body: { url } });
+}

package/dist/api/perps.d.ts

@@ -27,3 +27,61 @@ export declare function getAccountSummary(token: string): Promise<import("../typ
 export declare function getDecisions(token: string): Promise<import("../types.js").ApiResponse<Record<string, unknown>[]>>;
 /** Claim rewards */
 export declare function claimRewards(token: string): Promise<import("../types.js").ApiResponse<TransactionResult>>;
+export declare function getStrategies(token: string): Promise<import("../types.js").ApiResponse<Record<string, unknown>[]>>;
+export declare function getSupportedSymbols(token: string): Promise<import("../types.js").ApiResponse<string[]>>;
+export declare function createStrategy(token: string, dto: {
+    symbols: string[];
+    strategyConfig?: Record<string, unknown>;
+    language?: string;
+}): Promise<import("../types.js").ApiResponse<Record<string, unknown>>>;
+export declare function enableStrategy(token: string, strategyId: string): Promise<import("../types.js").ApiResponse<Record<string, unknown>>>;
+export declare function disableStrategy(token: string, strategyId: string): Promise<import("../types.js").ApiResponse<Record<string, unknown>>>;
+export declare function updateStrategy(token: string, dto: {
+    strategyId: string;
+    symbols: string[];
+    strategyConfig?: Record<string, unknown>;
+    language?: string;
+}): Promise<import("../types.js").ApiResponse<Record<string, unknown>>>;
+export declare function getPerformanceMetrics(token: string): Promise<import("../types.js").ApiResponse<Record<string, unknown>>>;
+export declare function priceAnalysis(token: string, dto: {
+    symbol: string;
+    startTime?: number;
+    endTime?: number;
+    interval?: string;
+    positionUSD?: number;
+    leverage?: number;
+}): Promise<import("../types.js").ApiResponse<Record<string, unknown>>>;
+/** Get perps wallet address from user profile */
+export declare function getPerpsAddress(token: string): Promise<string | null>;
+export interface HlAssetMeta {
+    name: string;
+    maxLeverage: number;
+    szDecimals: number;
+}
+export interface HlAssetInfo extends HlAssetMeta {
+    markPx: number;
+}
+/** Fetch perpetuals universe metadata + live prices from Hyperliquid (cached per session). */
+export declare function getAssetMeta(): Promise<HlAssetInfo[]>;
+export interface HlFill {
+    coin: string;
+    px: string;
+    sz: string;
+    side: string;
+    time: number;
+    dir: string;
+    closedPnl: string;
+    fee: string;
+    oid: number;
+    tid: number;
+}
+/** Fetch user trade fills directly from Hyperliquid (last 7 days by default). */
+export declare function getUserFills(address: string, days?: number): Promise<HlFill[]>;
+export interface HlLeverageInfo {
+    coin: string;
+    leverageType: string;
+    leverageValue: number;
+    maxLeverage: number;
+}
+/** Fetch user's per-asset leverage from Hyperliquid clearinghouseState. */
+export declare function getUserLeverage(address: string): Promise<HlLeverageInfo[]>;

package/dist/api/perps.js

@@ -55,3 +55,100 @@ export function getDecisions(token) {
 export function claimRewards(token) {
     return post('/v1/tx/perps/claim-rewards', { token });
 }
+// ── Autopilot (Fully Managed Strategy) ───────────────────────────────────
+export function getStrategies(token) {
+    return get('/v1/fully-managed/strategies', { token });
+}
+export function getSupportedSymbols(token) {
+    return get('/v1/fully-managed/supported-symbols', { token });
+}
+export function createStrategy(token, dto) {
+    return post('/v1/fully-managed/create-strategy', { token, body: dto });
+}
+export function enableStrategy(token, strategyId) {
+    return post('/v1/fully-managed/enable-strategy', { token, body: { strategyId } });
+}
+export function disableStrategy(token, strategyId) {
+    return post('/v1/fully-managed/disable-strategy', { token, body: { strategyId } });
+}
+export function updateStrategy(token, dto) {
+    return post('/v1/fully-managed/update-strategy', { token, body: dto });
+}
+export function getPerformanceMetrics(token) {
+    return get('/v1/fully-managed/performance/metrics/v2', { token });
+}
+// ── Price Analysis (Ask Long/Short) ──────────────────────────────────────
+export function priceAnalysis(token, dto) {
+    return post('/tokens/price-analysis', { token, body: dto });
+}
+/** Get perps wallet address from user profile */
+export async function getPerpsAddress(token) {
+    const res = await get('/auth/me', { token });
+    if (!res.success || !res.data)
+        return null;
+    return res.data.wallets?.['perpetual-evm'] ?? null;
+}
+let _assetInfoCache = null;
+/** Fetch perpetuals universe metadata + live prices from Hyperliquid (cached per session). */
+export async function getAssetMeta() {
+    if (_assetInfoCache)
+        return _assetInfoCache;
+    try {
+        const res = await fetch('https://api.hyperliquid.xyz/info', {
+            method: 'POST',
+            headers: { 'Content-Type': 'application/json' },
+            body: JSON.stringify({ type: 'metaAndAssetCtxs' }),
+        });
+        const json = (await res.json());
+        const [meta, ctxs] = json;
+        _assetInfoCache = (meta.universe ?? []).map((m, i) => ({
+            ...m,
+            markPx: Number(ctxs?.[i]?.markPx ?? 0),
+        }));
+        return _assetInfoCache;
+    }
+    catch {
+        return [];
+    }
+}
+/** Fetch user trade fills directly from Hyperliquid (last 7 days by default). */
+export async function getUserFills(address, days = 7) {
+    try {
+        const startTime = Date.now() - days * 24 * 60 * 60 * 1000;
+        const res = await fetch('https://api.hyperliquid.xyz/info', {
+            method: 'POST',
+            headers: { 'Content-Type': 'application/json' },
+            body: JSON.stringify({
+                type: 'userFillsByTime',
+                user: address,
+                startTime,
+                aggregateByTime: true,
+            }),
+        });
+        const data = await res.json();
+        return Array.isArray(data) ? data : [];
+    }
+    catch {
+        return [];
+    }
+}
+/** Fetch user's per-asset leverage from Hyperliquid clearinghouseState. */
+export async function getUserLeverage(address) {
+    try {
+        const res = await fetch('https://api.hyperliquid.xyz/info', {
+            method: 'POST',
+            headers: { 'Content-Type': 'application/json' },
+            body: JSON.stringify({ type: 'clearinghouseState', user: address }),
+        });
+        const data = (await res.json());
+        return (data.assetPositions ?? []).map((ap) => ({
+            coin: ap.position.coin,
+            leverageType: ap.position.leverage.type,
+            leverageValue: ap.position.leverage.value,
+            maxLeverage: ap.position.maxLeverage,
+        }));
+    }
+    catch {
+        return [];
+    }
+}

package/dist/commands/deposit.js

@@ -5,7 +5,7 @@ import { getAccount } from '../api/crosschain.js';
 import { getCurrentUser } from '../api/auth.js';
 import * as perpsApi from '../api/perps.js';
 import { requireAuth } from '../config.js';
-import { info, success, spinner, assertApiOk, wrapAction, requireTransactionConfirmation } from '../utils.js';
+import { info, success, warn, spinner, assertApiOk, wrapAction, requireTransactionConfirmation, openBrowser } from '../utils.js';
 import { requireTouchId } from '../touchid.js';
 import { printTxResult } from '../formatters.js';
 const EVM_CHAINS = 'Ethereum, Base, Arbitrum, Optimism, Polygon, Avalanche, BSC, Berachain, Blast';
@@ -52,6 +52,55 @@ async function showSpotDeposit(token) {
     console.log(chalk.red('  • Sending tokens on the wrong network may result in permanent loss.'));
     console.log('');
 }
+// ─── moonpay (credit card on-ramp) ───────────────────────────────────────
+const MOONPAY_PK = 'pk_live_yIf64w79W6ufwip4j51PWbymdwGtI';
+const MOONPAY_CURRENCIES = [
+    { name: 'USDC (Base)', code: 'usdc_base', network: 'base' },
+    { name: 'USDC (Ethereum)', code: 'usdc', network: 'ethereum' },
+    { name: 'USDC (Arbitrum)', code: 'usdc_arbitrum', network: 'arbitrum' },
+    { name: 'USDC (Polygon)', code: 'usdc_polygon', network: 'polygon' },
+    { name: 'ETH', code: 'eth', network: 'ethereum' },
+    { name: 'ETH (Base)', code: 'eth_base', network: 'base' },
+    { name: 'SOL', code: 'sol', network: 'solana' },
+];
+async function moonPayOnRamp(token) {
+    const addrSpin = spinner('Fetching wallet address…');
+    const accountRes = await getAccount(token);
+    addrSpin.stop();
+    const account = accountRes.data;
+    const evmAddr = account?.evmAddress;
+    const solAddr = account?.solanaAddress;
+    if (!evmAddr && !solAddr) {
+        warn('No wallet address found. Your account may not be fully initialized.');
+        return;
+    }
+    const currency = await select({
+        message: 'Currency to buy:',
+        choices: MOONPAY_CURRENCIES
+            .filter((c) => c.network === 'solana' ? !!solAddr : !!evmAddr)
+            .map((c) => ({ name: c.name, value: c })),
+    });
+    const walletAddress = currency.network === 'solana' ? solAddr : evmAddr;
+    // Build MoonPay buy URL (no walletAddress in URL — requires server-side signing
+    // which depends on backend MoonPay secret key config).
+    // User pastes their address in MoonPay's form instead.
+    const params = new URLSearchParams();
+    params.set('apiKey', MOONPAY_PK);
+    params.set('currencyCode', currency.code);
+    params.set('defaultCurrencyCode', currency.code);
+    const buyUrl = `https://buy.moonpay.com?${params.toString()}`;
+    console.log('');
+    console.log(chalk.bold('Buy Crypto with Credit Card (MoonPay)'));
+    console.log('');
+    console.log(`  Currency : ${chalk.cyan(currency.name)}`);
+    console.log(`  Wallet   : ${chalk.yellow(walletAddress)}`);
+    console.log(chalk.dim('  ↑ Copy this address and paste it in MoonPay when prompted.'));
+    console.log('');
+    info('Opening MoonPay in your browser…');
+    openBrowser(buyUrl);
+    console.log(chalk.dim('  Complete the purchase in your browser. Funds will arrive in your Minara wallet.'));
+    console.log('');
+}
 // ─── perps ───────────────────────────────────────────────────────────────
 const perpsCmd = new Command('perps')
     .description('Deposit USDC to perps account')
@@ -128,23 +177,34 @@ async function transferSpotToPerps(token, opts) {
     printTxResult(res.data);
 }
 // ─── parent ──────────────────────────────────────────────────────────────
+const buyCmd = new Command('buy')
+    .description('Buy crypto with credit card via MoonPay')
+    .action(wrapAction(async () => {
+    const creds = requireAuth();
+    await moonPayOnRamp(creds.accessToken);
+}));
 export const depositCommand = new Command('deposit')
-    .description('Deposit to spot wallet or perps account')
+    .description('Deposit to spot wallet or perps account, or buy with credit card')
     .addCommand(spotCmd)
     .addCommand(perpsCmd)
+    .addCommand(buyCmd)
     .action(wrapAction(async () => {
     const action = await select({
         message: 'Deposit to:',
         choices: [
             { name: 'Spot wallet — view deposit addresses', value: 'spot' },
             { name: 'Perps wallet — view deposit address or transfer from Spot', value: 'perps' },
+            { name: `Buy crypto with credit card ${chalk.dim('(MoonPay)')}`, value: 'buy' },
         ],
     });
     const creds = requireAuth();
     if (action === 'spot') {
         await showSpotDeposit(creds.accessToken);
     }
-    else {
+    else if (action === 'perps') {
         await perpsDepositFlow(creds.accessToken);
     }
+    else {
+        await moonPayOnRamp(creds.accessToken);
+    }
 }));

package/dist/commands/perps.js

@@ -5,7 +5,7 @@ import * as perpsApi from '../api/perps.js';
 import { requireAuth } from '../config.js';
 import { success, info, warn, spinner, assertApiOk, formatOrderSide, wrapAction, requireTransactionConfirmation } from '../utils.js';
 import { requireTouchId } from '../touchid.js';
-import { printTxResult, printTable, POSITION_COLUMNS } from '../formatters.js';
+import { printTxResult, printTable, printKV, POSITION_COLUMNS, FILL_COLUMNS } from '../formatters.js';
 // ─── deposit ─────────────────────────────────────────────────────────────
 const depositCmd = new Command('deposit')
     .description('Deposit USDC into Hyperliquid perps (min 5 USDC)')
@@ -73,19 +73,34 @@ const positionsCmd = new Command('positions')
     .action(wrapAction(async () => {
     const creds = requireAuth();
     const spin = spinner('Fetching positions…');
-    const res = await perpsApi.getPositions(creds.accessToken);
+    const res = await perpsApi.getAccountSummary(creds.accessToken);
     spin.stop();
-    assertApiOk(res, 'Failed to fetch positions');
-    const positions = res.data;
-    if (!positions || (Array.isArray(positions) && positions.length === 0)) {
-        console.log(chalk.dim('No open positions.'));
+    if (!res.success || !res.data) {
+        console.log(chalk.dim('Could not fetch positions.'));
+        if (res.error?.message)
+            console.log(chalk.dim(`  ${res.error.message}`));
+        return;
+    }
+    const d = res.data;
+    const fmt = (n) => `$${n.toLocaleString('en-US', { minimumFractionDigits: 2, maximumFractionDigits: 2 })}`;
+    const pnlFmt = (n) => {
+        const color = n >= 0 ? chalk.green : chalk.red;
+        return color(`${n >= 0 ? '+' : ''}${fmt(n)}`);
+    };
+    console.log('');
+    console.log(`  Equity        : ${fmt(Number(d.equityValue ?? 0))}`);
+    console.log(`  Unrealized PnL: ${pnlFmt(Number(d.totalUnrealizedPnl ?? 0))}`);
+    console.log(`  Margin Used   : ${fmt(Number(d.totalMarginUsed ?? 0))}`);
+    const positions = Array.isArray(d.positions) ? d.positions : [];
+    console.log('');
+    console.log(chalk.bold(`Open Positions (${positions.length}):`));
+    if (positions.length === 0) {
+        console.log(chalk.dim('  No open positions.'));
     }
     else {
-        console.log('');
-        console.log(chalk.bold('Open Positions:'));
         printTable(positions, POSITION_COLUMNS);
-        console.log('');
     }
+    console.log('');
 }));
 // ─── order ───────────────────────────────────────────────────────────────
 const orderCmd = new Command('order')
@@ -93,19 +108,29 @@ const orderCmd = new Command('order')
     .option('-y, --yes', 'Skip confirmation')
     .action(wrapAction(async (opts) => {
     const creds = requireAuth();
+    // Check autopilot — block manual orders while AI is trading
+    const apSpin = spinner('Checking autopilot…');
+    const apState = await getAutopilotState(creds.accessToken);
+    apSpin.stop();
+    if (apState.active) {
+        console.log('');
+        warn('Autopilot is currently ON. Manual order placement is disabled while AI is trading.');
+        info(`Trading symbols: ${apState.symbols?.join(', ') ?? 'unknown'}`);
+        info('Turn off autopilot first: minara perps autopilot');
+        console.log('');
+        return;
+    }
     info('Building a Hyperliquid perps order…');
-    // Fetch prices for reference (non-blocking — failure is OK)
-    const pricesSpin = spinner('Fetching token prices…');
-    const pricesRes = await perpsApi.getTokenPrices(creds.accessToken);
-    pricesSpin.stop();
-    if (pricesRes.success && pricesRes.data) {
-        console.log(chalk.dim('Current prices:'));
-        const prices = pricesRes.data;
-        for (const p of prices.slice(0, 10)) {
-            console.log(chalk.dim(`  ${p.symbol ?? '?'}: $${p.price ?? '?'}`));
-        }
-        if (prices.length > 10)
-            console.log(chalk.dim(`  … and ${prices.length - 10} more`));
+    const dataSpin = spinner('Fetching market data…');
+    const address = await perpsApi.getPerpsAddress(creds.accessToken);
+    const [assets, leverages] = await Promise.all([
+        perpsApi.getAssetMeta(),
+        address ? perpsApi.getUserLeverage(address) : Promise.resolve([]),
+    ]);
+    dataSpin.stop();
+    const leverageMap = new Map();
+    for (const l of leverages) {
+        leverageMap.set(l.coin.toUpperCase(), { value: l.leverageValue, type: l.leverageType });
     }
     const isBuy = await select({
         message: 'Side:',
@@ -114,15 +139,57 @@ const orderCmd = new Command('order')
             { name: 'Short (sell)', value: false },
         ],
     });
-    const asset = await input({ message: 'Asset symbol (e.g. BTC, ETH):' });
+    let asset;
+    if (assets.length > 0) {
+        asset = await select({
+            message: 'Asset:',
+            choices: assets.map((a) => {
+                const pxStr = a.markPx > 0 ? `$${a.markPx.toLocaleString()}` : '';
+                const lev = leverageMap.get(a.name.toUpperCase());
+                const levStr = lev ? `${lev.value}x ${lev.type}` : '';
+                return {
+                    name: `${a.name.padEnd(6)} ${chalk.dim(pxStr.padStart(12))}  ${chalk.dim(`max ${a.maxLeverage}x`)}${levStr ? `  ${chalk.cyan(levStr)}` : ''}`,
+                    value: a.name,
+                };
+            }),
+        });
+    }
+    else {
+        asset = await input({ message: 'Asset symbol (e.g. BTC, ETH):' });
+    }
+    const currentLev = leverageMap.get(asset.toUpperCase());
+    if (currentLev) {
+        info(`Current leverage: ${currentLev.value}x (${currentLev.type})`);
+    }
+    else {
+        info(`No leverage set for ${asset} — use 'minara perps leverage' to configure`);
+    }
     const orderType = await select({
         message: 'Order type:',
         choices: [
+            { name: 'Market', value: 'market' },
             { name: 'Limit', value: 'limit' },
-            { name: 'Market (trigger)', value: 'market' },
         ],
     });
-    const limitPx = await input({ message: `Price (${orderType === 'limit' ? 'limit' : 'trigger'}):` });
+    const assetMeta = assets.find((a) => a.name.toUpperCase() === asset.toUpperCase());
+    let limitPx;
+    let marketPx;
+    if (orderType === 'limit') {
+        limitPx = await input({ message: 'Limit price:' });
+    }
+    else {
+        marketPx = assetMeta?.markPx;
+        if (marketPx && marketPx > 0) {
+            const slippagePx = isBuy ? marketPx * 1.01 : marketPx * 0.99;
+            limitPx = slippagePx.toPrecision(6);
+            info(`Market order at ~$${marketPx}`);
+        }
+        else {
+            warn(`Could not fetch current price for ${asset}. Enter the approximate market price.`);
+            limitPx = await input({ message: 'Price:' });
+            marketPx = Number(limitPx);
+        }
+    }
     const sz = await input({ message: 'Size (in contracts):' });
     const reduceOnly = await confirm({ message: 'Reduce only?', default: false });
     const grouping = await select({
@@ -141,26 +208,24 @@ const orderCmd = new Command('order')
         r: reduceOnly,
         t: orderType === 'limit'
             ? { limit: { tif: 'Gtc' } }
-            : { trigger: { triggerPx: limitPx, tpsl: 'tp', isMarket: true } },
+            : { trigger: { triggerPx: String(marketPx ?? limitPx), tpsl: 'tp', isMarket: true } },
     };
+    const priceLabel = orderType === 'market' ? `Market (~$${marketPx ?? limitPx})` : `$${limitPx}`;
+    const levLabel = currentLev ? `${currentLev.value}x (${currentLev.type})` : '—';
     console.log('');
     console.log(chalk.bold('Order Preview:'));
     console.log(`  Asset        : ${chalk.bold(order.a)}`);
     console.log(`  Side         : ${formatOrderSide(order.b ? 'buy' : 'sell')}`);
-    console.log(`  Price        : ${chalk.yellow(order.p)}`);
+    console.log(`  Leverage     : ${chalk.cyan(levLabel)}`);
+    console.log(`  Type         : ${orderType === 'market' ? 'Market' : 'Limit (GTC)'}`);
+    console.log(`  Price        : ${chalk.yellow(priceLabel)}`);
     console.log(`  Size         : ${chalk.bold(order.s)}`);
     console.log(`  Reduce Only  : ${order.r ? chalk.yellow('Yes') : 'No'}`);
-    console.log(`  Type         : ${'limit' in order.t ? 'Limit (GTC)' : 'Trigger'}`);
     console.log(`  Grouping     : ${grouping}`);
     console.log('');
     if (!opts.yes) {
-        const ok = await confirm({ message: 'Submit order?', default: false });
-        if (!ok) {
-            console.log(chalk.dim('Cancelled.'));
-            return;
-        }
+        await requireTransactionConfirmation(`Perps ${order.b ? 'LONG' : 'SHORT'} ${order.a} · size ${order.s} @ ${priceLabel}`);
     }
-    await requireTransactionConfirmation(`Perps ${order.b ? 'LONG' : 'SHORT'} ${order.a} · size ${order.s} @ ${order.p}`);
     await requireTouchId();
     const spin = spinner('Placing order…');
     const res = await perpsApi.placeOrders(creds.accessToken, { orders: [order], grouping });
@@ -175,7 +240,25 @@ const cancelCmd = new Command('cancel')
     .option('-y, --yes', 'Skip confirmation')
     .action(wrapAction(async (opts) => {
     const creds = requireAuth();
-    const asset = await input({ message: 'Asset symbol to cancel (e.g. BTC):' });
+    const metaSpin = spinner('Fetching assets…');
+    const assets = await perpsApi.getAssetMeta();
+    metaSpin.stop();
+    let asset;
+    if (assets.length > 0) {
+        asset = await select({
+            message: 'Asset to cancel:',
+            choices: assets.map((a) => {
+                const pxStr = a.markPx > 0 ? `$${a.markPx.toLocaleString()}` : '';
+                return {
+                    name: `${a.name.padEnd(6)} ${chalk.dim(pxStr.padStart(12))}  ${chalk.dim(`max ${a.maxLeverage}x`)}`,
+                    value: a.name,
+                };
+            }),
+        });
+    }
+    else {
+        asset = await input({ message: 'Asset symbol to cancel (e.g. BTC):' });
+    }
     const oid = await input({
         message: 'Order ID (oid):',
         validate: (v) => {
@@ -200,8 +283,33 @@ const leverageCmd = new Command('leverage')
     .description('Update leverage for a symbol')
     .action(wrapAction(async () => {
     const creds = requireAuth();
-    const symbol = await input({ message: 'Symbol (e.g. BTC):' });
-    const leverage = await numberPrompt({ message: 'Leverage:', min: 1, max: 100, required: true });
+    const metaSpin = spinner('Fetching available assets…');
+    const assets = await perpsApi.getAssetMeta();
+    metaSpin.stop();
+    let symbol;
+    if (assets.length > 0) {
+        symbol = await select({
+            message: 'Asset:',
+            choices: assets.map((a) => {
+                const pxStr = a.markPx > 0 ? `$${a.markPx.toLocaleString()}` : '';
+                return {
+                    name: `${a.name.padEnd(6)} ${chalk.dim(pxStr.padStart(12))}  ${chalk.dim(`max ${a.maxLeverage}x`)}`,
+                    value: a.name,
+                };
+            }),
+        });
+    }
+    else {
+        symbol = await input({ message: 'Symbol (e.g. BTC):' });
+    }
+    const meta = assets.find((a) => a.name.toUpperCase() === symbol.toUpperCase());
+    const maxLev = meta?.maxLeverage ?? 50;
+    const leverage = await numberPrompt({
+        message: `Leverage (1–${maxLev}x):`,
+        min: 1,
+        max: maxLev,
+        required: true,
+    });
     const isCross = await select({
         message: 'Margin mode:',
         choices: [
@@ -217,20 +325,43 @@ const leverageCmd = new Command('leverage')
 }));
 // ─── trades ──────────────────────────────────────────────────────────────
 const tradesCmd = new Command('trades')
-    .description('View completed perps trades')
-    .action(wrapAction(async () => {
+    .description('View your perps trade fills')
+    .option('-n, --count <n>', 'Number of recent fills to show', '20')
+    .option('-d, --days <n>', 'Look back N days', '7')
+    .action(wrapAction(async (opts) => {
     const creds = requireAuth();
-    const spin = spinner('Fetching trades…');
-    const res = await perpsApi.getCompletedTrades(creds.accessToken);
+    const spin = spinner('Fetching trade history…');
+    const address = await perpsApi.getPerpsAddress(creds.accessToken);
+    if (!address) {
+        spin.stop();
+        warn('Could not find your perps wallet address. Make sure your perps account is initialized.');
+        return;
+    }
+    const days = Math.max(1, parseInt(opts.days, 10) || 7);
+    const fills = await perpsApi.getUserFills(address, days);
     spin.stop();
-    assertApiOk(res, 'Failed to fetch trades');
+    const limit = Math.max(1, parseInt(opts.count, 10) || 20);
+    const recent = fills.slice(0, limit);
+    const totalPnl = fills.reduce((s, f) => s + Number(f.closedPnl ?? 0), 0);
+    const totalFees = fills.reduce((s, f) => s + Number(f.fee ?? 0), 0);
+    const closingFills = fills.filter((f) => Number(f.closedPnl ?? 0) !== 0);
+    const wins = closingFills.filter((f) => Number(f.closedPnl) > 0).length;
+    const pnlColor = totalPnl >= 0 ? chalk.green : chalk.red;
+    const fmt = (n) => `$${n.toLocaleString('en-US', { minimumFractionDigits: 2, maximumFractionDigits: 2 })}`;
     console.log('');
-    console.log(chalk.bold('Completed Trades:'));
-    if (Array.isArray(res.data) && res.data.length > 0) {
-        printTable(res.data);
+    console.log(chalk.bold(`Trade Fills (last ${days}d — ${fills.length} fills):`));
+    console.log(`  Realized PnL : ${pnlColor(`${totalPnl >= 0 ? '+' : ''}${fmt(totalPnl)}`)}`);
+    console.log(`  Total Fees   : ${chalk.dim(fmt(totalFees))}`);
+    if (closingFills.length > 0) {
+        console.log(`  Win Rate     : ${wins}/${closingFills.length} (${((wins / closingFills.length) * 100).toFixed(1)}%)`);
+    }
+    console.log('');
+    if (recent.length > 0) {
+        console.log(chalk.dim(`Showing ${recent.length} most recent:`));
+        printTable(recent, FILL_COLUMNS);
     }
     else {
-        console.log(chalk.dim('  No completed trades.'));
+        console.log(chalk.dim('  No trade fills in this period.'));
     }
     console.log('');
 }));
@@ -255,31 +386,352 @@ const fundRecordsCmd = new Command('fund-records')
     }
     console.log('');
 }));
+async function getAutopilotState(token) {
+    const res = await perpsApi.getStrategies(token);
+    if (!res.success || !res.data)
+        return { active: false };
+    // Response may be an array or { data: [...] } or nested object
+    let strategies = [];
+    const raw = res.data;
+    if (Array.isArray(raw)) {
+        strategies = raw;
+    }
+    else if (raw && typeof raw === 'object') {
+        // Might be wrapped in { strategies: [...] } or { data: [...] }
+        const inner = raw.strategies
+            ?? raw.data
+            ?? raw;
+        if (Array.isArray(inner)) {
+            strategies = inner;
+        }
+        else {
+            for (const v of Object.values(raw)) {
+                if (Array.isArray(v)) {
+                    strategies.push(...v);
+                    break;
+                }
+            }
+        }
+    }
+    if (strategies.length === 0)
+        return { active: false };
+    const s = strategies[0];
+    // Check all possible status field names
+    const status = String(s.status ?? s.state ?? s.isActive ?? s.enabled ?? '').toLowerCase();
+    const isActive = status === 'active' || status === 'enabled' || status === 'running'
+        || status === 'true' || s.isActive === true || s.enabled === true;
+    return {
+        active: isActive,
+        strategyId: String(s._id ?? s.id ?? s.strategyId ?? ''),
+        symbols: Array.isArray(s.symbols) ? s.symbols : [],
+    };
+}
+// ─── autopilot ──────────────────────────────────────────────────────────
+const autopilotCmd = new Command('autopilot')
+    .alias('ap')
+    .description('Manage AI autopilot trading strategy')
+    .action(wrapAction(async () => {
+    const creds = requireAuth();
+    const statusSpin = spinner('Checking autopilot status…');
+    const state = await getAutopilotState(creds.accessToken);
+    statusSpin.stop();
+    const statusLabel = state.active ? chalk.green.bold('ON') : chalk.dim('OFF');
+    console.log('');
+    console.log(chalk.bold('Autopilot Status:') + ` ${statusLabel}`);
+    if (state.symbols && state.symbols.length > 0) {
+        console.log(`  Symbols : ${state.symbols.join(', ')}`);
+    }
+    console.log('');
+    const action = await select({
+        message: 'What would you like to do?',
+        choices: [
+            ...(state.active
+                ? [{ name: chalk.red('Turn OFF autopilot'), value: 'off' }]
+                : [{ name: chalk.green('Turn ON autopilot'), value: 'on' }]),
+            ...(!state.strategyId ? [{ name: 'Create autopilot strategy', value: 'create' }] : []),
+            ...(state.strategyId ? [{ name: 'Update symbols', value: 'update' }] : []),
+            { name: 'View performance', value: 'perf' },
+            { name: 'Back', value: 'back' },
+        ],
+    });
+    if (action === 'back')
+        return;
+    if (action === 'on' && state.strategyId) {
+        const spin = spinner('Enabling autopilot…');
+        const res = await perpsApi.enableStrategy(creds.accessToken, state.strategyId);
+        spin.stop();
+        assertApiOk(res, 'Failed to enable autopilot');
+        success('Autopilot is now ON');
+        return;
+    }
+    if (action === 'off' && state.strategyId) {
+        const ok = await confirm({ message: 'Turn off autopilot? AI will stop trading.', default: false });
+        if (!ok)
+            return;
+        const spin = spinner('Disabling autopilot…');
+        const res = await perpsApi.disableStrategy(creds.accessToken, state.strategyId);
+        spin.stop();
+        assertApiOk(res, 'Failed to disable autopilot');
+        success('Autopilot is now OFF');
+        return;
+    }
+    if (action === 'create' || (action === 'on' && !state.strategyId)) {
+        const symSpin = spinner('Fetching supported symbols…');
+        const symRes = await perpsApi.getSupportedSymbols(creds.accessToken);
+        symSpin.stop();
+        const supported = symRes.success && Array.isArray(symRes.data) ? symRes.data : ['BTC', 'ETH', 'SOL'];
+        info(`Supported symbols: ${supported.join(', ')}`);
+        const symbolsInput = await input({
+            message: 'Symbols to trade (comma-separated):',
+            default: supported.slice(0, 3).join(','),
+        });
+        const symbols = symbolsInput.split(',').map((s) => s.trim().toUpperCase()).filter(Boolean);
+        const spin = spinner('Creating autopilot strategy…');
+        const res = await perpsApi.createStrategy(creds.accessToken, { symbols });
+        spin.stop();
+        assertApiOk(res, 'Failed to create autopilot strategy');
+        success(`Autopilot created for ${symbols.join(', ')} and enabled!`);
+        return;
+    }
+    if (action === 'update' && state.strategyId) {
+        const symSpin = spinner('Fetching supported symbols…');
+        const symRes = await perpsApi.getSupportedSymbols(creds.accessToken);
+        symSpin.stop();
+        const supported = symRes.success && Array.isArray(symRes.data) ? symRes.data : ['BTC', 'ETH', 'SOL'];
+        info(`Supported: ${supported.join(', ')} | Current: ${state.symbols?.join(', ') ?? 'none'}`);
+        const symbolsInput = await input({
+            message: 'New symbols (comma-separated):',
+            default: state.symbols?.join(',') ?? '',
+        });
+        const symbols = symbolsInput.split(',').map((s) => s.trim().toUpperCase()).filter(Boolean);
+        const spin = spinner('Updating strategy…');
+        const res = await perpsApi.updateStrategy(creds.accessToken, { strategyId: state.strategyId, symbols });
+        spin.stop();
+        assertApiOk(res, 'Failed to update strategy');
+        success(`Autopilot updated: ${symbols.join(', ')}`);
+        return;
+    }
+    if (action === 'perf') {
+        const spin = spinner('Fetching performance…');
+        const res = await perpsApi.getPerformanceMetrics(creds.accessToken);
+        spin.stop();
+        if (res.success && res.data) {
+            console.log('');
+            console.log(chalk.bold('Autopilot Performance:'));
+            printKV(res.data);
+            console.log('');
+        }
+        else {
+            console.log(chalk.dim('  No performance data available.'));
+        }
+    }
+}));
+// ─── ask (long/short analysis) ──────────────────────────────────────────
+const askCmd = new Command('ask')
+    .description('Get AI trading analysis for an asset (long/short recommendation)')
+    .action(wrapAction(async () => {
+    const creds = requireAuth();
+    const dataSpin = spinner('Fetching assets…');
+    const assets = await perpsApi.getAssetMeta();
+    dataSpin.stop();
+    let symbol;
+    if (assets.length > 0) {
+        symbol = await select({
+            message: 'Asset to analyze:',
+            choices: assets.map((a) => {
+                const pxStr = a.markPx > 0 ? `$${a.markPx.toLocaleString()}` : '';
+                return { name: `${a.name.padEnd(6)} ${chalk.dim(pxStr.padStart(12))}`, value: a.name };
+            }),
+        });
+    }
+    else {
+        symbol = await input({ message: 'Symbol (e.g. BTC):' });
+    }
+    const style = await select({
+        message: 'Analysis style:',
+        choices: [
+            { name: 'Scalping (minutes–hours)', value: 'scalping' },
+            { name: 'Day Trading (hours–day)', value: 'day-trading' },
+            { name: 'Swing Trading (days–weeks)', value: 'swing-trading' },
+        ],
+    });
+    const styleConfig = {
+        'scalping': { interval: '5m', hours: 4 },
+        'day-trading': { interval: '1h', hours: 24 },
+        'swing-trading': { interval: '4h', hours: 24 * 7 },
+    };
+    const { interval, hours } = styleConfig[style] ?? styleConfig['day-trading'];
+    const endTime = Date.now();
+    const startTime = endTime - hours * 60 * 60 * 1000;
+    const marginInput = await input({ message: 'Margin in USD:', default: '1000' });
+    const leverageInput = await input({ message: 'Leverage:', default: '10' });
+    const spin = spinner(`Analyzing ${symbol}…`);
+    const res = await perpsApi.priceAnalysis(creds.accessToken, {
+        symbol,
+        startTime,
+        endTime,
+        interval,
+        positionUSD: Number(marginInput),
+        leverage: Number(leverageInput),
+    });
+    spin.stop();
+    if (!res.success || !res.data) {
+        warn(res.error?.message ?? 'Analysis failed. Try again later.');
+        return;
+    }
+    const data = res.data;
+    console.log('');
+    console.log(chalk.bold(`AI Analysis — ${symbol} (${style}):`));
+    console.log('');
+    if (typeof data === 'string') {
+        console.log(data);
+    }
+    else {
+        printKV(data);
+    }
+    console.log('');
+    // ── Quick Order ──────────────────────────────────────────────────
+    // Extract recommendation from the AI response
+    const recommendation = extractRecommendation(data, symbol, Number(marginInput), Number(leverageInput));
+    if (!recommendation)
+        return;
+    const { side, entryPrice, size } = recommendation;
+    const sideLabel = side === 'buy' ? chalk.green.bold('LONG') : chalk.red.bold('SHORT');
+    console.log(chalk.bold('Quick Order:'));
+    console.log(`  ${sideLabel} ${chalk.bold(symbol)}  |  Entry ~$${entryPrice.toLocaleString()}  |  Size ${size}  |  ${Number(leverageInput)}x`);
+    console.log('');
+    const doQuick = await confirm({ message: 'Place this order now?', default: false });
+    if (!doQuick)
+        return;
+    // Check autopilot before placing
+    const apState = await getAutopilotState(creds.accessToken);
+    if (apState.active) {
+        warn('Autopilot is ON — manual orders are disabled while AI is trading.');
+        info('Turn off autopilot first: minara perps autopilot');
+        return;
+    }
+    const isBuy = side === 'buy';
+    const slippagePx = isBuy ? entryPrice * 1.01 : entryPrice * 0.99;
+    const order = {
+        a: symbol,
+        b: isBuy,
+        p: slippagePx.toPrecision(6),
+        s: String(size),
+        r: false,
+        t: { trigger: { triggerPx: String(entryPrice), tpsl: 'tp', isMarket: true } },
+    };
+    await requireTransactionConfirmation(`Perps ${isBuy ? 'LONG' : 'SHORT'} ${symbol} · size ${size} @ ~$${entryPrice.toLocaleString()}`);
+    await requireTouchId();
+    const orderSpin = spinner('Placing order…');
+    const orderRes = await perpsApi.placeOrders(creds.accessToken, { orders: [order], grouping: 'na' });
+    orderSpin.stop();
+    assertApiOk(orderRes, 'Order placement failed');
+    success('Order submitted!');
+    printTxResult(orderRes.data);
+}));
+/** Try to extract a tradeable recommendation from the AI analysis response. */
+function extractRecommendation(data, symbol, marginUSD, leverage) {
+    if (typeof data === 'string') {
+        return parseRecommendationText(data, symbol, marginUSD, leverage);
+    }
+    // Structured response — look for common field names
+    const flat = flattenObj(data);
+    const sideRaw = String(flat['recommendation'] ?? flat['direction'] ?? flat['side'] ?? flat['signal']
+        ?? flat['action'] ?? flat['position'] ?? '').toLowerCase();
+    let side = null;
+    if (/long|buy|bullish/i.test(sideRaw))
+        side = 'buy';
+    else if (/short|sell|bearish/i.test(sideRaw))
+        side = 'sell';
+    if (!side) {
+        // Try to infer from the full JSON text
+        const jsonStr = JSON.stringify(data).toLowerCase();
+        if (/\blong\b|bullish/.test(jsonStr))
+            side = 'buy';
+        else if (/\bshort\b|bearish/.test(jsonStr))
+            side = 'sell';
+    }
+    if (!side)
+        return null;
+    const entryPrice = Number(flat['entryPrice'] ?? flat['entry_price'] ?? flat['entry'] ?? flat['price']
+        ?? flat['currentPrice'] ?? flat['current_price'] ?? flat['markPrice'] ?? 0);
+    if (!entryPrice || entryPrice <= 0)
+        return null;
+    let size = Number(flat['size'] ?? flat['contracts'] ?? flat['qty'] ?? flat['quantity'] ?? 0);
+    if (!size || size <= 0) {
+        size = parseFloat(((marginUSD * leverage) / entryPrice).toPrecision(4));
+    }
+    if (!size || size <= 0)
+        return null;
+    return { side, entryPrice, size };
+}
+function parseRecommendationText(text, symbol, marginUSD, leverage) {
+    let side = null;
+    if (/\blong\b|bullish|buy/i.test(text))
+        side = 'buy';
+    else if (/\bshort\b|bearish|sell/i.test(text))
+        side = 'sell';
+    if (!side)
+        return null;
+    const priceMatch = text.match(/entry[:\s]*\$?([\d,.]+)/i)
+        ?? text.match(/price[:\s]*\$?([\d,.]+)/i)
+        ?? text.match(/\$\s*([\d,.]+)/);
+    const entryPrice = priceMatch ? Number(priceMatch[1].replace(/,/g, '')) : 0;
+    if (!entryPrice || entryPrice <= 0)
+        return null;
+    const size = parseFloat(((marginUSD * leverage) / entryPrice).toPrecision(4));
+    if (!size || size <= 0)
+        return null;
+    return { side, entryPrice, size };
+}
+/** Recursively flatten nested object keys for easier field lookup. */
+function flattenObj(obj, prefix = '') {
+    const result = {};
+    for (const [k, v] of Object.entries(obj)) {
+        const key = prefix ? `${prefix}.${k}` : k;
+        if (v && typeof v === 'object' && !Array.isArray(v)) {
+            Object.assign(result, flattenObj(v, key));
+        }
+        else {
+            result[k] = v;
+            result[key] = v;
+        }
+    }
+    return result;
+}
 // ═════════════════════════════════════════════════════════════════════════
 //  Parent
 // ═════════════════════════════════════════════════════════════════════════
 export const perpsCommand = new Command('perps')
-    .description('Hyperliquid perpetual futures — deposit, withdraw, order, positions')
-    .addCommand(depositCmd)
-    .addCommand(withdrawCmd)
+    .description('Hyperliquid perpetual futures — order, positions, autopilot, analysis')
     .addCommand(positionsCmd)
     .addCommand(orderCmd)
     .addCommand(cancelCmd)
     .addCommand(leverageCmd)
     .addCommand(tradesCmd)
+    .addCommand(depositCmd)
+    .addCommand(withdrawCmd)
     .addCommand(fundRecordsCmd)
+    .addCommand(autopilotCmd)
+    .addCommand(askCmd)
     .action(wrapAction(async () => {
+    const creds = requireAuth();
+    // Show autopilot status inline
+    const apState = await getAutopilotState(creds.accessToken);
+    const apLabel = apState.active ? chalk.green.bold(' [ON]') : chalk.dim(' [OFF]');
     const action = await select({
         message: 'Perps — what would you like to do?',
         choices: [
-            { name: 'Deposit USDC', value: 'deposit' },
-            { name: 'Withdraw USDC', value: 'withdraw' },
+            { name: 'View positions', value: 'positions' },
             { name: 'Place order', value: 'order' },
             { name: 'Cancel order', value: 'cancel' },
-            { name: 'View positions', value: 'positions' },
             { name: 'Update leverage', value: 'leverage' },
-            { name: 'View completed trades', value: 'trades' },
+            { name: 'View trade history', value: 'trades' },
+            { name: 'Deposit USDC', value: 'deposit' },
+            { name: 'Withdraw USDC', value: 'withdraw' },
             { name: 'Fund records', value: 'fund-records' },
+            { name: `Autopilot${apLabel}`, value: 'autopilot' },
+            { name: 'Ask AI (long/short analysis)', value: 'ask' },
         ],
     });
     const sub = perpsCommand.commands.find((c) => c.name() === action || c.aliases().includes(action));

package/dist/formatters.d.ts

@@ -40,6 +40,10 @@ export declare function printTxResult(data: unknown): void;
 export declare const SPOT_COLUMNS: ColumnDef[];
 /** Perps positions — API uses snake_case field names */
 export declare const POSITION_COLUMNS: ColumnDef[];
+/** Completed perps trades */
+export declare const TRADE_COLUMNS: ColumnDef[];
+/** Hyperliquid user fills (from public API) */
+export declare const FILL_COLUMNS: ColumnDef[];
 /** Limit orders (LimitOrderInfo[]) */
 export declare const LIMIT_ORDER_COLUMNS: ColumnDef[];
 /** Trending / search tokens (TokenInfo[]) */

package/dist/formatters.js

@@ -272,6 +272,72 @@ export const POSITION_COLUMNS = [
     { key: 'leverage', label: 'Lev', format: (v) => v ? `${v}x` : chalk.dim('—') },
     { key: 'marginUsed', label: 'Margin', format: (v) => formatValue(v, 'price') },
 ];
+/** Completed perps trades */
+export const TRADE_COLUMNS = [
+    { key: 'symbol', label: 'Symbol', format: (v) => chalk.bold(String(v ?? '—').replace('USDT', '')) },
+    { key: 'side', label: 'Side', format: (v) => {
+            const s = String(v ?? '').toLowerCase();
+            return s === 'long' || s === 'buy' ? chalk.green.bold(String(v)) : chalk.red.bold(String(v));
+        } },
+    { key: 'quantity', label: 'Size', format: (v) => {
+            const n = Number(v);
+            return isNaN(n) ? String(v ?? '—') : n.toLocaleString('en-US', { maximumFractionDigits: 4 });
+        } },
+    { key: 'open_price', label: 'Open', format: (v) => formatValue(v, 'price') },
+    { key: 'close_price', label: 'Close', format: (v) => formatValue(v, 'price') },
+    { key: 'pnl', label: 'PnL', format: (v) => {
+            if (!v && v !== 0)
+                return chalk.dim('—');
+            const n = Number(v);
+            const color = n >= 0 ? chalk.green : chalk.red;
+            return color(`${n >= 0 ? '+' : ''}$${n.toLocaleString('en-US', { minimumFractionDigits: 2, maximumFractionDigits: 2 })}`);
+        } },
+    { key: 'duration', label: 'Duration' },
+    { key: 'close_time', label: 'Closed', format: (v) => {
+            if (!v)
+                return chalk.dim('—');
+            const d = new Date(String(v));
+            return isNaN(d.getTime()) ? String(v) : d.toLocaleDateString('en-US', { month: 'short', day: 'numeric', hour: '2-digit', minute: '2-digit' });
+        } },
+];
+/** Hyperliquid user fills (from public API) */
+export const FILL_COLUMNS = [
+    { key: 'coin', label: 'Asset', format: (v) => chalk.bold(String(v ?? '—')) },
+    { key: 'dir', label: 'Direction', format: (v) => {
+            const s = String(v ?? '');
+            if (/open.*long|buy/i.test(s))
+                return chalk.green.bold(s);
+            if (/close.*short/i.test(s))
+                return chalk.green(s);
+            if (/open.*short|sell/i.test(s))
+                return chalk.red.bold(s);
+            if (/close.*long/i.test(s))
+                return chalk.red(s);
+            return s;
+        } },
+    { key: 'sz', label: 'Size', format: (v) => {
+            const n = Number(v);
+            return isNaN(n) ? String(v ?? '—') : n.toLocaleString('en-US', { maximumFractionDigits: 4 });
+        } },
+    { key: 'px', label: 'Price', format: (v) => formatValue(v, 'price') },
+    { key: 'closedPnl', label: 'Realized PnL', format: (v) => {
+            const n = Number(v ?? 0);
+            if (n === 0)
+                return chalk.dim('—');
+            const color = n >= 0 ? chalk.green : chalk.red;
+            return color(`${n >= 0 ? '+' : ''}$${n.toLocaleString('en-US', { minimumFractionDigits: 2, maximumFractionDigits: 2 })}`);
+        } },
+    { key: 'fee', label: 'Fee', format: (v) => {
+            const n = Number(v ?? 0);
+            return n !== 0 ? `$${n.toLocaleString('en-US', { minimumFractionDigits: 2, maximumFractionDigits: 4 })}` : chalk.dim('—');
+        } },
+    { key: 'time', label: 'Time', format: (v) => {
+            if (!v)
+                return chalk.dim('—');
+            const d = new Date(Number(v));
+            return isNaN(d.getTime()) ? String(v) : d.toLocaleDateString('en-US', { month: 'short', day: 'numeric', hour: '2-digit', minute: '2-digit' });
+        } },
+];
 /** Limit orders (LimitOrderInfo[]) */
 export const LIMIT_ORDER_COLUMNS = [
     { key: 'id', label: 'ID', format: (v) => chalk.dim(truncate(String(v ?? ''), 12)) },

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "minara",
-  "version": "0.2.4",
+  "version": "0.2.6",
   "description": "CLI client for Minara.ai — login, trade, deposit/withdraw, chat and more from your terminal.",
   "type": "module",
   "main": "dist/index.js",