@bankr/cli 0.1.0 → 0.2.0

package/dist/commands/portfolio.js

@@ -0,0 +1,134 @@
+import chalk from "chalk";
+import { getPortfolio, } from "../lib/api.js";
+import * as output from "../lib/output.js";
+import { formatUsd, formatBalance } from "../lib/output.js";
+import { CHAIN_LABELS, VALID_CHAINS } from "../lib/chains.js";
+const BRAND = chalk.hex("#FF613D");
+const DIM = chalk.dim;
+const BOLD = chalk.bold;
+const GREEN = chalk.greenBright;
+const RED = chalk.redBright;
+const WHITE = chalk.whiteBright;
+function formatPnl(value) {
+    if (value === 0)
+        return DIM("$0.00");
+    const formatted = `$${Math.abs(value).toLocaleString("en-US", { minimumFractionDigits: 2, maximumFractionDigits: 2 })}`;
+    return value > 0 ? GREEN(`+${formatted}`) : RED(`-${formatted}`);
+}
+function printChainBalances(chain, data, showPnl) {
+    const label = CHAIN_LABELS[chain] || chain;
+    const total = parseFloat(data.total);
+    const totalStr = total > 0 ? GREEN(formatUsd(total)) : DIM(formatUsd(total));
+    console.log();
+    console.log();
+    console.log(`  ${BRAND.bold(label)}  ${totalStr}`);
+    console.log(`  ${DIM("─".repeat(showPnl ? 74 : 58))}`);
+    // Native balance
+    const nativeUsd = parseFloat(data.nativeUsd);
+    if (nativeUsd > 0 || parseFloat(data.nativeBalance) > 0) {
+        const nativeSymbol = chain === "solana" ? "SOL" : chain === "polygon" ? "POL" : "ETH";
+        console.log(`    ${BOLD(WHITE(nativeSymbol.padEnd(12)))} ${formatBalance(data.nativeBalance).padStart(18)}  ${DIM(formatUsd(nativeUsd))}`);
+    }
+    // Token balances sorted by USD value descending
+    const sorted = [...data.tokenBalances].sort((a, b) => b.token.balanceUSD - a.token.balanceUSD);
+    for (const tb of sorted) {
+        const symbol = tb.token.baseToken.symbol || "???";
+        const bal = formatBalance(tb.token.balance);
+        const usd = formatUsd(tb.token.balanceUSD);
+        let line = `    ${WHITE(symbol.padEnd(12))} ${bal.padStart(18)}  ${DIM(usd)}`;
+        if (showPnl && tb.token.pnl) {
+            line += `  ${formatPnl(tb.token.pnl.totalPnl)}`;
+        }
+        console.log(line);
+    }
+    if (sorted.length === 0 && (nativeUsd === 0 || isNaN(nativeUsd))) {
+        console.log(DIM("    No token balances"));
+    }
+}
+export async function portfolioCommand(opts) {
+    // Validate chain option
+    const chains = opts.chain
+        ? opts.chain.split(",").map((c) => c.trim().toLowerCase())
+        : undefined;
+    if (chains) {
+        const invalid = chains.filter((c) => !VALID_CHAINS.has(c));
+        if (invalid.length > 0) {
+            output.error(`Invalid chain${invalid.length > 1 ? "s" : ""}: ${invalid.join(", ")}. Valid chains: ${[...VALID_CHAINS].join(", ")}`);
+            process.exit(1);
+        }
+    }
+    const includePnl = opts.pnl || opts.all;
+    const includeNfts = opts.nfts || opts.all;
+    const include = [];
+    if (includePnl)
+        include.push("pnl");
+    if (includeNfts)
+        include.push("nfts");
+    const spinText = include.length > 0
+        ? `Fetching portfolio (${include.join(", ")})...`
+        : "Fetching portfolio...";
+    const spin = output.spinner(spinText);
+    let data;
+    try {
+        data = await getPortfolio({
+            chains,
+            showLowValueTokens: opts.lowValue,
+            include: include.length > 0 ? include : undefined,
+        });
+        spin.succeed("Portfolio loaded");
+    }
+    catch (err) {
+        spin.fail(`Failed to fetch portfolio: ${err.message}`);
+        process.exit(1);
+    }
+    // JSON output mode
+    if (opts.json) {
+        console.log(JSON.stringify(data, null, 2));
+        return;
+    }
+    // Calculate grand total
+    let grandTotal = 0;
+    const chainEntries = Object.entries(data.balances);
+    for (const [, chainData] of chainEntries) {
+        grandTotal += parseFloat(chainData.total) || 0;
+    }
+    console.log();
+    output.label("Wallet", "");
+    console.log(`  ${"EVM".padEnd(8)} ${data.evmAddress}`);
+    if (data.solAddress) {
+        console.log(`  ${"SOLANA".padEnd(8)} ${data.solAddress}`);
+    }
+    console.log();
+    output.label("Total", GREEN(formatUsd(grandTotal)));
+    if (opts.lowValue) {
+        console.log();
+        output.info("Including low-value tokens");
+    }
+    // Print each chain
+    for (const [chain, chainData] of chainEntries) {
+        printChainBalances(chain, chainData, !!includePnl);
+    }
+    // Print NFTs
+    if (includeNfts && data.nfts && data.nfts.length > 0) {
+        console.log();
+        console.log();
+        console.log(`  ${BRAND.bold("NFTs")}  ${DIM(`${data.nfts.length} item(s)`)}`);
+        console.log(`  ${DIM("─".repeat(58))}`);
+        for (const nft of data.nfts) {
+            const name = nft.name || DIM("Unnamed");
+            const collection = nft.collection?.name
+                ? DIM(` (${nft.collection.name})`)
+                : "";
+            const address = nft.collection?.address || DIM("unknown");
+            console.log(`    ${WHITE(name)}${collection}`);
+            console.log(`    ${DIM(address)} #${nft.tokenId}  ${DIM(nft.chainName || nft.chain)}`);
+            console.log();
+        }
+    }
+    else if (includeNfts) {
+        console.log();
+        output.info("No NFTs found");
+    }
+    console.log();
+}
+//# sourceMappingURL=portfolio.js.map

