agnic 1.0.0

package/dist/cli.d.ts

@@ -0,0 +1,2 @@
+#!/usr/bin/env node
+export {};

package/dist/cli.js

@@ -0,0 +1,25 @@
+#!/usr/bin/env node
+import { Command } from 'commander';
+import { registerAuthCommand } from './commands/auth.js';
+import { registerStatusCommand } from './commands/status.js';
+import { registerBalanceCommand } from './commands/balance.js';
+import { registerAddressCommand } from './commands/address.js';
+import { registerSendCommand } from './commands/send.js';
+import { registerTradeCommand } from './commands/trade.js';
+import { registerX402Command } from './commands/x402.js';
+const program = new Command();
+program
+    .name('agnic')
+    .description('CLI for AgnicPay — AI agent wallet for x402 payments and token trading')
+    .version('1.0.0')
+    .option('--token <token>', 'API token (overrides stored token and AGNIC_TOKEN env)')
+    .option('--api-url <url>', 'API base URL (default: https://api.agnic.ai)');
+// Register all commands
+registerAuthCommand(program);
+registerStatusCommand(program);
+registerBalanceCommand(program);
+registerAddressCommand(program);
+registerSendCommand(program);
+registerTradeCommand(program);
+registerX402Command(program);
+program.parse();

package/dist/commands/address.d.ts

@@ -0,0 +1,2 @@
+import { Command } from 'commander';
+export declare function registerAddressCommand(program: Command): void;

package/dist/commands/address.js

@@ -0,0 +1,27 @@
+import { getToken, loadConfig } from '../lib/config.js';
+import { printError, printJson } from '../lib/output.js';
+export function registerAddressCommand(program) {
+    program
+        .command('address')
+        .description('Show wallet address')
+        .option('--json', 'Output as JSON')
+        .action(async (opts) => {
+        const token = getToken(program.opts());
+        if (!token) {
+            printError('Not authenticated. Run: agnic auth login <email>');
+            process.exit(1);
+        }
+        const config = loadConfig();
+        const address = config.walletAddress;
+        if (!address) {
+            printError('No wallet address found. Visit https://pay.agnic.ai to create a wallet.');
+            process.exit(1);
+        }
+        if (opts.json) {
+            printJson({ address });
+        }
+        else {
+            console.log(address);
+        }
+    });
+}

package/dist/commands/auth.d.ts

@@ -0,0 +1,2 @@
+import { Command } from 'commander';
+export declare function registerAuthCommand(program: Command): void;

package/dist/commands/auth.js

@@ -0,0 +1,69 @@
+import chalk from 'chalk';
+import ora from 'ora';
+import { saveConfig, clearConfig, getApiUrl } from '../lib/config.js';
+import { ApiClient } from '../lib/api-client.js';
+import { printSuccess, printError, printJson } from '../lib/output.js';
+export function registerAuthCommand(program) {
+    const auth = program.command('auth').description('Manage authentication');
+    auth
+        .command('login <email>')
+        .description('Login with email OTP')
+        .action(async (email) => {
+        const apiUrl = getApiUrl();
+        const spinner = ora('Sending verification code...').start();
+        try {
+            const result = await ApiClient.otpInitiate(apiUrl, email);
+            spinner.succeed('Verification code sent!');
+            console.log(chalk.gray(`Check your email: ${email}`));
+            console.log();
+            console.log(`Flow ID: ${chalk.cyan(result.flowId)}`);
+            console.log();
+            console.log(chalk.bold('Run:'));
+            console.log(`  agnic auth verify ${result.flowId} <6-digit-code>`);
+        }
+        catch (error) {
+            spinner.fail('Failed to send verification code');
+            printError(error.message);
+            process.exit(1);
+        }
+    });
+    auth
+        .command('verify <flowId> <otp>')
+        .description('Verify OTP code')
+        .option('--json', 'Output as JSON')
+        .action(async (flowId, otp, opts) => {
+        const apiUrl = getApiUrl();
+        const spinner = ora('Verifying code...').start();
+        try {
+            const result = await ApiClient.otpVerify(apiUrl, flowId, otp);
+            spinner.succeed('Authenticated!');
+            // Save token
+            saveConfig({
+                token: result.token,
+                email: result.email,
+                walletAddress: result.walletAddress,
+            });
+            if (opts.json) {
+                printJson({ email: result.email, walletAddress: result.walletAddress });
+            }
+            else {
+                console.log(`Email: ${chalk.cyan(result.email)}`);
+                console.log(`Wallet: ${chalk.cyan(result.walletAddress || 'Not created yet')}`);
+                console.log();
+                printSuccess('Token saved to ~/.agnic/config.json');
+            }
+        }
+        catch (error) {
+            spinner.fail('Verification failed');
+            printError(error.message);
+            process.exit(1);
+        }
+    });
+    auth
+        .command('logout')
+        .description('Remove stored credentials')
+        .action(() => {
+        clearConfig();
+        printSuccess('Logged out. Token removed from ~/.agnic/config.json');
+    });
+}

