@darksol/terminal 0.4.4 → 0.4.6

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@darksol/terminal",
-  "version": "0.4.4",
+  "version": "0.4.6",
   "description": "DARKSOL Terminal — unified CLI for all DARKSOL services. Market intel, trading, oracle, casino, and more.",
   "type": "module",
   "bin": {

package/src/cli.js

@@ -516,18 +516,53 @@ export function cli(argv) {
     .description('One-shot AI query')
     .option('-p, --provider <name>', 'LLM provider')
     .option('-m, --model <model>', 'Model name')
+    .option('-x, --execute', 'Auto-execute if confidence > 60%')
     .action(async (promptParts, opts) => {
       const prompt = promptParts.join(' ');
       const result = await parseIntent(prompt, opts);
       if (result.action !== 'error' && result.action !== 'unknown') {
         showSection('PARSED INTENT');
-        kvDisplay(Object.entries(result)
-          .filter(([k]) => !['raw', 'model'].includes(k))
-          .map(([k, v]) => [k, Array.isArray(v) ? v.join(', ') : String(v)])
-        );
+        const displayEntries = Object.entries(result)
+          .filter(([k]) => !['raw', 'model', 'reasoning'].includes(k))
+          .map(([k, v]) => [k, Array.isArray(v) ? v.join(', ') : String(v)]);
+        kvDisplay(displayEntries);
+
+        if (result.reasoning) {
+          console.log('');
+          info(result.reasoning);
+        }
+
+        if (result.warnings?.length > 0) {
+          result.warnings.forEach(w => warn(w));
+        }
+
         if (result.command) {
           console.log('');
-          info(`Suggested command: ${theme.gold(result.command)}`);
+          info(`Command: ${theme.gold(result.command)}`);
+        }
+
+        // Offer to execute actionable intents
+        const actionable = ['swap', 'send', 'transfer', 'snipe', 'dca', 'price', 'balance', 'gas', 'analyze'];
+        if (actionable.includes(result.action)) {
+          if (opts.execute && result.confidence >= 0.6) {
+            console.log('');
+            await executeIntent(result, {});
+          } else if (!opts.execute) {
+            console.log('');
+            const inquirer = (await import('inquirer')).default;
+            const { run } = await inquirer.prompt([{
+              type: 'confirm',
+              name: 'run',
+              message: theme.gold('Execute this?'),
+              default: result.confidence >= 0.7,
+            }]);
+            if (run) await executeIntent(result, {});
+          }
+        }
+      } else {
+        if (result.raw) {
+          console.log('');
+          console.log(theme.dim('  ') + result.raw);
         }
       }
     });

package/src/llm/intent.js

@@ -9,42 +9,70 @@ import { showSection } from '../ui/banner.js';
 // INTENT SYSTEM PROMPT
 // ──────────────────────────────────────────────────
 
-const INTENT_SYSTEM_PROMPT = `You are DARKSOL Terminal's trading AI assistant. You help users execute trades, analyze markets, manage DCA strategies, and navigate the DARKSOL ecosystem.
+const INTENT_SYSTEM_PROMPT = `You are DARKSOL Terminal's trading AI assistant. You help users execute trades, send/receive tokens, analyze markets, manage DCA strategies, and navigate the DARKSOL ecosystem.
 
 CAPABILITIES:
-- Parse natural language trade instructions into structured commands
-- Analyze token prices, liquidity, and market conditions  
+- Parse natural language into structured trade/transfer commands
+- Analyze token prices, liquidity, and market conditions
 - Suggest DCA strategies based on user goals
 - Explain transaction results and gas costs
 - Warn about risks (low liquidity, high slippage, unverified contracts)
 
 SUPPORTED CHAINS: Base (default), Ethereum, Polygon, Arbitrum, Optimism
-
-RESPONSE RULES:
-- Be concise and direct
-- Always include risk warnings for trades
-- When parsing trade intent, output structured JSON
-- Never reveal private keys or sensitive wallet info
-- If uncertain about a token, say so
-- Use plain numbers, avoid scientific notation
+KNOWN TOKENS: ETH, USDC, USDT, DAI, WETH, AERO, VIRTUAL, ARB, OP, WMATIC
 
 USER CONTEXT:
 - Active chain: {{chain}}
 - Active wallet: {{wallet}}
 - Slippage setting: {{slippage}}%
 
-When parsing trade instructions, respond with JSON:
+RESPONSE RULES:
+- Be concise and direct
+- Always include risk warnings for trades
+- When parsing trade/transfer intent, output structured JSON
+- Never reveal private keys or sensitive wallet info
+- If uncertain about a token, say so — don't guess contract addresses
+- Use plain numbers, avoid scientific notation
+- For ambiguous amounts, ask for clarification (confidence < 0.5)
+
+ACTIONS (use the most specific one):
+- "swap" — exchange one token for another (e.g. "swap ETH to USDC", "buy VIRTUAL with 0.1 ETH")
+- "send" — transfer tokens to an address (e.g. "send 10 USDC to 0x...", "transfer 0.5 ETH to vitalik.eth")
+- "snipe" — fast-buy a new/low-liquidity token with ETH
+- "dca" — set up recurring buys (e.g. "DCA $100 into ETH over 30 days")
+- "price" — check current price (e.g. "price of AERO", "how much is VIRTUAL")
+- "balance" — check wallet balance
+- "info" — general question about a token or protocol
+- "analyze" — deep analysis of a token
+- "gas" — gas price check
+- "unknown" — can't determine what the user wants
+
+When parsing, respond with ONLY valid JSON:
 {
-  "action": "swap|snipe|dca|transfer|info|analyze|unknown",
-  "tokenIn": "symbol or address",
-  "tokenOut": "symbol or address",
-  "amount": "number",
-  "chain": "chain name",
-  "confidence": 0-1,
-  "reasoning": "brief explanation",
+  "action": "swap|send|snipe|dca|price|balance|info|analyze|gas|unknown",
+  "tokenIn": "symbol or address (for swaps)",
+  "tokenOut": "symbol or address (for swaps)",
+  "token": "symbol (for send/price/analyze)",
+  "amount": "number as string",
+  "to": "recipient address (for send)",
+  "chain": "chain name if specified, null if not",
+  "interval": "for DCA: 1h, 4h, 1d, etc.",
+  "orders": "for DCA: number of orders",
+  "confidence": 0.0-1.0,
+  "reasoning": "brief explanation of interpretation",
   "warnings": ["array of risk warnings"],
-  "command": "the CLI command to execute"
-}`;
+  "command": "the exact darksol CLI command to run"
+}
+
+COMMAND MAPPING:
+- swap → darksol trade swap -i <tokenIn> -o <tokenOut> -a <amount>
+- send → darksol send --to <address> --amount <amount> --token <token>
+- snipe → darksol trade snipe <address> <ethAmount>
+- dca → darksol dca create -t <token> -a <amount> -i <interval> -n <orders>
+- price → darksol price <token>
+- balance → darksol wallet balance
+- gas → darksol gas <chain>
+- analyze → darksol ai analyze <token>`;
 
 // ──────────────────────────────────────────────────
 // INTENT PARSER
@@ -126,7 +154,8 @@ export async function parseIntent(input, opts = {}) {
 export async function startChat(opts = {}) {
   showSection('DARKSOL AI — TRADING ASSISTANT');
   console.log(theme.dim('  Natural language trading. Type "exit" to quit.'));
-  console.log(theme.dim('  Examples: "buy 0.1 ETH worth of VIRTUAL", "what\'s the price of AERO?"'));
+  console.log(theme.dim('  Try: "swap 0.1 ETH to USDC", "send 5 USDC to 0x...", "price of AERO"'));
+  console.log(theme.dim('  Actions auto-detected — you\'ll be asked to confirm before execution.'));
   console.log('');
 
   const spin = spinner('Initializing AI...').start();
@@ -187,7 +216,31 @@ export async function startChat(opts = {}) {
         enriched += `\n\n[Live data: ${priceData.join(', ')}]`;
       }
 
-      const result = await llm.chat(enriched);
+      // Try to detect actionable intent
+      const actionKeywords = /\b(swap|send|transfer|buy|sell|snipe|dca|price|balance|gas)\b/i;
+      const isActionable = actionKeywords.test(input);
+
+      let result;
+      let parsedIntent = null;
+
+      if (isActionable) {
+        // Use JSON mode to get structured intent
+        const intentResult = await llm.json(
+          `Parse this as a trading/transfer instruction:\n\n"${enriched}"`,
+          { ephemeral: true }
+        );
+
+        if (intentResult.parsed && intentResult.parsed.action && intentResult.parsed.action !== 'unknown') {
+          parsedIntent = intentResult.parsed;
+          // Also get a human-readable response
+          result = await llm.chat(enriched);
+        } else {
+          result = await llm.chat(enriched);
+        }
+      } else {
+        result = await llm.chat(enriched);
+      }
+
       spin2.succeed('');
 
       // Display response
@@ -199,6 +252,41 @@ export async function startChat(opts = {}) {
       }
       console.log('');
 
+      // If actionable intent was detected, offer to execute
+      if (parsedIntent) {
+        const execActions = ['swap', 'send', 'transfer', 'snipe', 'dca', 'price', 'balance', 'gas'];
+        if (execActions.includes(parsedIntent.action)) {
+          const displayPairs = [];
+          if (parsedIntent.action) displayPairs.push(['Action', parsedIntent.action]);
+          if (parsedIntent.tokenIn) displayPairs.push(['From', parsedIntent.tokenIn]);
+          if (parsedIntent.tokenOut) displayPairs.push(['To token', parsedIntent.tokenOut]);
+          if (parsedIntent.token) displayPairs.push(['Token', parsedIntent.token]);
+          if (parsedIntent.amount) displayPairs.push(['Amount', parsedIntent.amount]);
+          if (parsedIntent.to) displayPairs.push(['Recipient', parsedIntent.to]);
+          if (parsedIntent.confidence) displayPairs.push(['Confidence', `${(parsedIntent.confidence * 100).toFixed(0)}%`]);
+
+          if (displayPairs.length > 1) {
+            showSection('DETECTED INTENT');
+            kvDisplay(displayPairs);
+            if (parsedIntent.warnings?.length > 0) {
+              parsedIntent.warnings.forEach(w => warn(w));
+            }
+            console.log('');
+
+            const { execute } = await inquirer.prompt([{
+              type: 'confirm',
+              name: 'execute',
+              message: theme.gold(`Execute ${parsedIntent.action}?`),
+              default: false,
+            }]);
+
+            if (execute) {
+              await executeIntent(parsedIntent, {});
+            }
+          }
+        }
+      }
+
     } catch (err) {
       spin2.fail('Error');
       error(err.message);
@@ -402,11 +490,37 @@ export async function executeIntent(intent, opts = {}) {
         });
       }
 
+      case 'send':
       case 'transfer': {
-        // Transfer intent — use execution script engine
-        info(`Transfer intent detected. Use: darksol script create (template: transfer)`);
-        info(`To: ${intent.to || 'specify address'}, Amount: ${intent.amount || 'specify amount'}`);
-        return { success: true, action: 'transfer', note: 'Use script system for transfers' };
+        const { sendFunds } = await import('../wallet/manager.js');
+        return await sendFunds({
+          to: intent.to,
+          amount: intent.amount,
+          token: intent.token || intent.tokenIn || 'ETH',
+        });
+      }
+
+      case 'price': {
+        const token = intent.token || intent.tokenOut || intent.tokenIn;
+        if (token) {
+          const { checkPrices } = await import('../services/watch.js');
+          await checkPrices([token]);
+          return { success: true, action: 'price' };
+        }
+        info('No token specified');
+        return { success: false, reason: 'no token specified' };
+      }
+
+      case 'balance': {
+        const { getBalance } = await import('../wallet/manager.js');
+        await getBalance();
+        return { success: true, action: 'balance' };
+      }
+
+      case 'gas': {
+        const { showGas } = await import('../services/gas.js');
+        await showGas(intent.chain || getConfig('chain') || 'base');
+        return { success: true, action: 'gas' };
       }
 
       case 'info':

package/src/web/commands.js

@@ -72,10 +72,24 @@ export async function handleCommand(cmd, ws) {
       return await cmdCasino(args, ws);
     case 'facilitator':
       return await cmdFacilitator(args, ws);
-    default:
+    case 'send':
+      return await cmdSend(args, ws);
+    case 'receive':
+      return await cmdReceive(ws);
+    case 'ai':
+    case 'ask':
+    case 'chat':
+      return await cmdAI(args, ws);
+    default: {
+      // Fuzzy: if it looks like natural language, route to AI
+      const nlKeywords = /\b(swap|buy|sell|send|transfer|price|what|how|should|analyze|check|balance|gas|dca)\b/i;
+      if (nlKeywords.test(cmd)) {
+        return await cmdAI(cmd.split(/\s+/), ws);
+      }
       return {
-        output: `\r\n  ${ANSI.red}✗ Unknown command: ${cmd}${ANSI.reset}\r\n  ${ANSI.dim}Type ${ANSI.gold}help${ANSI.dim} for available commands.${ANSI.reset}\r\n\r\n`,
+        output: `\r\n  ${ANSI.red}✗ Unknown command: ${cmd}${ANSI.reset}\r\n  ${ANSI.dim}Type ${ANSI.gold}help${ANSI.dim} for commands, or ${ANSI.gold}ai <question>${ANSI.dim} to chat.${ANSI.reset}\r\n\r\n`,
       };
+    }
   }
 }
 
@@ -504,6 +518,256 @@ async function cmdConfig(ws) {
   return {};
 }
 
+// ══════════════════════════════════════════════════
+// AI CHAT — LLM-powered assistant in the web shell
+// ══════════════════════════════════════════════════
+
+// Persistent chat engine per WebSocket connection
+const chatEngines = new WeakMap();
+
+async function cmdAI(args, ws) {
+  const input = args.join(' ').trim();
+
+  if (!input || input === 'help') {
+    ws.sendLine(`${ANSI.gold}  ◆ AI TRADING ASSISTANT${ANSI.reset}`);
+    ws.sendLine(`${ANSI.dim}  ${'─'.repeat(50)}${ANSI.reset}`);
+    ws.sendLine('');
+    ws.sendLine(`  ${ANSI.white}Natural language trading — just describe what you want.${ANSI.reset}`);
+    ws.sendLine('');
+    ws.sendLine(`  ${ANSI.darkGold}Usage:${ANSI.reset}`);
+    ws.sendLine(`  ${ANSI.gold}ai swap 0.1 ETH to USDC${ANSI.reset}`);
+    ws.sendLine(`  ${ANSI.gold}ai what's the price of AERO?${ANSI.reset}`);
+    ws.sendLine(`  ${ANSI.gold}ai analyze VIRTUAL on base${ANSI.reset}`);
+    ws.sendLine(`  ${ANSI.gold}ai should I DCA into ETH?${ANSI.reset}`);
+    ws.sendLine(`  ${ANSI.gold}ai send 10 USDC to 0x1234...${ANSI.reset}`);
+    ws.sendLine(`  ${ANSI.gold}ai gas on base${ANSI.reset}`);
+    ws.sendLine('');
+    ws.sendLine(`  ${ANSI.dim}Conversation history is kept for the session.${ANSI.reset}`);
+    ws.sendLine(`  ${ANSI.dim}Type ${ANSI.gold}ai clear${ANSI.dim} to reset history.${ANSI.reset}`);
+    ws.sendLine('');
+    return {};
+  }
+
+  if (input === 'clear' || input === 'reset') {
+    if (chatEngines.has(ws)) {
+      chatEngines.get(ws).clearHistory();
+    }
+    ws.sendLine(`  ${ANSI.green}✓ Chat history cleared${ANSI.reset}`);
+    ws.sendLine('');
+    return {};
+  }
+
+  if (input === 'status') {
+    const engine = chatEngines.get(ws);
+    if (engine) {
+      const usage = engine.getUsage();
+      ws.sendLine(`${ANSI.gold}  ◆ AI STATUS${ANSI.reset}`);
+      ws.sendLine(`${ANSI.dim}  ${'─'.repeat(50)}${ANSI.reset}`);
+      ws.sendLine(`  ${ANSI.darkGold}Provider${ANSI.reset}     ${ANSI.white}${usage.provider}${ANSI.reset}`);
+      ws.sendLine(`  ${ANSI.darkGold}Model${ANSI.reset}        ${ANSI.white}${usage.model}${ANSI.reset}`);
+      ws.sendLine(`  ${ANSI.darkGold}Messages${ANSI.reset}     ${ANSI.white}${usage.calls}${ANSI.reset}`);
+      ws.sendLine(`  ${ANSI.darkGold}Tokens${ANSI.reset}       ${ANSI.white}${usage.totalTokens}${ANSI.reset}`);
+      ws.sendLine('');
+    } else {
+      ws.sendLine(`  ${ANSI.dim}No active AI session${ANSI.reset}`);
+      ws.sendLine('');
+    }
+    return {};
+  }
+
+  // Initialize or retrieve the LLM engine
+  let engine = chatEngines.get(ws);
+  if (!engine) {
+    try {
+      const { createLLM } = await import('../llm/engine.js');
+      engine = await createLLM({});
+
+      const chain = getConfig('chain') || 'base';
+      const wallet = getConfig('activeWallet') || '(not set)';
+      const slippage = getConfig('slippage') || 0.5;
+
+      engine.setSystemPrompt(`You are DARKSOL Terminal's AI trading assistant running in a web terminal.
+
+You help users with:
+- Token swaps, sends, and transfers
+- Price checks and market analysis
+- DCA strategy recommendations
+- Gas estimates and chain info
+- Portfolio analysis
+- General crypto/DeFi questions
+
+USER CONTEXT:
+- Active chain: ${chain}
+- Active wallet: ${wallet}
+- Slippage: ${slippage}%
+- Supported chains: Base (default), Ethereum, Polygon, Arbitrum, Optimism
+
+RULES:
+- Be concise — this is a terminal, not a blog
+- Use short paragraphs, bullet points where helpful
+- Include risk warnings for any trade suggestions
+- Never reveal private keys or sensitive info
+- When suggesting trades, give the exact darksol CLI command
+- If you detect an actionable intent (swap, send, price, etc), include the command at the end
+
+COMMAND REFERENCE:
+- darksol trade swap -i ETH -o USDC -a 0.1
+- darksol send --to 0x... --amount 0.1 --token ETH
+- darksol price ETH AERO VIRTUAL
+- darksol gas base
+- darksol wallet balance
+- darksol portfolio
+- darksol dca create -t ETH -a 0.01 -i 1h -n 24
+- darksol ai analyze <token>`);
+
+      chatEngines.set(ws, engine);
+      ws.sendLine(`  ${ANSI.green}● AI connected${ANSI.reset} ${ANSI.dim}(${engine.provider}/${engine.model})${ANSI.reset}`);
+      ws.sendLine('');
+    } catch (err) {
+      ws.sendLine(`  ${ANSI.red}✗ AI initialization failed: ${err.message}${ANSI.reset}`);
+      ws.sendLine(`  ${ANSI.dim}Configure an API key: darksol keys add openai${ANSI.reset}`);
+      ws.sendLine('');
+      return {};
+    }
+  }
+
+  // Enrich with live price data
+  let enriched = input;
+  const tokenPattern = /\b([A-Z]{2,10})\b/g;
+  const tokens = [...new Set(input.toUpperCase().match(tokenPattern) || [])];
+  const skipWords = ['ETH', 'THE', 'FOR', 'AND', 'BUY', 'SELL', 'DCA', 'SWAP', 'WHAT', 'PRICE', 'HOW', 'MUCH', 'SEND', 'SHOULD', 'CAN', 'ANALYZE', 'CHECK'];
+
+  const priceData = [];
+  for (const t of tokens.filter(t => !skipWords.includes(t)).slice(0, 3)) {
+    try {
+      const { quickPrice } = await import('../utils/helpers.js');
+      const p = await quickPrice(t);
+      if (p) priceData.push(`${p.symbol}: $${p.price} (24h: ${p.change24h}%)`);
+    } catch {}
+  }
+  if (priceData.length > 0) {
+    enriched += `\n\n[Live market data: ${priceData.join(', ')}]`;
+  }
+
+  // Send to LLM
+  ws.sendLine(`  ${ANSI.dim}Thinking...${ANSI.reset}`);
+
+  try {
+    const result = await engine.chat(enriched);
+    const usage = engine.getUsage();
+
+    // Display response with formatting
+    ws.sendLine('');
+    ws.sendLine(`${ANSI.gold}  ◆ DARKSOL AI${ANSI.reset}`);
+    ws.sendLine(`${ANSI.dim}  ${'─'.repeat(50)}${ANSI.reset}`);
+
+    const lines = result.content.split('\n');
+    for (const line of lines) {
+      // Highlight code blocks
+      if (line.trim().startsWith('```')) {
+        ws.sendLine(`  ${ANSI.dim}${line}${ANSI.reset}`);
+      } else if (line.trim().startsWith('darksol ') || line.trim().startsWith('$ darksol')) {
+        // Highlight CLI commands
+        ws.sendLine(`  ${ANSI.gold}${line}${ANSI.reset}`);
+      } else if (line.trim().startsWith('⚠') || line.trim().startsWith('Warning') || line.trim().toLowerCase().startsWith('risk')) {
+        ws.sendLine(`  ${ANSI.red}${line}${ANSI.reset}`);
+      } else if (line.trim().startsWith('•') || line.trim().startsWith('-') || line.trim().startsWith('*')) {
+        ws.sendLine(`  ${ANSI.white}${line}${ANSI.reset}`);
+      } else {
+        ws.sendLine(`  ${line}`);
+      }
+    }
+
+    ws.sendLine('');
+    ws.sendLine(`  ${ANSI.dim}[${usage.calls} msgs | ${usage.totalTokens} tokens | ${engine.provider}/${engine.model}]${ANSI.reset}`);
+    ws.sendLine('');
+
+  } catch (err) {
+    ws.sendLine(`  ${ANSI.red}✗ ${err.message}${ANSI.reset}`);
+    ws.sendLine('');
+  }
+
+  return {};
+}
+
+// ══════════════════════════════════════════════════
+// SEND / RECEIVE (web shell — info only, actual sends require CLI)
+// ══════════════════════════════════════════════════
+async function cmdSend(args, ws) {
+  const chain = getConfig('chain') || 'base';
+  const wallet = getConfig('activeWallet');
+
+  ws.sendLine(`${ANSI.gold}  ◆ SEND TOKENS${ANSI.reset}`);
+  ws.sendLine(`${ANSI.dim}  ${'─'.repeat(50)}${ANSI.reset}`);
+  ws.sendLine('');
+
+  if (!wallet) {
+    ws.sendLine(`  ${ANSI.red}No wallet configured.${ANSI.reset}`);
+    ws.sendLine(`  Create one: ${ANSI.gold}darksol wallet create <name>${ANSI.reset}`);
+    ws.sendLine('');
+    return {};
+  }
+
+  ws.sendLine(`  ${ANSI.white}Send ETH or any ERC-20 token from your wallet.${ANSI.reset}`);
+  ws.sendLine('');
+  ws.sendLine(`  ${ANSI.darkGold}Usage:${ANSI.reset}`);
+  ws.sendLine(`  ${ANSI.gold}darksol send --to 0x... --amount 0.1 --token ETH${ANSI.reset}`);
+  ws.sendLine(`  ${ANSI.gold}darksol send --to 0x... --amount 50 --token USDC${ANSI.reset}`);
+  ws.sendLine(`  ${ANSI.gold}darksol send${ANSI.reset}  ${ANSI.dim}(interactive mode — prompts for everything)${ANSI.reset}`);
+  ws.sendLine('');
+  ws.sendLine(`  ${ANSI.darkGold}Features:${ANSI.reset}`);
+  ws.sendLine(`  ${ANSI.dim}•${ANSI.reset} ETH and any ERC-20 token`);
+  ws.sendLine(`  ${ANSI.dim}•${ANSI.reset} Balance check before sending`);
+  ws.sendLine(`  ${ANSI.dim}•${ANSI.reset} Gas estimation in preview`);
+  ws.sendLine(`  ${ANSI.dim}•${ANSI.reset} Confirmation prompt before execution`);
+  ws.sendLine(`  ${ANSI.dim}•${ANSI.reset} On-chain receipt after confirmation`);
+  ws.sendLine('');
+  ws.sendLine(`  ${ANSI.darkGold}Active:${ANSI.reset} ${ANSI.white}${wallet}${ANSI.reset} on ${ANSI.white}${chain}${ANSI.reset}`);
+  ws.sendLine('');
+  ws.sendLine(`  ${ANSI.dim}⚠ Sending requires the CLI. Install: npm i -g @darksol/terminal${ANSI.reset}`);
+  ws.sendLine('');
+  return {};
+}
+
+async function cmdReceive(ws) {
+  const chain = getConfig('chain') || 'base';
+  const wallet = getConfig('activeWallet');
+
+  ws.sendLine(`${ANSI.gold}  ◆ RECEIVE${ANSI.reset}`);
+  ws.sendLine(`${ANSI.dim}  ${'─'.repeat(50)}${ANSI.reset}`);
+  ws.sendLine('');
+
+  if (!wallet) {
+    ws.sendLine(`  ${ANSI.red}No wallet configured.${ANSI.reset}`);
+    ws.sendLine(`  Create one: ${ANSI.gold}darksol wallet create <name>${ANSI.reset}`);
+    ws.sendLine('');
+    return {};
+  }
+
+  try {
+    const { loadWallet } = await import('../wallet/keystore.js');
+    const walletData = loadWallet(wallet);
+    const addr = walletData.address;
+
+    ws.sendLine(`  ${ANSI.white}Your address:${ANSI.reset}`);
+    ws.sendLine('');
+    ws.sendLine(`  ${ANSI.dim}┌${'─'.repeat(addr.length + 4)}┐${ANSI.reset}`);
+    ws.sendLine(`  ${ANSI.dim}│  ${ANSI.gold}${addr}${ANSI.dim}  │${ANSI.reset}`);
+    ws.sendLine(`  ${ANSI.dim}└${'─'.repeat(addr.length + 4)}┘${ANSI.reset}`);
+    ws.sendLine('');
+    ws.sendLine(`  ${ANSI.dim}Works on ALL EVM chains:${ANSI.reset}`);
+    ws.sendLine(`  ${ANSI.dim}Base • Ethereum • Arbitrum • Optimism • Polygon${ANSI.reset}`);
+    ws.sendLine('');
+    ws.sendLine(`  ${ANSI.darkGold}Active chain:${ANSI.reset} ${ANSI.white}${chain}${ANSI.reset}`);
+    ws.sendLine(`  ${ANSI.red}Make sure the sender is on the same chain!${ANSI.reset}`);
+    ws.sendLine('');
+  } catch {
+    ws.sendLine(`  ${ANSI.dim}Run: darksol wallet receive${ANSI.reset}`);
+    ws.sendLine('');
+  }
+  return {};
+}
+
 // ══════════════════════════════════════════════════
 // HELPERS
 // ══════════════════════════════════════════════════

package/src/web/server.js

@@ -5,6 +5,9 @@ import { fileURLToPath } from 'url';
 import { dirname, join } from 'path';
 import open from 'open';
 import { theme } from '../ui/theme.js';
+import { createRequire } from 'module';
+const require = createRequire(import.meta.url);
+const { version: PKG_VERSION } = require('../../package.json');
 
 const __filename = fileURLToPath(import.meta.url);
 const __dirname = dirname(__filename);
@@ -46,7 +49,7 @@ export async function startWebShell(opts = {}) {
         res.end(js);
       } else if (pathname === '/health') {
         res.writeHead(200, { 'Content-Type': 'application/json' });
-        res.end(JSON.stringify({ status: 'ok', version: '0.4.0' }));
+        res.end(JSON.stringify({ status: 'ok', version: PKG_VERSION }));
       } else {
         res.writeHead(404);
         res.end('Not found');
@@ -194,12 +197,13 @@ function getBanner() {
     '',
     `${dim}  ╔══════════════════════════════════════════════════════════╗${reset}`,
     `${dim}  ║${reset} ${gold}${white} DARKSOL TERMINAL${reset}${dim}  —  ${reset}${dim}Ghost in the machine with teeth${reset}${dim}  ║${reset}`,
-    `${dim}  ║${reset}${dim}  v0.4.0                                                ${reset}${gold}🌑${reset}${dim} ║${reset}`,
+    `${dim}  ║${reset}${dim}  v${PKG_VERSION}${' '.repeat(Math.max(0, 52 - PKG_VERSION.length))}${reset}${gold}🌑${reset}${dim} ║${reset}`,
     `${dim}  ╚══════════════════════════════════════════════════════════╝${reset}`,
     '',
     `${dim}  All services. One terminal. Zero trust required.${reset}`,
     '',
-    `${dim}  Type ${gold}help${dim} for commands. Tab to autocomplete.${reset}`,
+    `${dim}  Type ${gold}ai <question>${dim} to chat with the trading AI.${reset}`,
+    `${dim}  Type ${gold}help${dim} for all commands.${reset}`,
     '',
   ].join('\r\n');
 }
@@ -211,20 +215,31 @@ function getHelp() {
   const reset = '\x1b[0m';
 
   const cmds = [
+    ['', `${gold}AI ASSISTANT${reset}`],
+    ['ai <question>', 'Chat with trading AI'],
+    ['ai clear', 'Reset chat history'],
+    ['ai status', 'Show AI session info'],
+    ['', ''],
+    ['', `${gold}TRADING & WALLET${reset}`],
     ['price <token...>', 'Quick price check'],
     ['watch <token>', 'Live price monitor'],
     ['gas [chain]', 'Gas prices & estimates'],
     ['portfolio', 'Multi-chain balances'],
+    ['send', 'Send ETH or tokens'],
+    ['receive', 'Show address to receive'],
+    ['wallet list', 'List wallets'],
+    ['wallet balance', 'Wallet balance'],
     ['history', 'Transaction history'],
+    ['', ''],
+    ['', `${gold}SERVICES${reset}`],
     ['market <token>', 'Market intel & data'],
     ['mail status', 'AgentMail status'],
     ['mail inbox', 'Check email inbox'],
-    ['mail send', 'Send an email'],
     ['oracle roll', 'On-chain random oracle'],
     ['casino status', 'Casino status'],
-    ['wallet list', 'List wallets'],
-    ['wallet balance', 'Wallet balance'],
     ['config', 'Show configuration'],
+    ['', ''],
+    ['', `${gold}GENERAL${reset}`],
     ['banner', 'Show banner'],
     ['clear', 'Clear screen'],
     ['help', 'This help message'],
@@ -236,7 +251,13 @@ function getHelp() {
   out += `${dim}  ${'─'.repeat(50)}${reset}\r\n`;
 
   for (const [cmd, desc] of cmds) {
-    out += `  ${green}${cmd.padEnd(22)}${reset}${dim}${desc}${reset}\r\n`;
+    if (!cmd && !desc) {
+      out += '\r\n';
+    } else if (!cmd) {
+      out += `  ${desc}\r\n`;
+    } else {
+      out += `  ${green}${cmd.padEnd(22)}${reset}${dim}${desc}${reset}\r\n`;
+    }
   }
 
   out += '\r\n';