package/dist/commands/tokens.d.ts

@@ -0,0 +1,7 @@
+export declare function tokensSearchCommand(query: string, opts: {
+    chain?: string;
+}): Promise<void>;
+export declare function tokensInfoCommand(address: string, opts: {
+    chain?: string;
+}): Promise<void>;
+//# sourceMappingURL=tokens.d.ts.map

package/dist/commands/tokens.js

@@ -0,0 +1,60 @@
+import { searchTokens } from "../lib/api.js";
+import * as output from "../lib/output.js";
+export async function tokensSearchCommand(query, opts) {
+    const spin = output.spinner(`Searching tokens for "${query}"...`);
+    try {
+        const chainId = opts.chain ? Number(opts.chain) : undefined;
+        const res = await searchTokens(query, chainId);
+        spin.succeed(`Found ${res.tokens.length} result(s)`);
+        if (res.tokens.length === 0) {
+            output.info("No tokens found. Try a different search query.");
+            return;
+        }
+        console.log();
+        for (const token of res.tokens) {
+            const price = token.priceUsd
+                ? `$${token.priceUsd.toLocaleString(undefined, { minimumFractionDigits: 2, maximumFractionDigits: 6 })}`
+                : output.fmt.dim("n/a");
+            console.log(`  ${output.fmt.brandBold(`${token.symbol}`)} ${output.fmt.dim(token.name)}`);
+            console.log(`    Address:  ${token.address}`);
+            console.log(`    Price:    ${price}`);
+            console.log();
+        }
+    }
+    catch (err) {
+        spin.fail(`Search failed: ${err.message}`);
+        process.exit(1);
+    }
+}
+export async function tokensInfoCommand(address, opts) {
+    const spin = output.spinner(`Fetching token info for ${address}...`);
+    try {
+        const chainId = opts.chain ? Number(opts.chain) : undefined;
+        const res = await searchTokens(address, chainId);
+        spin.succeed("Token info loaded");
+        // Match by the requested address (search returns all tokens from matching pools)
+        const addressLower = address.toLowerCase();
+        const token = res.tokens.find((t) => t.address.toLowerCase() === addressLower) ??
+            res.tokens[0];
+        if (!token) {
+            output.error("Token not found. Check the address and try again.");
+            process.exit(1);
+        }
+        console.log();
+        output.label("Name", token.name);
+        output.label("Symbol", token.symbol);
+        output.label("Address", token.address);
+        output.label("Decimals", String(token.decimals));
+        if (token.priceUsd) {
+            output.label("Price", `$${token.priceUsd.toLocaleString(undefined, { minimumFractionDigits: 2, maximumFractionDigits: 6 })}`);
+        }
+        if (token.logoURI) {
+            output.label("Logo", token.logoURI);
+        }
+    }
+    catch (err) {
+        spin.fail(`Failed to fetch token info: ${err.message}`);
+        process.exit(1);
+    }
+}
+//# sourceMappingURL=tokens.js.map