package/dist/commands/balance.d.ts

@@ -0,0 +1,2 @@
+import { Command } from 'commander';
+export declare function registerBalanceCommand(program: Command): void;

package/dist/commands/balance.js

@@ -0,0 +1,69 @@
+import chalk from 'chalk';
+import ora from 'ora';
+import { getToken, getApiUrl } from '../lib/config.js';
+import { ApiClient } from '../lib/api-client.js';
+import { printError, printJson, printTable } from '../lib/output.js';
+export function registerBalanceCommand(program) {
+    program
+        .command('balance')
+        .description('Check USDC balance')
+        .option('--network <network>', 'Specific network (base, base-sepolia, solana, solana-devnet)')
+        .option('--json', 'Output as JSON')
+        .action(async (opts) => {
+        const token = getToken(program.opts());
+        if (!token) {
+            printError('Not authenticated. Run: agnic auth login <email>');
+            process.exit(1);
+        }
+        const spinner = ora('Fetching balance...').start();
+        try {
+            const client = new ApiClient(getApiUrl(), token);
+            if (opts.network) {
+                const result = await client.getBalance(opts.network);
+                spinner.stop();
+                if (opts.json) {
+                    printJson(result);
+                }
+                else {
+                    console.log(`${chalk.bold(opts.network)}: ${chalk.green('$' + result.usdcBalance)} USDC`);
+                    if (result.address)
+                        console.log(`Address: ${chalk.gray(result.address)}`);
+                }
+            }
+            else {
+                // Fetch all networks
+                const networks = ['base', 'solana'];
+                const results = [];
+                for (const net of networks) {
+                    try {
+                        const result = await client.getBalance(net);
+                        results.push({
+                            network: net,
+                            balance: result.usdcBalance || '0',
+                            address: result.address || 'N/A',
+                        });
+                    }
+                    catch {
+                        results.push({ network: net, balance: '0', address: 'N/A' });
+                    }
+                }
+                spinner.stop();
+                if (opts.json) {
+                    printJson(results);
+                }
+                else {
+                    printTable(results.map((r) => ({
+                        Network: r.network,
+                        Currency: 'USDC',
+                        Balance: `$${r.balance}`,
+                    })));
+                }
+            }
+        }
+        catch (error) {
+            spinner.fail('Failed to fetch balance');
+            printError(error.message);
+            process.exit(1);
+        }
+    });
+}

package/dist/commands/send.d.ts

@@ -0,0 +1,2 @@
+import { Command } from 'commander';
+export declare function registerSendCommand(program: Command): void;

package/dist/commands/send.js

