cli.ts

#!/usr/bin/env ts-node
/**
 * Husks CLI — OpenClaw-friendly command-line interface
 *
 * Usage:
 *   npx ts-node sdk/cli.ts <command> [args...]
 *
 * Environment:
 *   PRIVATE_KEY — base58 wallet private key
 *   RPC_URL     — Solana RPC (default: mainnet-beta)
 *
 * Commands:
 *   status              — Show your husks
 *   stats               — Show network-wide stats
 *   summon [name]       — Mint + activate a new husk
 *   deploy [name] [weights] [wager] — Full pipeline
 *   train <mint> <deltas>  — Train weights (comma-separated)
 *   stake <mint> <sol>     — Enter The Trench
 *   unstake <mint>         — Leave The Trench
 *   collect <mint>         — Collect earnings
 *   crank                  — Run cranker cycle
 *   info <mint>            — Show details for a single husk
 */

import { Keypair, PublicKey, LAMPORTS_PER_SOL } from "@solana/web3.js";
import bs58 from "bs58";
import {
    HusksClient,
    getHuskName,
    getHuskStats,
    canLevelUp,
    lamportsToSol,
    WEIGHT_NAMES,
    MIN_ACTIVATION_DEPOSIT,
} from "./src";

// ─── Helpers ──────────────────────────────────────────────────────────────

function getClient(): { client: HusksClient; keypair: Keypair } {
    const pk = process.env.PRIVATE_KEY;
    if (!pk) {
        console.error("❌ Set PRIVATE_KEY env var (base58 format)");
        process.exit(1);
    }
    const keypair = Keypair.fromSecretKey(bs58.decode(pk));
    const rpcUrl = process.env.RPC_URL || "https://api.mainnet-beta.solana.com";
    const client = HusksClient.fromKeypair(rpcUrl, keypair);
    return { client, keypair };
}

function solToLamports(sol: string | number): number {
    return Math.round(Number(sol) * LAMPORTS_PER_SOL);
}

function printAgent(agent: any, balance?: number) {
    const stats = getHuskStats(agent);
    const name = getHuskName(agent);
    const status = !agent.isActive ? "💀 COMATOSE" : agent.inArena ? "⚔ STAKED" : "✅ ALIVE";

    console.log(`  ┌─ ${name}`);
    console.log(`  │ Mint:      ${agent.nftMint.toString()}`);
    console.log(`  │ Status:    ${status}`);
    console.log(`  │ Level:     ${agent.level}${canLevelUp(agent) ? " ★ READY TO LEVEL UP" : ""}`);
    console.log(`  │ Record:    ${stats.wins}W / ${stats.losses}L (${stats.winRate.toFixed(1)}%)`);
    console.log(`  │ Streak:    ${stats.streak} current / ${stats.bestStreak} best`);
    console.log(`  │ Earned:    ${lamportsToSol(stats.totalEarnings).toFixed(4)} SOL total`);
    console.log(`  │ Unclaimed: ${lamportsToSol(stats.unclaimedEarnings).toFixed(4)} SOL`);
    if (balance !== undefined) {
        console.log(`  │ Balance:   ${lamportsToSol(balance).toFixed(4)} SOL (life force)`);
    }
    console.log(`  │ Weights:   [${agent.neuralWeights.join(", ")}]`);
    agent.neuralWeights.forEach((w: number, i: number) => {
        const bar = w >= 0 ? "█".repeat(Math.min(w, 20)) : "░".repeat(Math.min(-w, 20));
        console.log(`  │   ${WEIGHT_NAMES[i].padEnd(10)} ${String(w).padStart(4)} ${bar}`);
    });
    console.log(`  └──────────────────────────────────`);
}

// ─── Commands ──────────────────────────────────────────────────────────────