package/dist/commands/transfer.d.ts

@@ -0,0 +1,8 @@
+export declare function transferCommand(opts: {
+    to: string;
+    amount: string;
+    token?: string;
+    native?: boolean;
+    chain?: string;
+}): Promise<void>;
+//# sourceMappingURL=transfer.d.ts.map

package/dist/commands/transfer.js

@@ -0,0 +1,80 @@
+import { transfer, searchTokens } from "../lib/api.js";
+import * as output from "../lib/output.js";
+import { NATIVE_SYMBOLS, CHAIN_IDS } from "../lib/chains.js";
+import { isAddress } from "viem";
+/**
+ * Resolve a token symbol or address to a contract address.
+ * If it's already a valid address, return as-is. Otherwise search by symbol.
+ */
+async function resolveToken(tokenInput, chain) {
+    if (isAddress(tokenInput)) {
+        return { address: tokenInput, symbol: tokenInput };
+    }
+    const chainId = CHAIN_IDS[chain];
+    const res = await searchTokens(tokenInput, chainId);
+    // Exact symbol match (case-insensitive) to avoid resolving to wrong token
+    const inputUpper = tokenInput.toUpperCase();
+    const exactMatch = res.tokens.find((t) => t.symbol.toUpperCase() === inputUpper);
+    if (!exactMatch) {
+        const available = res.tokens
+            .slice(0, 5)
+            .map((t) => `${t.symbol} (${t.address})`)
+            .join(", ");
+        throw new Error(`No exact match for "${tokenInput}" on ${chain}. Did you mean: ${available || "no results"}`);
+    }
+    return { address: exactMatch.address, symbol: exactMatch.symbol };
+}
+export async function transferCommand(opts) {
+    const isNative = opts.native ?? false;
+    const chain = opts.chain ?? "base";
+    if (!isNative && !opts.token) {
+        output.error("Token required for ERC20 transfers. Use --token <symbol or address> or --native.");
+        process.exit(1);
+    }
+    let tokenAddress;
+    let tokenLabel;
+    if (isNative) {
+        tokenAddress = "0x0000000000000000000000000000000000000000";
+        tokenLabel = NATIVE_SYMBOLS[chain] ?? "ETH";
+    }
+    else {
+        const spin = output.spinner(`Resolving token "${opts.token}"...`);
+        try {
+            const resolved = await resolveToken(opts.token, chain);
+            tokenAddress = resolved.address;
+            tokenLabel = resolved.symbol;
+            if (tokenAddress !== opts.token) {
+                spin.succeed(`Resolved ${opts.token} → ${tokenLabel} (${tokenAddress})`);
+            }
+            else {
+                spin.stop();
+            }
+        }
+        catch (err) {
+            spin.fail(err.message);
+            process.exit(1);
+        }
+    }
+    const chainLabel = chain !== "base" ? ` on ${chain}` : "";
+    const spin = output.spinner(`Transferring ${opts.amount} ${tokenLabel} to ${opts.to}${chainLabel}...`);
+    try {
+        const result = await transfer({
+            tokenAddress,
+            recipientAddress: opts.to,
+            amount: opts.amount,
+            isNativeToken: isNative,
+            chain,
+        });
+        if (!result.success) {
+            spin.fail(`Transfer failed: ${result.error}`);
+            process.exit(1);
+        }
+        spin.succeed(`Transfer successful`);
+        output.label("Tx Hash", result.txHash ?? "unknown");
+    }
+    catch (err) {
+        spin.fail(`Transfer failed: ${err.message}`);
+        process.exit(1);
+    }
+}
+//# sourceMappingURL=transfer.js.map

package/dist/commands/update.d.ts

@@ -0,0 +1,4 @@
+export declare function updateCommand(opts: {
+    check?: boolean;
+}): Promise<void>;
+//# sourceMappingURL=update.d.ts.map

package/dist/commands/update.js

