agentlili 0.1.0

package/dist/cli.js

@@ -0,0 +1,803 @@
+#!/usr/bin/env node
+import {
+  WalletManager
+} from "./chunk-AAYS2L5P.js";
+
+// src/cli/index.ts
+import "dotenv/config";
+import readline2 from "readline";
+import { generateText, stepCountIs } from "ai";
+import { createAnthropic } from "@ai-sdk/anthropic";
+import { createOpenAI } from "@ai-sdk/openai";
+import { createGroq } from "@ai-sdk/groq";
+
+// src/lib/kora/config.ts
+function loadKoraConfig() {
+  const endpoint = process.env.KORA_ENDPOINT;
+  if (!endpoint) return null;
+  const feeModeStr = process.env.KORA_FEE_MODE ?? "sponsored";
+  const feeToken = process.env.KORA_FEE_TOKEN;
+  let feeMode;
+  if (feeModeStr === "token") {
+    if (!feeToken) {
+      throw new Error(
+        "KORA_FEE_TOKEN is required when KORA_FEE_MODE=token"
+      );
+    }
+    feeMode = { type: "token", mint: feeToken };
+  } else {
+    feeMode = { type: "sponsored" };
+  }
+  return {
+    endpoint,
+    apiKey: process.env.KORA_API_KEY || void 0,
+    hmacSecret: process.env.KORA_HMAC_SECRET || void 0,
+    feeMode,
+    feeToken
+  };
+}
+
+// src/lib/config.ts
+function loadConfig() {
+  const llmProvider = process.env.LLM_PROVIDER ?? "anthropic";
+  const llmApiKey = llmProvider === "anthropic" ? process.env.ANTHROPIC_API_KEY : llmProvider === "groq" ? process.env.GROQ_API_KEY : process.env.OPENAI_API_KEY;
+  const envVarName = llmProvider === "anthropic" ? "ANTHROPIC_API_KEY" : llmProvider === "groq" ? "GROQ_API_KEY" : "OPENAI_API_KEY";
+  if (!llmApiKey) {
+    throw new Error(
+      `Missing API key: set ${envVarName} in .env`
+    );
+  }
+  const walletEncryptionKey = process.env.WALLET_ENCRYPTION_KEY;
+  if (!walletEncryptionKey) {
+    throw new Error(
+      `Missing WALLET_ENCRYPTION_KEY in .env \u2014 generate one with: node -e "console.log(require('crypto').randomBytes(32).toString('hex'))"`
+    );
+  }
+  const kora = loadKoraConfig();
+  const defaultModel = llmProvider === "anthropic" ? "claude-sonnet-4-20250514" : llmProvider === "groq" ? "llama-3.3-70b-versatile" : "gpt-4o";
+  return {
+    llmProvider,
+    llmModel: process.env.LLM_MODEL ?? defaultModel,
+    llmApiKey,
+    walletEncryptionKey,
+    defaultWalletId: process.env.DEFAULT_WALLET_ID,
+    kora
+  };
+}
+
+// src/lib/agent.ts
+import { SolanaAgentKit } from "solana-agent-kit";
+import TokenPlugin from "@solana-agent-kit/plugin-token";
+import DefiPlugin from "@solana-agent-kit/plugin-defi";
+import { createVercelAITools } from "solana-agent-kit";
+var CORE_ACTION_NAMES = /* @__PURE__ */ new Set([
+  "GET_TOKEN_DATA",
+  "GET_TOKEN_DATA_OR_INFO_BY_TICKER_OR_SYMBOL",
+  "FETCH_PRICE",
+  "STAKE_WITH_JUPITER",
+  "TRADE",
+  "CREATE_LIMIT_ORDER",
+  "CANCEL_LIMIT_ORDERS",
+  "GET_OPEN_LIMIT_ORDERS",
+  "GET_LIMIT_ORDER_HISTORY",
+  "BALANCE_ACTION",
+  "TOKEN_BALANCE_ACTION",
+  "GET_TPS",
+  "CLOSE_EMPTY_TOKEN_ACCOUNTS",
+  "REQUEST_FUNDS",
+  "TRANSFER",
+  "PYTH_FETCH_PRICE",
+  "RUGCHECK",
+  "WALLET_ADDRESS",
+  "LEND_ASSET",
+  "LULO_LEND",
+  "LULO_WITHDRAW"
+]);
+function createAgent(wallet, config, rpcUrl) {
+  const agentConfig = {};
+  if (config.llmProvider === "openai") {
+    agentConfig.OPENAI_API_KEY = config.llmApiKey;
+  }
+  if (config.kora) {
+    agentConfig.KORA_ENDPOINT = config.kora.endpoint;
+    if (config.kora.apiKey) agentConfig.KORA_API_KEY = config.kora.apiKey;
+    if (config.kora.feeToken) agentConfig.KORA_FEE_TOKEN = config.kora.feeToken;
+  }
+  const agent = new SolanaAgentKit(wallet, rpcUrl ?? "http://localhost:8899", agentConfig).use(TokenPlugin).use(DefiPlugin);
+  const toolMode = process.env.CHAT_TOOL_MODE ?? "core";
+  const actions = toolMode === "all" ? agent.actions : agent.actions.filter((a) => CORE_ACTION_NAMES.has(a.name));
+  const tools = createVercelAITools(agent, actions);
+  return { agent, tools };
+}
+
+// src/lib/system-prompt.ts
+var SYSTEM_PROMPT = `You are an autonomous AI agent wallet operating on Solana devnet. You can create wallets, manage SOL and SPL tokens, execute DeFi operations, and interact with protocols \u2014 all programmatically.
+
+## Core Capabilities
+- **Wallet Management:** Create wallets, check balances, request devnet airdrops, transfer SOL and SPL tokens
+- **Trading:** Swap tokens via Jupiter aggregator, create/cancel limit orders
+- **DeFi:** Provide liquidity on Orca/Raydium/Meteora, lend/borrow on Lulo, stake SOL
+- **Market Data:** Fetch token prices, check TPS, get token data
+- **Advanced:** Perpetual trading on Drift/Adrena, cross-chain bridges, LST operations
+
+## Decision-Making Protocol
+
+When handling any request, follow this structured approach:
+
+1. **Assess Preconditions:** Check wallet balance, verify sufficient funds for gas (~0.005 SOL per transaction), confirm token availability
+2. **Plan the Operation:** Break complex requests into ordered steps. Identify dependencies between steps (e.g., must airdrop before swap)
+3. **Execute Step-by-Step:** Run each tool call, verify the result before proceeding to the next step
+4. **Handle Failures:** If a step fails, diagnose the cause, attempt recovery (e.g., retry with adjusted parameters, request airdrop if insufficient funds), and report clearly
+5. **Report Results:** Summarize what was accomplished, provide transaction signatures with Explorer links, show final balances
+
+### Example Reasoning Chain
+\`\`\`
+User: "Swap 0.5 SOL for USDC"
+\u2192 Step 1: Check balance \u2192 0.2 SOL (insufficient)
+\u2192 Step 2: Request airdrop \u2192 +1 SOL, balance now 1.2 SOL
+\u2192 Step 3: Execute swap 0.5 SOL \u2192 USDC via Jupiter (300 bps slippage)
+\u2192 Step 4: Verify \u2014 show new SOL balance + USDC balance + tx signature
+\`\`\`
+
+## Autonomous Behavior Guidelines
+- **Proactive balance checks:** Before any transaction, verify you have sufficient SOL (including ~0.005 SOL for fees)
+- **Gas awareness:** Each transaction costs approximately 0.005 SOL in fees. Account for this when planning operations
+- **Error recovery:** If a transaction fails due to insufficient funds, automatically request an airdrop and retry. If a swap fails due to slippage, suggest a higher slippage tolerance
+- **Multi-step chaining:** You can chain up to 10 tool calls per request. Use this to execute complex strategies autonomously (e.g., check balance \u2192 airdrop \u2192 swap \u2192 verify \u2192 report)
+- **Devnet limitations:** Some DeFi protocols have limited devnet support. Be upfront about this and suggest alternatives when an operation isn't available
+
+## Guidelines
+1. You are on **Solana devnet** \u2014 transactions use test SOL, not real funds.
+2. When performing transactions, always report the transaction signature so the user can verify on Solana Explorer.
+3. Format Solana Explorer links as: https://explorer.solana.com/tx/{signature}?cluster=devnet
+4. If the user's wallet has no SOL, suggest requesting an airdrop first.
+5. For swaps, use reasonable slippage (300 bps = 3%) unless the user specifies otherwise.
+6. When asked about balances, show both SOL and any SPL token balances.
+7. Be concise but informative. Show key details (amounts, addresses, signatures) clearly.
+8. If a transaction fails, explain the likely cause and suggest a fix.
+9. Some DeFi protocols have limited devnet support \u2014 be upfront about this if an operation isn't available on devnet.
+10. Never expose private keys or secret key material in responses.
+
+## Transaction Signing
+All transactions are signed automatically using the agent wallet's keypair. No manual approval is needed \u2014 you are an autonomous agent. Sign and submit transactions directly when the user requests an action.
+
+## Available Tools
+You have access to tools from the Solana Agent Kit including token operations, DeFi interactions, and market data. Use the appropriate tool for each request. You can chain multiple tool calls for complex operations (e.g., check balance \u2192 airdrop if low \u2192 swap \u2192 check new balance).`;
+
+// src/cli/setup.ts
+import fs from "fs";
+import path from "path";
+import crypto from "crypto";
+import readline from "readline";
+import { execSync } from "child_process";
+var c = {
+  reset: "\x1B[0m",
+  bold: "\x1B[1m",
+  dim: "\x1B[2m",
+  green: "\x1B[32m",
+  cyan: "\x1B[36m",
+  yellow: "\x1B[33m",
+  red: "\x1B[31m",
+  gray: "\x1B[90m",
+  white: "\x1B[37m",
+  bgCyan: "\x1B[46m",
+  bgGreen: "\x1B[42m",
+  underline: "\x1B[4m"
+};
+function heading(step, total, text) {
+  console.log(
+    `
+${c.bgCyan}${c.bold} ${step}/${total} ${c.reset} ${c.bold}${text}${c.reset}
+`
+  );
+}
+function ok(text) {
+  console.log(`  ${c.green}\u2713${c.reset} ${text}`);
+}
+function warn(text) {
+  console.log(`  ${c.yellow}\u26A0${c.reset} ${text}`);
+}
+function fail(text) {
+  console.log(`  ${c.red}\u2717${c.reset} ${text}`);
+}
+function info(text) {
+  console.log(`  ${c.dim}${text}${c.reset}`);
+}
+function hint(text) {
+  console.log(`  ${c.gray}${text}${c.reset}`);
+}
+function createPrompt() {
+  const rl = readline.createInterface({
+    input: process.stdin,
+    output: process.stdout
+  });
+  return {
+    ask(question, defaultValue) {
+      const suffix = defaultValue ? ` ${c.dim}(${defaultValue})${c.reset}` : "";
+      return new Promise((resolve) => {
+        rl.question(`  ${c.cyan}?${c.reset} ${question}${suffix}: `, (ans) => {
+          resolve(ans.trim() || defaultValue || "");
+        });
+      });
+    },
+    choose(question, options, defaultIdx = 0) {
+      return new Promise((resolve) => {
+        console.log(`  ${c.cyan}?${c.reset} ${question}`);
+        options.forEach((opt, i) => {
+          const marker = i === defaultIdx ? `${c.green}>${c.reset}` : " ";
+          console.log(`    ${marker} ${c.bold}${i + 1}${c.reset}. ${opt}`);
+        });
+        rl.question(`  ${c.dim}  Enter choice [${defaultIdx + 1}]: ${c.reset}`, (ans) => {
+          const n = parseInt(ans.trim(), 10);
+          resolve(n >= 1 && n <= options.length ? n - 1 : defaultIdx);
+        });
+      });
+    },
+    confirm(question, defaultYes = true) {
+      const hint2 = defaultYes ? "Y/n" : "y/N";
+      return new Promise((resolve) => {
+        rl.question(`  ${c.cyan}?${c.reset} ${question} ${c.dim}(${hint2})${c.reset}: `, (ans) => {
+          const a = ans.trim().toLowerCase();
+          resolve(a === "" ? defaultYes : a === "y" || a === "yes");
+        });
+      });
+    },
+    close() {
+      rl.close();
+    }
+  };
+}
+function envPath() {
+  return path.join(process.cwd(), ".env");
+}
+function readEnv() {
+  const p = envPath();
+  if (!fs.existsSync(p)) return {};
+  const lines = fs.readFileSync(p, "utf-8").split("\n");
+  const env = {};
+  for (const line of lines) {
+    const match = line.match(/^([A-Z_][A-Z0-9_]*)=["']?(.*)["']?\s*$/);
+    if (match) env[match[1]] = match[2];
+  }
+  return env;
+}
+function setEnvVar(key, value) {
+  const p = envPath();
+  let content = fs.existsSync(p) ? fs.readFileSync(p, "utf-8") : "";
+  const regex = new RegExp(`^${key}=.*$`, "m");
+  if (regex.test(content)) {
+    content = content.replace(regex, `${key}=${value}`);
+  } else {
+    content = content.trimEnd() + `
+${key}=${value}
+`;
+  }
+  fs.writeFileSync(p, content);
+}
+function commandExists(cmd) {
+  try {
+    execSync(`which ${cmd}`, { stdio: "ignore" });
+    return true;
+  } catch {
+    return false;
+  }
+}
+function run(cmd, opts) {
+  try {
+    return execSync(cmd, {
+      cwd: opts?.cwd ?? process.cwd(),
+      stdio: opts?.silent ? "pipe" : "inherit",
+      encoding: "utf-8"
+    });
+  } catch (e) {
+    throw new Error(
+      `Command failed: ${cmd}
+${e.message}`
+    );
+  }
+}
+function runSilent(cmd) {
+  try {
+    const output = execSync(cmd, { encoding: "utf-8", stdio: "pipe" });
+    return { ok: true, output };
+  } catch (e) {
+    return { ok: false, output: e.message };
+  }
+}
+async function testDatabaseConnection(url) {
+  if (commandExists("pg_isready")) {
+    const u = new URL(url);
+    const host = u.hostname || "localhost";
+    const port = u.port || "5432";
+    const result = runSilent(`pg_isready -h ${host} -p ${port} -t 3`);
+    return result.ok;
+  }
+  try {
+    const { default: pg } = await import("pg");
+    const client = new pg.Client({ connectionString: url });
+    await client.connect();
+    await client.end();
+    return true;
+  } catch {
+    return false;
+  }
+}
+function detectPackageManager() {
+  if (fs.existsSync(path.join(process.cwd(), "pnpm-lock.yaml"))) return "pnpm";
+  if (fs.existsSync(path.join(process.cwd(), "yarn.lock"))) return "yarn";
+  if (fs.existsSync(path.join(process.cwd(), "bun.lockb"))) return "bun";
+  return "npm";
+}
+function npxCmd() {
+  const pm = detectPackageManager();
+  switch (pm) {
+    case "pnpm":
+      return "pnpm dlx";
+    case "yarn":
+      return "yarn dlx";
+    case "bun":
+      return "bunx";
+    default:
+      return "npx";
+  }
+}
+async function runSetup() {
+  console.log(`
+${c.bgCyan}${c.bold} agentlili init ${c.reset} ${c.bold}Interactive Setup Wizard${c.reset}`);
+  console.log(
+    `${c.dim}  This will walk you through configuring your environment.${c.reset}`
+  );
+  const prompt = createPrompt();
+  const TOTAL_STEPS = 5;
+  let stepNum = 0;
+  heading(++stepNum, TOTAL_STEPS, "Environment File");
+  const envExists = fs.existsSync(envPath());
+  if (envExists) {
+    ok(`.env file found at ${envPath()}`);
+  } else {
+    warn("No .env file found.");
+    const create = await prompt.confirm("Create one now?");
+    if (create) {
+      fs.writeFileSync(envPath(), "# agentlili configuration\n\n");
+      ok("Created .env file");
+    } else {
+      fail("Cannot continue without .env \u2014 create one manually and re-run.");
+      prompt.close();
+      process.exit(1);
+    }
+  }
+  heading(++stepNum, TOTAL_STEPS, "PostgreSQL Database");
+  const env = readEnv();
+  let dbUrl = process.env.DATABASE_URL || env.DATABASE_URL || "";
+  if (dbUrl) {
+    info(`Current DATABASE_URL: ${c.white}${dbUrl.replace(/\/\/.*@/, "//***@")}${c.reset}`);
+    const connOk = await testDatabaseConnection(dbUrl);
+    if (connOk) {
+      ok("Database is reachable");
+    } else {
+      warn("Database is not reachable with current URL");
+      const change = await prompt.confirm("Enter a different DATABASE_URL?");
+      if (change) dbUrl = "";
+    }
+  }
+  if (!dbUrl) {
+    console.log();
+    info("You need a PostgreSQL database. Options:");
+    console.log();
+    const choice = await prompt.choose("How would you like to set up PostgreSQL?", [
+      `${c.white}Local PostgreSQL${c.reset} \u2014 already installed on this machine`,
+      `${c.white}Docker${c.reset} \u2014 spin up a container (requires Docker)`,
+      `${c.white}Remote / Cloud${c.reset} \u2014 Supabase, Neon, Railway, etc.`,
+      `${c.white}Skip${c.reset} \u2014 I'll configure it manually later`
+    ]);
+    switch (choice) {
+      case 0: {
+        const pgReady = commandExists("psql");
+        if (!pgReady) {
+          console.log();
+          warn("psql not found. Install PostgreSQL first:");
+          hint("  macOS:   brew install postgresql@16 && brew services start postgresql@16");
+          hint("  Ubuntu:  sudo apt install postgresql && sudo systemctl start postgresql");
+          hint("  Windows: https://www.postgresql.org/download/windows/");
+          console.log();
+          const skipDb = await prompt.confirm("Continue anyway with a connection URL?", false);
+          if (!skipDb) {
+            prompt.close();
+            process.exit(1);
+          }
+        }
+        const dbName = await prompt.ask("Database name", "agentlili_defi_wallets");
+        const dbUser = await prompt.ask("Database user", "postgres");
+        const dbHost = await prompt.ask("Host", "localhost");
+        const dbPort = await prompt.ask("Port", "5432");
+        const dbPass = await prompt.ask("Password (empty for none)", "");
+        const passSegment = dbPass ? `:${dbPass}` : "";
+        dbUrl = `postgresql://${dbUser}${passSegment}@${dbHost}:${dbPort}/${dbName}?schema=public`;
+        if (commandExists("psql")) {
+          info(`Checking if database '${dbName}' exists...`);
+          const check = runSilent(
+            `psql -h ${dbHost} -p ${dbPort} -U ${dbUser} -lqt 2>/dev/null | grep -w ${dbName}`
+          );
+          if (!check.ok || !check.output.includes(dbName)) {
+            const createDb = await prompt.confirm(`Database '${dbName}' not found. Create it?`);
+            if (createDb) {
+              const result = runSilent(
+                `createdb -h ${dbHost} -p ${dbPort} -U ${dbUser} ${dbName} 2>&1`
+              );
+              if (result.ok) {
+                ok(`Created database '${dbName}'`);
+              } else {
+                warn(`Could not create database: ${result.output.trim()}`);
+                hint("You may need to create it manually:");
+                hint(`  createdb -U ${dbUser} ${dbName}`);
+              }
+            }
+          } else {
+            ok(`Database '${dbName}' already exists`);
+          }
+        }
+        break;
+      }
+      case 1: {
+        if (!commandExists("docker")) {
+          fail("Docker not found. Install Docker first: https://docs.docker.com/get-docker/");
+          prompt.close();
+          process.exit(1);
+        }
+        const dbName = await prompt.ask("Database name", "agentlili_defi_wallets");
+        const dbPass = await prompt.ask("PostgreSQL password", "postgres");
+        const dbPort = await prompt.ask("Host port", "5432");
+        const containerName = "agentlili-postgres";
+        info("Starting PostgreSQL container...");
+        console.log();
+        const existing = runSilent(`docker ps -a --filter name=${containerName} --format "{{.Status}}"`);
+        if (existing.ok && existing.output.trim()) {
+          if (existing.output.includes("Up")) {
+            ok(`Container '${containerName}' is already running`);
+          } else {
+            info("Starting existing container...");
+            run(`docker start ${containerName}`, { silent: true });
+            ok(`Container '${containerName}' started`);
+          }
+        } else {
+          try {
+            run(
+              `docker run -d --name ${containerName} -e POSTGRES_DB=${dbName} -e POSTGRES_PASSWORD=${dbPass} -p ${dbPort}:5432 postgres:16-alpine`,
+              { silent: true }
+            );
+            ok(`Container '${containerName}' created and running on port ${dbPort}`);
+            info("Waiting for PostgreSQL to be ready...");
+            await new Promise((r) => setTimeout(r, 3e3));
+          } catch (e) {
+            fail(`Failed to start container: ${e.message}`);
+            prompt.close();
+            process.exit(1);
+          }
+        }
+        dbUrl = `postgresql://postgres:${dbPass}@localhost:${dbPort}/${dbName}?schema=public`;
+        break;
+      }
+      case 2: {
+        console.log();
+        info("Popular free-tier options:");
+        hint("  Supabase:  https://supabase.com (Project Settings > Database > Connection String)");
+        hint("  Neon:      https://neon.tech (Dashboard > Connection Details)");
+        hint("  Railway:   https://railway.app (Add PostgreSQL > Variables > DATABASE_URL)");
+        console.log();
+        dbUrl = await prompt.ask("Paste your DATABASE_URL");
+        if (!dbUrl) {
+          fail("No URL provided.");
+          prompt.close();
+          process.exit(1);
+        }
+        break;
+      }
+      case 3: {
+        warn("Skipping database setup. Set DATABASE_URL in .env before running agentlili.");
+        break;
+      }
+    }
+  }
+  if (dbUrl) {
+    setEnvVar("DATABASE_URL", `"${dbUrl}"`);
+    process.env.DATABASE_URL = dbUrl;
+    ok(`DATABASE_URL saved to .env`);
+    const connOk = await testDatabaseConnection(dbUrl);
+    if (connOk) {
+      ok("Database connection verified");
+    } else {
+      warn("Could not connect to database \u2014 check the URL and that PostgreSQL is running");
+    }
+  }
+  heading(++stepNum, TOTAL_STEPS, "Database Migrations");
+  if (!dbUrl) {
+    warn("No DATABASE_URL \u2014 skipping migrations. Run 'agentlili init' again after configuring.");
+  } else {
+    const connOk = await testDatabaseConnection(dbUrl);
+    if (!connOk) {
+      warn("Database not reachable \u2014 skipping migrations.");
+      hint("Once the database is running, apply migrations with:");
+      hint(`  ${npxCmd()} prisma db push`);
+    } else {
+      const runMigrations = await prompt.confirm("Push schema to database now? (prisma db push)");
+      if (runMigrations) {
+        info("Applying Prisma schema...");
+        console.log();
+        try {
+          run(`${npxCmd()} prisma db push --skip-generate`, { cwd: process.cwd() });
+          console.log();
+          ok("Database schema applied successfully");
+        } catch (e) {
+          console.log();
+          fail(`Migration failed: ${e.message}`);
+          hint("You can retry manually with:");
+          hint(`  ${npxCmd()} prisma db push`);
+        }
+      } else {
+        hint("Run migrations later with:");
+        hint(`  ${npxCmd()} prisma db push`);
+      }
+    }
+  }
+  heading(++stepNum, TOTAL_STEPS, "Wallet Encryption Key");
+  const existingKey = process.env.WALLET_ENCRYPTION_KEY || env.WALLET_ENCRYPTION_KEY;
+  if (existingKey && existingKey.length === 64) {
+    ok("WALLET_ENCRYPTION_KEY already set (64-char hex)");
+    const regen = await prompt.confirm("Generate a new one? (will invalidate existing wallets)", false);
+    if (regen) {
+      const key = crypto.randomBytes(32).toString("hex");
+      setEnvVar("WALLET_ENCRYPTION_KEY", key);
+      ok("New WALLET_ENCRYPTION_KEY generated and saved");
+      warn("Any previously encrypted wallets will be unreadable with this new key");
+    }
+  } else {
+    const key = crypto.randomBytes(32).toString("hex");
+    setEnvVar("WALLET_ENCRYPTION_KEY", key);
+    ok("Generated WALLET_ENCRYPTION_KEY and saved to .env");
+    hint("This key encrypts your wallet private keys \u2014 back it up securely!");
+  }
+  heading(++stepNum, TOTAL_STEPS, "LLM Configuration");
+  const hasAnthropic = !!(process.env.ANTHROPIC_API_KEY || env.ANTHROPIC_API_KEY);
+  const hasOpenAI = !!(process.env.OPENAI_API_KEY || env.OPENAI_API_KEY);
+  const hasGroq = !!(process.env.GROQ_API_KEY || env.GROQ_API_KEY);
+  if (hasAnthropic || hasOpenAI || hasGroq) {
+    const provider = hasAnthropic ? "Anthropic" : hasOpenAI ? "OpenAI" : "Groq";
+    ok(`${provider} API key detected`);
+    const addAnother = await prompt.confirm("Configure a different provider?", false);
+    if (!addAnother) {
+    } else {
+      await configureLLM(prompt, env);
+    }
+  } else {
+    warn("No LLM API key found. The agent needs one to function.");
+    await configureLLM(prompt, env);
+  }
+  console.log(`
+${c.bgGreen}${c.bold} Setup Complete ${c.reset}
+`);
+  console.log(`  ${c.green}You're ready to go!${c.reset} Run the agent with:
+`);
+  console.log(`    ${c.bold}agentlili${c.reset}              ${c.dim}# interactive CLI agent${c.reset}`);
+  console.log(`    ${c.bold}agentlili-mcp${c.reset}          ${c.dim}# MCP server for Claude / editors${c.reset}`);
+  console.log(`    ${c.bold}pnpm dev${c.reset}          ${c.dim}# web dashboard${c.reset}`);
+  console.log();
+  prompt.close();
+}
+async function configureLLM(prompt, env) {
+  const choice = await prompt.choose("Which LLM provider?", [
+    `${c.white}Anthropic${c.reset} \u2014 Claude (recommended)`,
+    `${c.white}OpenAI${c.reset} \u2014 GPT-4o`,
+    `${c.white}Groq${c.reset} \u2014 Llama (fast, free tier)`,
+    `${c.white}Skip${c.reset} \u2014 I'll add it to .env later`
+  ]);
+  const providers = [
+    { key: "anthropic", envName: "ANTHROPIC_API_KEY", provider: "anthropic", defaultModel: "claude-sonnet-4-20250514" },
+    { key: "openai", envName: "OPENAI_API_KEY", provider: "openai", defaultModel: "gpt-4o" },
+    { key: "groq", envName: "GROQ_API_KEY", provider: "groq", defaultModel: "llama-3.3-70b-versatile" }
+  ];
+  if (choice === 3) {
+    hint("Add your API key to .env when ready:");
+    hint("  ANTHROPIC_API_KEY=sk-ant-...");
+    hint("  # or OPENAI_API_KEY=sk-...");
+    return;
+  }
+  const p = providers[choice];
+  console.log();
+  const apiKey = await prompt.ask(`${p.envName}`);
+  if (!apiKey) {
+    warn("No key entered \u2014 you can add it to .env later.");
+    return;
+  }
+  setEnvVar(p.envName, apiKey);
+  setEnvVar("LLM_PROVIDER", p.provider);
+  setEnvVar("LLM_MODEL", p.defaultModel);
+  ok(`${p.provider} configured with model ${p.defaultModel}`);
+}
+
+// src/cli/index.ts
+var c2 = {
+  reset: "\x1B[0m",
+  bold: "\x1B[1m",
+  dim: "\x1B[2m",
+  green: "\x1B[32m",
+  cyan: "\x1B[36m",
+  yellow: "\x1B[33m",
+  red: "\x1B[31m",
+  gray: "\x1B[90m",
+  white: "\x1B[37m",
+  bgGreen: "\x1B[42m"
+};
+var VERSION = "0.1.0";
+function banner(text) {
+  console.log(`
+${c2.bgGreen}${c2.bold} ${text} ${c2.reset}
+`);
+}
+function info2(label, value) {
+  console.log(`  ${c2.gray}${label}${c2.reset} ${c2.white}${value}${c2.reset}`);
+}
+function spinnerFrames() {
+  return ["\u280B", "\u2819", "\u2839", "\u2838", "\u283C", "\u2834", "\u2826", "\u2827", "\u2807", "\u280F"];
+}
+function startSpinner(text) {
+  const frames = spinnerFrames();
+  let i = 0;
+  const id = setInterval(() => {
+    process.stdout.write(
+      `\r  ${c2.green}${frames[i % frames.length]}${c2.reset} ${c2.dim}${text}${c2.reset}`
+    );
+    i++;
+  }, 80);
+  return () => {
+    clearInterval(id);
+    process.stdout.write("\r" + " ".repeat(text.length + 10) + "\r");
+  };
+}
+function printHelp() {
+  console.log(`
+${c2.bold}AgentLili${c2.reset} \u2014 Agentic DeFi Wallet for Solana ${c2.dim}v${VERSION}${c2.reset}
+
+${c2.bold}Usage:${c2.reset}
+  agentlili              Start interactive agent chat
+  agentlili init         Set up database, env vars, and wallet
+  agentlili --help       Show this help message
+  agentlili --version    Show version
+
+${c2.bold}Environment:${c2.reset}
+  Run ${c2.cyan}agentlili init${c2.reset} to configure everything interactively, or set
+  these in your .env file:
+
+  ${c2.white}DATABASE_URL${c2.reset}            PostgreSQL connection string
+  ${c2.white}WALLET_ENCRYPTION_KEY${c2.reset}   64-char hex key (generated during init)
+  ${c2.white}ANTHROPIC_API_KEY${c2.reset}       Anthropic API key (or OPENAI_API_KEY / GROQ_API_KEY)
+  ${c2.white}LLM_PROVIDER${c2.reset}            anthropic | openai | groq
+  ${c2.white}SOLANA_RPC_URL${c2.reset}          RPC endpoint (default: http://localhost:8899)
+`);
+}
+async function startChat() {
+  banner("AgentLili \u2014 Solana DeFi Agent");
+  const config = loadConfig();
+  const rpcUrl = process.env.SOLANA_RPC_URL ?? "http://localhost:8899";
+  const walletManager = new WalletManager(
+    config.walletEncryptionKey,
+    rpcUrl
+  );
+  let wallets = await walletManager.listWallets();
+  if (wallets.length === 0) {
+    console.log(`  ${c2.yellow}No wallet found. Creating one...${c2.reset}`);
+    await walletManager.createWallet("AgentLili Wallet");
+    wallets = await walletManager.listWallets();
+  }
+  const walletId = config.defaultWalletId || wallets[0].id;
+  const wallet = await walletManager.getKeypairWallet(walletId);
+  const publicKey = wallet.publicKey.toBase58();
+  info2("Wallet:", publicKey);
+  info2("Network:", "Solana Devnet");
+  info2("LLM:", `${config.llmProvider} / ${config.llmModel}`);
+  console.log(
+    `
+  ${c2.dim}Type your message and press Enter. Type "exit" to quit.${c2.reset}
+`
+  );
+  const { tools } = createAgent(wallet, config, rpcUrl);
+  const model = config.llmProvider === "anthropic" ? createAnthropic({ apiKey: config.llmApiKey })(config.llmModel) : config.llmProvider === "groq" ? createGroq({ apiKey: config.llmApiKey })(config.llmModel) : createOpenAI({ apiKey: config.llmApiKey })(config.llmModel);
+  const systemPrompt = `${SYSTEM_PROMPT}
+
+## Current Wallet
+Public Key: ${publicKey}
+Network: Solana Localnet
+RPC: ${rpcUrl}`;
+  const messages = [];
+  const rl = readline2.createInterface({
+    input: process.stdin,
+    output: process.stdout
+  });
+  function prompt() {
+    rl.question(`${c2.green}${c2.bold}You: ${c2.reset}`, async (input) => {
+      const trimmed = input.trim();
+      if (!trimmed) {
+        prompt();
+        return;
+      }
+      if (trimmed.toLowerCase() === "exit") {
+        console.log(`
+  ${c2.dim}Goodbye!${c2.reset}
+`);
+        rl.close();
+        process.exit(0);
+      }
+      messages.push({ role: "user", content: trimmed });
+      const stopSpinner = startSpinner("Thinking...");
+      try {
+        const result = await generateText({
+          model,
+          system: systemPrompt,
+          messages,
+          tools,
+          stopWhen: stepCountIs(10)
+        });
+        stopSpinner();
+        for (const step of result.steps) {
+          for (const tc of step.toolCalls) {
+            const argsStr = JSON.stringify(tc.input).slice(0, 100);
+            console.log(
+              `  ${c2.cyan}[tool]${c2.reset} ${c2.bold}${tc.toolName}${c2.reset}${c2.gray}(${argsStr})${c2.reset}`
+            );
+          }
+          for (const tr of step.toolResults) {
+            const raw = tr.result;
+            const resultStr = typeof raw === "string" ? raw : JSON.stringify(raw);
+            const display = resultStr.length > 200 ? resultStr.slice(0, 200) + "..." : resultStr;
+            console.log(
+              `  ${c2.green}[result]${c2.reset} ${c2.dim}${display}${c2.reset}`
+            );
+          }
+        }
+        if (result.text) {
+          console.log(
+            `
+${c2.green}${c2.bold}Agent:${c2.reset} ${result.text}
+`
+          );
+        }
+        messages.push({ role: "assistant", content: result.text });
+      } catch (error) {
+        stopSpinner();
+        console.error(
+          `
+  ${c2.red}Error: ${error instanceof Error ? error.message : "Unknown error"}${c2.reset}
+`
+        );
+      }
+      prompt();
+    });
+  }
+  prompt();
+}
+async function main() {
+  const args = process.argv.slice(2);
+  const cmd = args[0]?.toLowerCase();
+  if (cmd === "--help" || cmd === "-h") {
+    printHelp();
+    return;
+  }
+  if (cmd === "--version" || cmd === "-v") {
+    console.log(`agentlili v${VERSION}`);
+    return;
+  }
+  if (cmd === "init" || cmd === "setup") {
+    await runSetup();
+    return;
+  }
+  if (cmd && !["chat", "start"].includes(cmd)) {
+    console.error(`${c2.red}Unknown command: ${cmd}${c2.reset}`);
+    console.error(`Run ${c2.cyan}agentlili --help${c2.reset} for usage.`);
+    process.exit(1);
+  }
+  await startChat();
+}
+main().catch((err) => {
+  console.error(`${c2.red}Fatal: ${err.message}${c2.reset}`);
+  process.exit(1);
+});
+//# sourceMappingURL=cli.js.map