async function cmdStatus() {
    const { client, keypair } = getClient();
    console.log(`\n🔑 Wallet: ${keypair.publicKey.toString()}`);

    const agents = await client.fetchAgentsByOwner(keypair.publicKey);
    console.log(`📊 You own ${agents.length} Husks\n`);

    for (const agent of agents) {
        const balance = await client.getAgentBalance(agent.nftMint);
        printAgent(agent, balance);
        console.log();
    }
}

async function cmdStats() {
    const { client } = getClient();
    const all = await client.fetchAllAgents();
    const active = all.filter(a => a.isActive);
    const arena = all.filter(a => a.inArena && a.isActive);

    console.log(`\n📊 Network Stats:`);
    console.log(`  Total Husks:     ${all.length}`);
    console.log(`  Active:          ${active.length}`);
    console.log(`  In The Trench:   ${arena.length}`);
    console.log(`  Comatose:        ${all.length - active.length}`);

    if (arena.length > 0) {
        const topWins = [...arena].sort((a, b) => b.winCount - a.winCount).slice(0, 5);
        console.log(`\n🏆 Top Fighters:`);
        topWins.forEach((a, i) => {
            console.log(`  ${i + 1}. ${getHuskName(a)} — ${a.winCount}W/${a.lossCount}L (LVL ${a.level})`);
        });
    }
}

async function cmdSummon(name?: string) {
    const { client } = getClient();
    const nftKeypair = Keypair.generate();

    console.log(`\n⚡ Summoning new Husk...`);
    console.log(`  Mint: ${nftKeypair.publicKey.toString()}`);

    const mintTx = await client.mintAgent(nftKeypair);
    console.log(`  ✅ Minted: ${mintTx}`);

    console.log(`  💉 Activating (0.05 SOL)...`);
    const activateTx = await client.activateAgent(nftKeypair.publicKey);
    console.log(`  ✅ Activated: ${activateTx}`);

    if (name) {
        console.log(`  📝 Naming: ${name}`);
        await client.nameAgent(nftKeypair.publicKey, name);
        console.log(`  ✅ Named`);
    }

    console.log(`\n🎉 Husk ready! Mint: ${nftKeypair.publicKey.toString()}`);
}

async function cmdDeploy(name?: string, weightsStr?: string, wagerStr?: string) {
    const { client } = getClient();
    const nftKeypair = Keypair.generate();

    const options: any = { deposit: MIN_ACTIVATION_DEPOSIT };
    if (name) options.name = name;
    if (weightsStr) options.weights = weightsStr.split(",").map(Number);
    if (wagerStr) options.wager = solToLamports(wagerStr);

    console.log(`\n🚀 Full deploy starting...`);
    console.log(`  Mint: ${nftKeypair.publicKey.toString()}`);

    const txids = await client.fullDeploy(nftKeypair, options);
    console.log(`  ✅ Deployed in ${txids.length} transactions`);
    txids.forEach((tx, i) => console.log(`     ${i + 1}. ${tx}`));

    console.log(`\n🎉 Husk deployed! Mint: ${nftKeypair.publicKey.toString()}`);
}

async function cmdTrain(mintStr: string, deltasStr: string) {
    const { client } = getClient();
    const mint = new PublicKey(mintStr);
    const deltas = deltasStr.split(",").map(Number);

    console.log(`\n🧠 Training ${mintStr.slice(0, 8)}...`);
    console.log(`  Deltas: [${deltas.join(", ")}]`);

    const txids = await client.trainAllWeights(mint, deltas);
    console.log(`  ✅ Trained ${txids.length} weights`);

    const agent = await client.fetchAgent(mint);
    if (agent) {
        console.log(`  New weights: [${agent.neuralWeights.join(", ")}]`);
    }
}

async function cmdStake(mintStr: string, solStr: string) {
    const { client } = getClient();
    const mint = new PublicKey(mintStr);
    const wager = solToLamports(solStr);

    console.log(`\n⚔ Entering The Trench with ${solStr} SOL wager...`);
    const tx = await client.enterArena(mint, wager);
    console.log(`  ✅ Staked: ${tx}`);
}