@@ -0,0 +1,116 @@
+import { readFileSync } from "node:fs";
+import { execSync } from "node:child_process";
+import * as output from "../lib/output.js";
+const PACKAGE_NAME = "@bankr/cli";
+/**
+ * Compare two semver version strings.
+ * Returns -1 if a < b, 0 if equal, 1 if a > b.
+ */
+function compareSemver(a, b) {
+    const partsA = a.split(".").map(Number);
+    const partsB = b.split(".").map(Number);
+    for (let i = 0; i < Math.max(partsA.length, partsB.length); i++) {
+        const numA = partsA[i] ?? 0;
+        const numB = partsB[i] ?? 0;
+        if (numA < numB)
+            return -1;
+        if (numA > numB)
+            return 1;
+    }
+    return 0;
+}
+async function fetchLatestVersion() {
+    const res = await fetch(`https://registry.npmjs.org/${PACKAGE_NAME}/latest`, {
+        signal: AbortSignal.timeout(10000),
+    });
+    if (!res.ok) {
+        throw new Error(`Failed to check for updates (HTTP ${res.status})`);
+    }
+    const data = (await res.json());
+    return data.version;
+}
+function getCurrentVersion() {
+    const pkg = JSON.parse(readFileSync(new URL("../../package.json", import.meta.url), "utf-8"));
+    return pkg.version;
+}
+/**
+ * Detect which package manager installed the CLI globally.
+ * Falls back to npm if we can't determine.
+ */
+function detectPackageManager() {
+    try {
+        const execPath = process.argv[1] ?? "";
+        // Check if running under bun
+        if (execPath.includes("/.bun/") || "bun" in process.versions) {
+            return "bun";
+        }
+        // Check if running under pnpm
+        if (execPath.includes("/pnpm/") || execPath.includes("/.pnpm/")) {
+            return "pnpm";
+        }
+        // Check if running under yarn
+        if (execPath.includes("/yarn/") || execPath.includes("/.yarn/")) {
+            return "yarn";
+        }
+    }
+    catch {
+        // ignore detection errors
+    }
+    return "npm";
+}
+function getInstallCommand(pm) {
+    switch (pm) {
+        case "bun":
+            return `bun install -g ${PACKAGE_NAME}@latest`;
+        case "pnpm":
+            return `pnpm add -g ${PACKAGE_NAME}@latest`;
+        case "yarn":
+            return `yarn global add ${PACKAGE_NAME}@latest`;
+        default:
+            return `npm install -g ${PACKAGE_NAME}@latest`;
+    }
+}
+export async function updateCommand(opts) {
+    const current = getCurrentVersion();
+    const spin = output.spinner("Checking for updates...");
+    let latest;
+    try {
+        latest = await fetchLatestVersion();
+    }
+    catch (err) {
+        spin.fail();
+        output.error(err.message);
+        process.exit(1);
+    }
+    const cmp = compareSemver(current, latest);
+    if (cmp === 0) {
+        spin.succeed(`Already on the latest version (${current})`);
+        return;
+    }
+    if (cmp > 0) {
+        spin.succeed(`You're ahead of latest (${current} > ${latest}). No update needed.`);
+        return;
+    }
+    spin.succeed(`Update available: ${current} → ${latest}`);
+    if (opts.check) {
+        return;
+    }
+    const pm = detectPackageManager();
+    const cmd = getInstallCommand(pm);
+    output.blank();
+    output.info(`Updating via ${pm}...`);
+    output.dim(`  $ ${cmd}`);
+    output.blank();
+    try {
+        execSync(cmd, { stdio: "inherit" });
+        output.blank();
+        output.success(`Updated to ${PACKAGE_NAME}@${latest}`);
+    }
+    catch {
+        output.blank();
+        output.error("Update failed. Try running manually:");
+        output.dim(`  $ ${cmd}`);
+        process.exit(1);
+    }
+}
+//# sourceMappingURL=update.js.map

package/dist/lib/api.d.ts

@@ -61,7 +61,29 @@ export interface TokenBalanceInfo {
             imgUrl: string;
             decimals: number;
         };