@@ -0,0 +1,48 @@
+import chalk from 'chalk';
+import ora from 'ora';
+import { getToken, getApiUrl } from '../lib/config.js';
+import { ApiClient } from '../lib/api-client.js';
+import { printError, printJson } from '../lib/output.js';
+export function registerSendCommand(program) {
+    program
+        .command('send <amount> <to>')
+        .description('Send USDC to a wallet address')
+        .option('--network <network>', 'Network (default: base)', 'base')
+        .option('--memo <memo>', 'Transaction memo')
+        .option('--json', 'Output as JSON')
+        .action(async (amount, to, opts) => {
+        const token = getToken(program.opts());
+        if (!token) {
+            printError('Not authenticated. Run: agnic auth login <email>');
+            process.exit(1);
+        }
+        const amountNum = parseFloat(amount);
+        if (isNaN(amountNum) || amountNum <= 0) {
+            printError('Amount must be a positive number');
+            process.exit(1);
+        }
+        const spinner = ora(`Sending ${amount} USDC to ${to.slice(0, 8)}...${to.slice(-6)}...`).start();
+        try {
+            const client = new ApiClient(getApiUrl(), token);
+            const result = await client.send(to, amountNum, opts.network, opts.memo);
+            spinner.succeed('Transfer complete!');
+            if (opts.json) {
+                printJson(result);
+            }
+            else {
+                console.log(`Amount: ${chalk.green('$' + result.amount)} USDC`);
+                console.log(`To: ${chalk.cyan(result.to)}`);
+                console.log(`Network: ${result.network}`);
+                console.log(`Tx: ${chalk.gray(result.transactionHash)}`);
+                if (result.explorerUrl) {
+                    console.log(`Explorer: ${chalk.underline(result.explorerUrl)}`);
+                }
+            }
+        }
+        catch (error) {
+            spinner.fail('Send failed');
+            printError(error.message);
+            process.exit(1);
+        }
+    });
+}

package/dist/commands/status.d.ts

@@ -0,0 +1,2 @@
+import { Command } from 'commander';
+export declare function registerStatusCommand(program: Command): void;

package/dist/commands/status.js

@@ -0,0 +1,45 @@
+import chalk from 'chalk';
+import ora from 'ora';
+import { getToken, getApiUrl, loadConfig } from '../lib/config.js';
+import { ApiClient } from '../lib/api-client.js';
+import { printError, printJson } from '../lib/output.js';
+export function registerStatusCommand(program) {
+    program
+        .command('status')
+        .description('Check authentication and wallet status')
+        .option('--json', 'Output as JSON')
+        .action(async (opts) => {
+        const token = getToken(program.opts());
+        if (!token) {
+            printError('Not authenticated. Run: agnic auth login <email>');
+            process.exit(1);
+        }
+        const spinner = ora('Checking status...').start();
+        try {
+            const client = new ApiClient(getApiUrl(), token);
+            const result = await client.validate();
+            spinner.succeed('Authenticated');
+            const config = loadConfig();
+            if (opts.json) {
+                printJson({
+                    authenticated: true,
+                    userId: result.userId || result.valid,
+                    email: config.email || null,
+                    walletAddress: config.walletAddress || null,
+                });
+            }
+            else {
+                console.log(`User ID: ${chalk.cyan(result.userId || 'OK')}`);
+                if (config.email)
+                    console.log(`Email: ${chalk.cyan(config.email)}`);
+                if (config.walletAddress)
+                    console.log(`Wallet: ${chalk.cyan(config.walletAddress)}`);
+            }
+        }
+        catch (error) {
+            spinner.fail('Authentication check failed');
+            printError(error.message);
+            process.exit(1);
+        }
+    });
+}

package/dist/commands/trade.d.ts

@@ -0,0 +1,2 @@
+import { Command } from 'commander';
+export declare function registerTradeCommand(program: Command): void;

package/dist/commands/trade.js