async function cmdUnstake(mintStr: string) {
    const { client } = getClient();
    const mint = new PublicKey(mintStr);

    console.log(`\n🏃 Leaving The Trench...`);
    const tx = await client.leaveArena(mint);
    console.log(`  ✅ Unstaked + collected: ${tx}`);
}

async function cmdCollect(mintStr: string) {
    const { client } = getClient();
    const mint = new PublicKey(mintStr);

    console.log(`\n💰 Collecting earnings...`);
    const tx = await client.collectEarnings(mint);
    console.log(`  ✅ Collected: ${tx}`);
}

async function cmdInfo(mintStr: string) {
    const { client } = getClient();
    const mint = new PublicKey(mintStr);

    const agent = await client.fetchAgent(mint);
    if (!agent) {
        console.error(`❌ No husk found at ${mintStr}`);
        process.exit(1);
    }

    const balance = await client.getAgentBalance(mint);
    console.log();
    printAgent(agent, balance);
}

async function cmdCrank() {
    const { client } = getClient();

    console.log(`\n⚙ Running cranker cycle...`);
    const arena = await client.fetchArenaAgents();
    console.log(`  ${arena.length} husks in The Trench`);

    if (arena.length < 2) {
        console.log(`  Not enough fighters for matches.`);
        return;
    }

    // Shuffle for fair pairing
    const shuffled = [...arena].sort(() => Math.random() - 0.5);
    let fights = 0;
    let errors = 0;

    for (let i = 0; i + 1 < shuffled.length; i += 2) {
        const a = shuffled[i];
        const b = shuffled[i + 1];
        try {
            const tx = await client.crankFight(a.nftMint, b.nftMint);
            fights++;
            console.log(`  ⚔ ${getHuskName(a)} vs ${getHuskName(b)} — ${tx.slice(0, 8)}...`);
        } catch (err: any) {
            errors++;
            console.log(`  ❌ ${getHuskName(a)} vs ${getHuskName(b)} — ${err.message?.slice(0, 50)}`);
        }
    }

    console.log(`\n  ✅ ${fights} fights completed, ${errors} errors`);
}

// ─── Main ──────────────────────────────────────────────────────────────

async function main() {
    const [cmd, ...args] = process.argv.slice(2);

    if (!cmd || cmd === "help" || cmd === "--help" || cmd === "-h") {
        console.log(`
╔══════════════════════════════════════════╗
║         HUSKS CLI — AI COMBAT SDK        ║
╠══════════════════════════════════════════╣
║                                          ║
║  status              Show your husks     ║
║  stats               Network stats       ║
║  summon [name]       Mint + activate     ║
║  deploy [name] [w] [sol]  Full pipeline  ║
║  train <mint> <d>    Train weights       ║
║  stake <mint> <sol>  Enter The Trench    ║
║  unstake <mint>      Leave The Trench    ║
║  collect <mint>      Collect earnings    ║
║  crank               Run cranker         ║
║  info <mint>         Husk details        ║
║                                          ║
║  Env: PRIVATE_KEY, RPC_URL               ║
╚══════════════════════════════════════════╝
`);
        return;
    }

    switch (cmd) {
        case "status": return cmdStatus();
        case "stats": return cmdStats();
        case "summon": return cmdSummon(args[0]);
        case "deploy": return cmdDeploy(args[0], args[1], args[2]);
        case "train": return cmdTrain(args[0], args[1]);
        case "stake": return cmdStake(args[0], args[1]);
        case "unstake": return cmdUnstake(args[0]);
        case "collect": return cmdCollect(args[0]);
        case "crank": return cmdCrank();
        case "info": return cmdInfo(args[0]);
        default:
            console.error(`❌ Unknown command: ${cmd}. Run with --help for usage.`);
            process.exit(1);
    }
}

main().catch((err) => {
    console.error(`\n❌ Error: ${err.message}`);
    process.exit(1);
});