+        pnl?: {
+            realizedPnl: number;
+            unrealizedPnl: number;
+            totalPnl: number;
+            averageEntryPrice: number;
+        };
+    };
+}
+export interface NftInfo {
+    name?: string;
+    tokenId: string;
+    collection?: {
+        name: string;
+        address: string;
+        nftStandard?: string;
     };
+    chain: string;
+    chainName?: string;
+    image?: {
+        thumbnail?: string;
+        original?: string;
+    };
+    openSeaUrl?: string;
 }
 export interface ChainBalanceInfo {
     nativeBalance: string;
@@ -69,13 +91,23 @@ export interface ChainBalanceInfo {
     tokenBalances: TokenBalanceInfo[];
     total: string;
 }
-export interface BalancesResponse {
+export interface PortfolioResponse {
     success: boolean;
     evmAddress: string;
     solAddress?: string;
     balances: Record<string, ChainBalanceInfo>;
+    nfts?: NftInfo[];
+}
+export interface PortfolioOptions {
+    chains?: string[];
+    showLowValueTokens?: boolean;
+    include?: string[];
 }
-export declare function getBalances(chains?: string[]): Promise<BalancesResponse>;
+export declare function getPortfolio(opts?: PortfolioOptions): Promise<PortfolioResponse>;
+/** @deprecated Use PortfolioResponse instead */
+export type BalancesResponse = PortfolioResponse;
+/** @deprecated Use getPortfolio instead */
+export declare const getBalances: (chains?: string[], showLowValueTokens?: boolean) => Promise<PortfolioResponse>;
 export declare function pollJob(jobId: string, opts?: {
     interval?: number;
     maxAttempts?: number;
@@ -324,5 +356,30 @@ export declare function addProjectUpdate(data: {
     title: string;
     content: string;
 }): Promise<AgentProfileResponse>;
+export interface TokenSearchResult {
+    address: string;
+    symbol: string;
+    name: string;
+    decimals: number;
+    logoURI?: string;
+    priceUsd?: number;
+}
+export interface TokenSearchResponse {
+    tokens: TokenSearchResult[];
+}
+export declare function searchTokens(query: string, chainId?: number): Promise<TokenSearchResponse>;
+export interface TransferRequest {
+    tokenAddress: string;
+    recipientAddress: string;
+    amount: string;
+    isNativeToken: boolean;
+    chain?: string;
+}
+export interface TransferResponse {
+    success: boolean;
+    txHash?: string;
+    error?: string;
+}
+export declare function transfer(request: TransferRequest): Promise<TransferResponse>;
 export declare function buildPublicClaimTxs(beneficiaryAddress: string, tokenAddresses: string[]): Promise<BuildClaimResponse>;
 //# sourceMappingURL=api.d.ts.map

package/dist/lib/api.js

@@ -62,18 +62,25 @@ export async function validateApiKey() {
     }
 }
 export async function getUserInfo() {
-    const res = await fetch(`${getApiUrl()}/agent/me`, {
+    const res = await fetch(`${getApiUrl()}/wallet/me`, {
         headers: authHeaders(),
     });
     return handleResponse(res);
 }
-export async function getBalances(chains) {
-    const params = chains?.length ? `?chains=${chains.join(",")}` : "";
-    const res = await fetch(`${getApiUrl()}/agent/balances${params}`, {
-        headers: authHeaders(),
-    });
+export async function getPortfolio(opts = {}) {
+    const query = new URLSearchParams();
+    if (opts.chains?.length)
+        query.set("chains", opts.chains.join(","));
+    if (opts.showLowValueTokens)
+        query.set("showLowValueTokens", "true");
+    if (opts.include?.length)
+        query.set("include", opts.include.join(","));
+    const qs = query.toString();
+    const res = await fetch(`${getApiUrl()}/wallet/portfolio${qs ? `?${qs}` : ""}`, { headers: authHeaders() });
     return handleResponse(res);
 }
+/** @deprecated Use getPortfolio instead */
+export const getBalances = (chains, showLowValueTokens) => getPortfolio({ chains, showLowValueTokens });
 export async function pollJob(jobId, opts = {}) {
     const { interval = 2000, maxAttempts = 150, onStatus } = opts;
     let attempts = 0;
@@ -89,7 +96,7 @@ export async function pollJob(jobId, opts = {}) {
     throw new Error(`Polling timed out after ${maxAttempts} attempts`);
 }
 export async function sign(request) {
-    const res = await fetch(`${getApiUrl()}/agent/sign`, {
+    const res = await fetch(`${getApiUrl()}/wallet/sign`, {
         method: "POST",
         headers: authHeaders(),
         body: JSON.stringify(request),
@@ -97,7 +104,7 @@ export async function sign(request) {
     return handleResponse(res);
 }
 export async function submit(request) {
-    const res = await fetch(`${getApiUrl()}/agent/submit`, {
+    const res = await fetch(`${getApiUrl()}/wallet/submit`, {
         method: "POST",
         headers: authHeaders(),
         body: JSON.stringify(request),
@@ -254,6 +261,25 @@ export async function addProjectUpdate(data) {
     });
     return handleResponse(res);
 }
+export async function searchTokens(query, chainId) {
+    const params = new URLSearchParams({ query });
+    if (chainId)
+        params.set("chainId", String(chainId));
+    const res = await fetch(`${getApiUrl()}/tokens/search?${params}`, {
+        headers: {
+            "User-Agent": CLI_USER_AGENT,
+        },
+    });
+    return handleResponse(res);
+}
+export async function transfer(request) {
+    const res = await fetch(`${getApiUrl()}/wallet/transfer`, {
+        method: "POST",
+        headers: authHeaders(),
+        body: JSON.stringify(request),
+    });
+    return handleResponse(res);
+}
 export async function buildPublicClaimTxs(beneficiaryAddress, tokenAddresses) {
     const res = await fetch(`${getApiUrl()}/public/doppler/build-claim`, {
         method: "POST",

package/dist/lib/chains.d.ts

@@ -0,0 +1,5 @@
+export declare const CHAIN_LABELS: Record<string, string>;
+export declare const VALID_CHAINS: Set<string>;
+export declare const CHAIN_IDS: Record<string, number>;
+export declare const NATIVE_SYMBOLS: Record<string, string>;
+//# sourceMappingURL=chains.d.ts.map

package/dist/lib/chains.js

@@ -0,0 +1,35 @@
+export const CHAIN_LABELS = {
+    base: "Base",
+    polygon: "Polygon",
+    mainnet: "Ethereum",
+    unichain: "Unichain",
+    worldchain: "World Chain",
+    arbitrum: "Arbitrum",
+    solana: "Solana",
+};
+export const VALID_CHAINS = new Set([
+    "base",
+    "polygon",
+    "mainnet",
+    "unichain",
+    "worldchain",
+    "arbitrum",
+    "solana",
+]);
+export const CHAIN_IDS = {
+    base: 8453,
+    mainnet: 1,
+    polygon: 137,
+    unichain: 130,
+    worldchain: 480,
+    arbitrum: 42161,
+};
+export const NATIVE_SYMBOLS = {
+    base: "ETH",
+    mainnet: "ETH",
+    unichain: "ETH",
+    worldchain: "ETH",
+    arbitrum: "ETH",
+    polygon: "POL",
+};
+//# sourceMappingURL=chains.js.map

package/dist/lib/output.d.ts

@@ -29,5 +29,7 @@ export declare function keyValue(key: string, value: string): void;
 export declare function spinner(text: string): Ora;
 export declare function maskApiKey(key: string): string;
 export declare function formatDuration(ms: number): string;
+export declare function formatUsd(value: string | number): string;
+export declare function formatBalance(value: string | number, decimals?: number): string;
 export declare function formatStatus(status: string): string;
 //# sourceMappingURL=output.d.ts.map

package/dist/lib/output.js

@@ -66,6 +66,23 @@ export function formatDuration(ms) {
         return `${ms}ms`;
     return `${(ms / 1000).toFixed(1)}s`;
 }
+export function formatUsd(value) {
+    const num = typeof value === "string" ? parseFloat(value) : value;
+    if (isNaN(num) || num === 0)
+        return chalk.dim("$0.00");
+    return `$${num.toLocaleString("en-US", { minimumFractionDigits: 2, maximumFractionDigits: 2 })}`;
+}
+export function formatBalance(value, decimals = 6) {
+    const num = typeof value === "string" ? parseFloat(value) : value;
+    if (isNaN(num) || num === 0)
+        return "0";
+    if (num < 0.000001)
+        return "<0.000001";
+    return num.toLocaleString("en-US", {
+        minimumFractionDigits: 0,
+        maximumFractionDigits: decimals,
+    });
+}
 export function formatStatus(status) {
     switch (status) {
         case "completed":

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@bankr/cli",
-  "version": "0.1.0",
+  "version": "0.2.0",
   "description": "Official CLI for the Bankr AI agent platform",
   "type": "module",
   "bin": {