@@ -0,0 +1,82 @@
+import chalk from 'chalk';
+import ora from 'ora';
+import { getToken, getApiUrl } from '../lib/config.js';
+import { ApiClient } from '../lib/api-client.js';
+import { printError, printJson } from '../lib/output.js';
+export function registerTradeCommand(program) {
+    program
+        .command('trade <amount> <from> <to>')
+        .description('Trade/swap tokens on Base (e.g., agnic trade 10 usdc eth)')
+        .option('--slippage <percent>', 'Max slippage percentage (default: 1.0)', '1.0')
+        .option('--dry-run', 'Show quote without executing')
+        .option('--json', 'Output as JSON')
+        .action(async (amount, from, to, opts) => {
+        const token = getToken(program.opts());
+        if (!token) {
+            printError('Not authenticated. Run: agnic auth login <email>');
+            process.exit(1);
+        }
+        const amountNum = parseFloat(amount);
+        if (isNaN(amountNum) || amountNum <= 0) {
+            printError('Amount must be a positive number');
+            process.exit(1);
+        }
+        const sellToken = from.toUpperCase();
+        const buyToken = to.toUpperCase();
+        const slippage = parseFloat(opts.slippage);
+        const client = new ApiClient(getApiUrl(), token);
+        // Dry run — just show quote
+        if (opts.dryRun) {
+            const spinner = ora('Fetching quote...').start();
+            try {
+                const quote = await client.tradeQuote(sellToken, buyToken, amountNum);
+                spinner.stop();
+                if (opts.json) {
+                    printJson(quote);
+                }
+                else {
+                    console.log(chalk.bold('Trade Quote:'));
+                    console.log(`  Sell: ${amount} ${sellToken}`);
+                    console.log(`  Buy:  ${chalk.green(quote.buyAmount)} ${buyToken}`);
+                    console.log(`  Price: ${quote.price}`);
+                    console.log(`  Slippage: ${quote.slippage}`);
+                    console.log(`  Network: ${quote.network}`);
+                }
+            }
+            catch (error) {
+                spinner.fail('Quote failed');
+                printError(error.message);
+                process.exit(1);
+            }
+            return;
+        }
+        // Execute trade
+        const spinner = ora(`Swapping ${amount} ${sellToken} → ${buyToken} on Base...`).start();
+        try {
+            const result = await client.trade(sellToken, buyToken, amountNum, slippage);
+            if (!result.success) {
+                spinner.fail('Trade failed');
+                printError(result.error || result.message || 'Unknown error');
+                process.exit(1);
+            }
+            spinner.succeed('Trade complete!');
+            if (opts.json) {
+                printJson(result);
+            }
+            else {
+                console.log(`  Sold: ${result.sellAmount} ${result.sellToken}`);
+                console.log(`  Got:  ${chalk.green(result.buyAmount)} ${result.buyToken}`);
+                console.log(`  Price: ${result.price}`);
+                console.log(`  Tx: ${chalk.gray(result.transactionHash)}`);
+                if (result.explorerUrl) {
+                    console.log(`  Explorer: ${chalk.underline(result.explorerUrl)}`);
+                }
+            }
+        }
+        catch (error) {
+            spinner.fail('Trade failed');
+            printError(error.message);
+            process.exit(1);
+        }
+    });
+}

package/dist/commands/x402.d.ts

@@ -0,0 +1,2 @@
+import { Command } from 'commander';
+export declare function registerX402Command(program: Command): void;

package/dist/commands/x402.js

@@ -0,0 +1,122 @@
+import chalk from 'chalk';
+import ora from 'ora';
+import { getToken, getApiUrl } from '../lib/config.js';
+import { ApiClient } from '../lib/api-client.js';
+import { printError, printJson } from '../lib/output.js';
+export function registerX402Command(program) {
+    const x402 = program
+        .command('x402')
+        .description('Search and pay for x402-enabled APIs');
+    // Search subcommand
+    x402
+        .command('search <query>')
+        .description('Search for x402-enabled APIs')
+        .option('--category <category>', 'Filter by category (AI, Crypto, Data, Trading, Finance, Weather)')
+        .option('--limit <n>', 'Max results (default: 10)', '10')
+        .option('--json', 'Output as JSON')
+        .action(async (query, opts) => {
+        const spinner = ora('Searching x402 APIs...').start();
+        try {
+            const res = await fetch('https://hub.agnic.ai/api/discover', {
+                method: 'POST',
+                headers: { 'Content-Type': 'application/json' },
+                body: JSON.stringify({
+                    search: query,
+                    category: opts.category,
+                    limit: parseInt(opts.limit, 10),
+                }),
+            });
+            if (!res.ok) {
+                throw new Error(`Search failed: ${res.status}`);
+            }
+            const data = await res.json();
+            spinner.stop();
+            if (opts.json) {
+                printJson(data);
+                return;
+            }
+            const apis = data.apis || data.results || data;
+            if (!Array.isArray(apis) || apis.length === 0) {
+                console.log(chalk.yellow('No APIs found matching your query.'));
+                return;
+            }
+            console.log(chalk.bold(`Found ${apis.length} API(s):\n`));
+            apis.forEach((api, i) => {
+                console.log(`  ${chalk.cyan(`${i + 1}.`)} ${chalk.bold(api.name || api.title)}`);
+                if (api.description) {
+                    console.log(`     ${chalk.gray(api.description.slice(0, 80))}`);
+                }
+                if (api.price || api.cost) {
+                    console.log(`     Price: ${chalk.green('$' + (api.price || api.cost))} /request`);
+                }
+                if (api.url || api.endpoint) {
+                    console.log(`     URL: ${chalk.underline(api.url || api.endpoint)}`);
+                }
+                console.log();
+            });
+        }
+        catch (error) {
+            spinner.fail('Search failed');
+            printError(error.message);
+            process.exit(1);
+        }
+    });
+    // Pay subcommand
+    x402
+        .command('pay <url>')
+        .description('Make an x402 payment request to an API')
+        .option('--method <method>', 'HTTP method (default: GET)', 'GET')
+        .option('--body <json>', 'Request body (JSON string)')
+        .option('--network <network>', 'Payment network (default: base)', 'base')
+        .option('--json', 'Output as JSON')
+        .action(async (url, opts) => {
+        const token = getToken(program.opts());
+        if (!token) {
+            printError('Not authenticated. Run: agnic auth login <email>');
+            process.exit(1);
+        }
+        const spinner = ora(`Paying ${url}...`).start();
+        try {
+            const client = new ApiClient(getApiUrl(), token);
+            let body = undefined;
+            if (opts.body) {
+                try {
+                    body = JSON.parse(opts.body);
+                }
+                catch {
+                    spinner.fail('Invalid JSON body');
+                    printError('--body must be a valid JSON string');
+                    process.exit(1);
+                }
+            }
+            const result = await client.x402Fetch(url, opts.method, body);
+            spinner.succeed('Request complete!');
+            if (opts.json) {
+                printJson(result);
+            }
+            else {
+                if (result.status)
+                    console.log(`Status: ${chalk.green(result.status)}`);
+                if (result.cost)
+                    console.log(`Cost: ${chalk.yellow('$' + result.cost)}`);
+                if (result.network)
+                    console.log(`Network: ${result.network}`);
+                if (result.transactionHash) {
+                    console.log(`Tx: ${chalk.gray(result.transactionHash)}`);
+                }
+                console.log(chalk.bold('\nResponse:'));
+                if (typeof result.data === 'object') {
+                    console.log(JSON.stringify(result.data, null, 2));
+                }
+                else {
+                    console.log(result.data || result.body || JSON.stringify(result, null, 2));
+                }
+            }
+        }
+        catch (error) {
+            spinner.fail('Request failed');
+            printError(error.message);
+            process.exit(1);
+        }
+    });
+}

package/dist/lib/api-client.d.ts

@@ -0,0 +1,21 @@
+/**
+ * HTTP client for agnic CLI
+ * Wraps api.agnic.ai endpoints
+ */
+export declare class ApiClient {
+    private apiUrl;
+    private token;
+    constructor(apiUrl: string, token: string);
+    private getHeaders;
+    get(path: string): Promise<any>;
+    post(path: string, body: any): Promise<any>;
+    static otpInitiate(apiUrl: string, email: string): Promise<any>;
+    static otpVerify(apiUrl: string, flowId: string, otp: string): Promise<any>;
+    validate(): Promise<any>;
+    getBalance(network?: string): Promise<any>;
+    send(to: string, amount: number, network: string, memo?: string): Promise<any>;
+    trade(sellToken: string, buyToken: string, sellAmount: number, slippagePercentage?: number): Promise<any>;
+    tradeQuote(sellToken: string, buyToken: string, sellAmount: number): Promise<any>;
+    x402Fetch(url: string, method?: string, body?: any): Promise<any>;
+    getAgentIdentity(): Promise<any>;
+}

package/dist/lib/api-client.js

@@ -0,0 +1,88 @@
+/**
+ * HTTP client for agnic CLI
+ * Wraps api.agnic.ai endpoints
+ */
+export class ApiClient {
+    apiUrl;
+    token;
+    constructor(apiUrl, token) {
+        this.apiUrl = apiUrl;
+        this.token = token;
+    }
+    getHeaders() {
+        return {
+            'X-Agnic-Token': this.token,
+            'Content-Type': 'application/json',
+        };
+    }
+    async get(path) {
+        const response = await fetch(`${this.apiUrl}${path}`, {
+            headers: this.getHeaders(),
+        });
+        if (!response.ok) {
+            const err = await response.json().catch(() => ({ error: response.statusText }));
+            throw new Error(err.message || err.error || `HTTP ${response.status}`);
+        }
+        return response.json();
+    }
+    async post(path, body) {
+        const response = await fetch(`${this.apiUrl}${path}`, {
+            method: 'POST',
+            headers: this.getHeaders(),
+            body: JSON.stringify(body),
+        });
+        if (!response.ok) {
+            const err = await response.json().catch(() => ({ error: response.statusText }));
+            throw new Error(err.message || err.error || `HTTP ${response.status}`);
+        }
+        return response.json();
+    }
+    // Auth endpoints (no token needed)
+    static async otpInitiate(apiUrl, email) {
+        const response = await fetch(`${apiUrl}/api/auth/otp/initiate`, {
+            method: 'POST',
+            headers: { 'Content-Type': 'application/json' },
+            body: JSON.stringify({ email }),
+        });
+        if (!response.ok) {
+            const err = await response.json().catch(() => ({ error: response.statusText }));
+            throw new Error(err.message || err.error || `HTTP ${response.status}`);
+        }
+        return response.json();
+    }
+    static async otpVerify(apiUrl, flowId, otp) {
+        const response = await fetch(`${apiUrl}/api/auth/otp/verify`, {
+            method: 'POST',
+            headers: { 'Content-Type': 'application/json' },
+            body: JSON.stringify({ flowId, otp }),
+        });
+        if (!response.ok) {
+            const err = await response.json().catch(() => ({ error: response.statusText }));
+            throw new Error(err.message || err.error || `HTTP ${response.status}`);
+        }
+        return response.json();
+    }
+    // Wallet endpoints
+    async validate() {
+        return this.get('/api/auth/validate');
+    }
+    async getBalance(network) {
+        const params = network ? `?network=${network}` : '';
+        return this.get(`/api/balance${params}`);
+    }
+    async send(to, amount, network, memo) {
+        return this.post('/api/send', { to, amount, network, ...(memo && { memo }) });
+    }
+    async trade(sellToken, buyToken, sellAmount, slippagePercentage) {
+        return this.post('/api/trade', { sellToken, buyToken, sellAmount, slippagePercentage, network: 'base' });
+    }
+    async tradeQuote(sellToken, buyToken, sellAmount) {
+        return this.get(`/api/trade/quote?sellToken=${sellToken}&buyToken=${buyToken}&sellAmount=${sellAmount}`);
+    }
+    async x402Fetch(url, method = 'GET', body) {
+        return this.post(`/api/x402/fetch?url=${encodeURIComponent(url)}&method=${method}`, body || {});
+    }
+    async getAgentIdentity() {
+        return this.get('/api/agent/identity');
+    }
+}

package/dist/lib/config.d.ts

@@ -0,0 +1,18 @@
+/**
+ * Configuration management for agnic CLI
+ * Stores auth token and preferences in ~/.agnic/config.json
+ */
+interface AgnicConfig {
+    token?: string;
+    email?: string;
+    walletAddress?: string;
+    apiUrl?: string;
+}
+export declare function loadConfig(): AgnicConfig;
+export declare function saveConfig(config: AgnicConfig): void;
+export declare function getToken(flags: {
+    token?: string;
+}): string | undefined;
+export declare function getApiUrl(): string;
+export declare function clearConfig(): void;
+export {};

package/dist/lib/config.js

@@ -0,0 +1,39 @@
+/**
+ * Configuration management for agnic CLI
+ * Stores auth token and preferences in ~/.agnic/config.json
+ */
+import { readFileSync, writeFileSync, mkdirSync, existsSync } from 'node:fs';
+import { join } from 'node:path';
+import { homedir } from 'node:os';
+const CONFIG_DIR = join(homedir(), '.agnic');
+const CONFIG_FILE = join(CONFIG_DIR, 'config.json');
+function ensureConfigDir() {
+    if (!existsSync(CONFIG_DIR)) {
+        mkdirSync(CONFIG_DIR, { recursive: true, mode: 0o700 });
+    }
+}
+export function loadConfig() {
+    try {
+        if (!existsSync(CONFIG_FILE))
+            return {};
+        const raw = readFileSync(CONFIG_FILE, 'utf-8');
+        return JSON.parse(raw);
+    }
+    catch {
+        return {};
+    }
+}
+export function saveConfig(config) {
+    ensureConfigDir();
+    writeFileSync(CONFIG_FILE, JSON.stringify(config, null, 2), { mode: 0o600 });
+}
+export function getToken(flags) {
+    // Priority: flag > env > stored
+    return flags.token || process.env.AGNIC_TOKEN || loadConfig().token;
+}
+export function getApiUrl() {
+    return process.env.AGNIC_API_URL || loadConfig().apiUrl || 'https://api.agnic.ai';
+}
+export function clearConfig() {
+    saveConfig({});
+}

package/dist/lib/output.d.ts

@@ -0,0 +1,8 @@
+/**
+ * Output formatting for agnic CLI
+ */
+export declare function printJson(data: any): void;
+export declare function printTable(rows: Record<string, string | number>[]): void;
+export declare function printSuccess(message: string): void;
+export declare function printError(message: string): void;
+export declare function printInfo(message: string): void;

package/dist/lib/output.js

@@ -0,0 +1,31 @@
+/**
+ * Output formatting for agnic CLI
+ */
+import chalk from 'chalk';
+export function printJson(data) {
+    console.log(JSON.stringify(data, null, 2));
+}
+export function printTable(rows) {
+    if (rows.length === 0)
+        return;
+    const keys = Object.keys(rows[0]);
+    const widths = keys.map((k) => Math.max(k.length, ...rows.map((r) => String(r[k]).length)));
+    // Header
+    const header = keys.map((k, i) => k.padEnd(widths[i])).join('  ');
+    console.log(chalk.bold(header));
+    console.log(chalk.gray('-'.repeat(header.length)));
+    // Rows
+    for (const row of rows) {
+        const line = keys.map((k, i) => String(row[k]).padEnd(widths[i])).join('  ');
+        console.log(line);
+    }
+}
+export function printSuccess(message) {
+    console.log(chalk.green(`✓ ${message}`));
+}
+export function printError(message) {
+    console.error(chalk.red(`✗ ${message}`));
+}
+export function printInfo(message) {
+    console.log(chalk.cyan(`ℹ ${message}`));
+}

package/package.json

@@ -0,0 +1,48 @@
+{
+  "name": "agnic",
+  "version": "1.0.0",
+  "description": "CLI for AgnicPay - AI agent wallet for x402 payments and token trading",
+  "type": "module",
+  "bin": {
+    "agnic": "./dist/cli.js"
+  },
+  "files": [
+    "dist/"
+  ],
+  "scripts": {
+    "build": "tsc",
+    "prepublishOnly": "npm run build",
+    "dev": "tsx src/cli.ts",
+    "start": "node dist/cli.js"
+  },
+  "dependencies": {
+    "commander": "^12.0.0",
+    "chalk": "^5.3.0",
+    "ora": "^8.0.0"
+  },
+  "devDependencies": {
+    "typescript": "^5.4.0",
+    "tsx": "^4.7.0",
+    "@types/node": "^22.0.0"
+  },
+  "engines": {
+    "node": ">=18"
+  },
+  "keywords": [
+    "agnic",
+    "agnicpay",
+    "x402",
+    "wallet",
+    "cli",
+    "ai-agent",
+    "trading",
+    "usdc"
+  ],
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/agnicpay/agnicwallet-project",
+    "directory": "agnic-cli"
+  },
+  "homepage": "https://docs.agnic.ai/docs/agnicpay-features/cli"
+}