@darksol/terminal 0.8.1 → 0.9.1

package/src/agent/tools.js

@@ -0,0 +1,311 @@
+import fetch from 'node-fetch';
+import { ethers } from 'ethers';
+import { getConfig, getRPC } from '../config/store.js';
+import { loadWallet } from '../wallet/keystore.js';
+
+const DEXSCREENER_API = 'https://api.dexscreener.com/latest/dex/search?q=';
+const USDC_ADDRESSES = {
+  base: '0x833589fCD6eDb6E08f4c7C32D4f71b54bdA02913',
+  ethereum: '0xA0b86991c6218b36c1d19D4a2e9Eb0cE3606eB48',
+  arbitrum: '0xaf88d065e77c8cC2239327C5EDb3A432268e5831',
+  optimism: '0x0b2C639c533813f4Aa9D7837CAf62653d097Ff85',
+  polygon: '0x3c499c542cEF5E3811e1192ce70d8cC03d5c3359',
+};
+const PORTFOLIO_CHAINS = {
+  base: { name: 'Base' },
+  ethereum: { name: 'Ethereum' },
+  arbitrum: { name: 'Arbitrum' },
+  optimism: { name: 'Optimism' },
+  polygon: { name: 'Polygon' },
+};
+const ERC20_ABI = [
+  'function balanceOf(address) view returns (uint256)',
+  'function decimals() view returns (uint8)',
+];
+
+function compactNumber(value) {
+  const num = Number(value || 0);
+  if (!Number.isFinite(num)) return '0';
+  if (num >= 1e9) return `${(num / 1e9).toFixed(2)}B`;
+  if (num >= 1e6) return `${(num / 1e6).toFixed(2)}M`;
+  if (num >= 1e3) return `${(num / 1e3).toFixed(1)}K`;
+  return num.toFixed(2);
+}
+
+function summarizeResult(result) {
+  if (!result) return 'No result';
+  if (typeof result === 'string') return result;
+  if (result.summary) return result.summary;
+  if (result.final) return result.final;
+  if (result.error) return result.error;
+  if (result.token && result.priceUsd) return `${result.token} at $${result.priceUsd}`;
+  return JSON.stringify(result).slice(0, 240);
+}
+
+async function fetchBestPair(query, fetchImpl = fetch) {
+  const response = await fetchImpl(`${DEXSCREENER_API}${encodeURIComponent(query)}`);
+  const data = await response.json();
+  const pairs = Array.isArray(data.pairs) ? data.pairs : [];
+  if (pairs.length === 0) return null;
+  return pairs.sort((a, b) => (b.liquidity?.usd || 0) - (a.liquidity?.usd || 0))[0];
+}
+
+async function getEthPrice(fetchImpl = fetch) {
+  try {
+    const response = await fetchImpl('https://api.coingecko.com/api/v3/simple/price?ids=ethereum&vs_currencies=usd');
+    const data = await response.json();
+    return Number(data.ethereum?.usd) || 3000;
+  } catch {
+    return 3000;
+  }
+}
+
+async function readTokenBalance(provider, address, tokenAddress) {
+  if (!tokenAddress) return 0;
+  try {
+    const contract = new ethers.Contract(tokenAddress, ERC20_ABI, provider);
+    const raw = await contract.balanceOf(address);
+    const decimals = await contract.decimals();
+    return Number(ethers.formatUnits(raw, decimals));
+  } catch {
+    return 0;
+  }
+}
+
+function requireWallet(walletName) {
+  const resolved = walletName || getConfig('activeWallet');
+  if (!resolved) {
+    throw new Error('No active wallet configured');
+  }
+  return loadWallet(resolved);
+}
+
+function defaultRegistry(deps = {}) {
+  const fetchImpl = deps.fetch || fetch;
+  const providerFactory = deps.providerFactory || ((chain) => new ethers.JsonRpcProvider(getRPC(chain)));
+
+  return {
+    price: {
+      description: 'Fetch a live token price and liquidity snapshot',
+      mutating: false,
+      handler: async ({ token, query }) => {
+        const resolved = token || query;
+        if (!resolved) throw new Error('price requires token or query');
+        const pair = await fetchBestPair(resolved, fetchImpl);
+        if (!pair) return { ok: false, token: resolved, summary: `No market data for ${resolved}` };
+        return {
+          ok: true,
+          token: pair.baseToken?.symbol || resolved.toUpperCase(),
+          name: pair.baseToken?.name || resolved,
+          chain: pair.chainId,
+          dex: pair.dexId,
+          priceUsd: Number(pair.priceUsd || 0),
+          change24h: Number(pair.priceChange?.h24 || 0),
+          liquidityUsd: Number(pair.liquidity?.usd || 0),
+          volume24hUsd: Number(pair.volume?.h24 || 0),
+          pairAddress: pair.pairAddress,
+          summary: `${pair.baseToken?.symbol || resolved} ${Number(pair.priceUsd || 0).toFixed(6)} USD, 24h ${Number(pair.priceChange?.h24 || 0).toFixed(2)}%, liq $${compactNumber(pair.liquidity?.usd)}`,
+        };
+      },
+    },
+    gas: {
+      description: 'Fetch current gas data for a chain',
+      mutating: false,
+      handler: async ({ chain }) => {
+        const resolvedChain = chain || getConfig('chain') || 'base';
+        const provider = providerFactory(resolvedChain);
+        const feeData = await provider.getFeeData();
+        const gasPriceWei = feeData.gasPrice || 0n;
+        const gasPriceGwei = Number(ethers.formatUnits(gasPriceWei, 'gwei'));
+        const ethPrice = await getEthPrice(fetchImpl);
+        return {
+          ok: true,
+          chain: resolvedChain,
+          gasPriceGwei,
+          maxFeeGwei: Number(ethers.formatUnits(feeData.maxFeePerGas || 0n, 'gwei')),
+          priorityFeeGwei: Number(ethers.formatUnits(feeData.maxPriorityFeePerGas || 0n, 'gwei')),
+          ethPriceUsd: ethPrice,
+          summary: `${resolvedChain} gas ${gasPriceGwei.toFixed(2)} gwei`,
+        };
+      },
+    },
+    'wallet-balance': {
+      description: 'Read the active or named wallet native and USDC balances',
+      mutating: false,
+      handler: async ({ wallet, chain }) => {
+        const walletData = requireWallet(wallet);
+        const resolvedChain = chain || getConfig('chain') || walletData.chain || 'base';
+        const provider = providerFactory(resolvedChain);
+        const native = Number(ethers.formatEther(await provider.getBalance(walletData.address)));
+        const usdc = await readTokenBalance(provider, walletData.address, USDC_ADDRESSES[resolvedChain]);
+        return {
+          ok: true,
+          wallet: walletData.name,
+          address: walletData.address,
+          chain: resolvedChain,
+          native,
+          nativeSymbol: 'ETH',
+          usdc,
+          summary: `${walletData.name} on ${resolvedChain}: ${native.toFixed(6)} ETH and ${usdc.toFixed(2)} USDC`,
+        };
+      },
+    },
+    portfolio: {
+      description: 'Read wallet balances across supported chains',
+      mutating: false,
+      handler: async ({ wallet }) => {
+        const walletData = requireWallet(wallet);
+        const ethPrice = await getEthPrice(fetchImpl);
+        const chains = await Promise.all(
+          Object.entries(PORTFOLIO_CHAINS).map(async ([chainId, meta]) => {
+            try {
+              const provider = providerFactory(chainId);
+              const native = Number(ethers.formatEther(await provider.getBalance(walletData.address)));
+              const usdc = await readTokenBalance(provider, walletData.address, USDC_ADDRESSES[chainId]);
+              const totalUsd = native * ethPrice + usdc;
+              return { chain: chainId, name: meta.name, native, usdc, totalUsd };
+            } catch (error) {
+              return { chain: chainId, name: meta.name, native: 0, usdc: 0, totalUsd: 0, error: error.message };
+            }
+          }),
+        );
+        const totalUsd = chains.reduce((sum, item) => sum + (item.totalUsd || 0), 0);
+        return {
+          ok: true,
+          wallet: walletData.name,
+          address: walletData.address,
+          totalUsd,
+          chains,
+          summary: `${walletData.name} portfolio totals $${totalUsd.toFixed(2)} across ${chains.length} chains`,
+        };
+      },
+    },
+    market: {
+      description: 'Get top market movers or token comparison context',
+      mutating: false,
+      handler: async ({ query, token, chain, limit }) => {
+        const resolved = query || token || chain || getConfig('chain') || 'base';
+        const pair = await fetchBestPair(resolved, fetchImpl);
+        if (!pair) return { ok: false, summary: `No market snapshot for ${resolved}` };
+        return {
+          ok: true,
+          query: resolved,
+          token: pair.baseToken?.symbol || resolved,
+          chain: pair.chainId,
+          priceUsd: Number(pair.priceUsd || 0),
+          change24h: Number(pair.priceChange?.h24 || 0),
+          liquidityUsd: Number(pair.liquidity?.usd || 0),
+          volume24hUsd: Number(pair.volume?.h24 || 0),
+          limit: limit || 1,
+          summary: `Market snapshot ${pair.baseToken?.symbol || resolved}: $${Number(pair.priceUsd || 0).toFixed(6)}, vol $${compactNumber(pair.volume?.h24)}`,
+        };
+      },
+    },
+    watch: {
+      description: 'Take a quick watch snapshot for a token',
+      mutating: false,
+      handler: async ({ token, query }) => {
+        const resolved = token || query;
+        if (!resolved) throw new Error('watch requires token or query');
+        const pair = await fetchBestPair(resolved, fetchImpl);
+        if (!pair) return { ok: false, summary: `No watch data for ${resolved}` };
+        return {
+          ok: true,
+          token: pair.baseToken?.symbol || resolved,
+          priceUsd: Number(pair.priceUsd || 0),
+          change24h: Number(pair.priceChange?.h24 || 0),
+          liquidityUsd: Number(pair.liquidity?.usd || 0),
+          note: 'Watch tool returns a single snapshot inside the agent loop',
+          summary: `Watch snapshot ${pair.baseToken?.symbol || resolved}: $${Number(pair.priceUsd || 0).toFixed(6)}`,
+        };
+      },
+    },
+    swap: {
+      description: 'Execute a token swap',
+      mutating: true,
+      handler: deps.swapHandler || (async (args) => {
+        const { executeSwap } = await import('../trading/swap.js');
+        return executeSwap(args);
+      }),
+    },
+    send: {
+      description: 'Send ETH or ERC-20 tokens',
+      mutating: true,
+      handler: deps.sendHandler || (async (args) => {
+        const { sendFunds } = await import('../wallet/manager.js');
+        return sendFunds(args);
+      }),
+    },
+    'script-run': {
+      description: 'Execute a saved automation script',
+      mutating: true,
+      handler: deps.scriptRunHandler || (async (args) => {
+        const { runScript } = await import('../scripts/engine.js');
+        return runScript(args.name, args);
+      }),
+    },
+  };
+}
+
+export function createToolRegistry(deps = {}) {
+  const base = defaultRegistry(deps);
+  return {
+    ...base,
+    ...(deps.overrides || {}),
+  };
+}
+
+export function listTools(registry) {
+  return Object.entries(registry).map(([name, tool]) => ({
+    name,
+    description: tool.description,
+    mutating: Boolean(tool.mutating),
+  }));
+}
+
+export function createToolExecutor({ registry = createToolRegistry(), allowActions = false, onEvent = () => {} } = {}) {
+  return async function executeTool(name, input = {}) {
+    const tool = registry[name];
+    if (!tool) {
+      return { ok: false, blocked: true, error: `Unknown tool: ${name}`, summary: `Unknown tool ${name}` };
+    }
+
+    if (tool.mutating && !allowActions) {
+      return {
+        ok: false,
+        blocked: true,
+        error: `Tool "${name}" is blocked in safe mode. Re-run with --allow-actions to enable mutating tools.`,
+        summary: `Blocked ${name} in safe mode`,
+      };
+    }
+
+    onEvent({ type: 'tool-start', tool: name, input, mutating: Boolean(tool.mutating) });
+    try {
+      const result = await tool.handler(input);
+      const normalized = typeof result === 'object' && result !== null ? result : { value: result };
+      const finalResult = {
+        ok: normalized.ok !== false,
+        ...normalized,
+        summary: summarizeResult(normalized),
+      };
+      onEvent({ type: 'tool-result', tool: name, result: finalResult });
+      return finalResult;
+    } catch (error) {
+      const failure = { ok: false, error: error.message, summary: error.message };
+      onEvent({ type: 'tool-error', tool: name, error: error.message });
+      return failure;
+    }
+  };
+}
+
+export const AGENT_TOOL_NAMES = [
+  'price',
+  'gas',
+  'wallet-balance',
+  'portfolio',
+  'market',
+  'watch',
+  'swap',
+  'send',
+  'script-run',
+];

package/src/cli.js

@@ -26,8 +26,12 @@ import { addKey, removeKey, listKeys } from './config/keys.js';
 import { parseIntent, startChat, adviseStrategy, analyzeToken, executeIntent } from './llm/intent.js';
 import { startAgentSigner, showAgentDocs } from './wallet/agent-signer.js';
 import { listSkills, installSkill, skillInfo, uninstallSkill } from './services/skills.js';
-import { runSetupWizard, checkFirstRun } from './setup/wizard.js';
+import { runSetupWizard } from './setup/wizard.js';
+import { displaySoul, hasSoul, resetSoul, runSoulSetup } from './soul/index.js';
+import { clearMemories, exportMemories, getRecentMemories, searchMemories } from './memory/index.js';
+import { getAgentStatus, planAgentGoal, runAgentTask } from './agent/index.js';
 import { createRequire } from 'module';
+import { resolve } from 'path';
 const require = createRequire(import.meta.url);
 const { version: PKG_VERSION } = require('../package.json');
 
@@ -647,6 +651,101 @@ export function cli(argv) {
     .option('-m, --model <model>', 'Model name')
     .action((opts) => startChat(opts));
 
+  const soul = program
+    .command('soul')
+    .description('Identity and agent personality')
+    .action(async () => {
+      await runSoulSetup({ reset: !hasSoul() });
+    });
+
+  soul
+    .command('show')
+    .description('Show current soul configuration')
+    .action(() => displaySoul());
+
+  soul
+    .command('reset')
+    .description('Clear soul configuration and re-run setup')
+    .action(async () => {
+      resetSoul();
+      await runSoulSetup({ reset: true });
+    });
+
+  const memory = program
+    .command('memory')
+    .description('Persistent memory store');
+
+  memory
+    .command('show')
+    .description('Show recent persistent memories')
+    .option('-n, --limit <n>', 'Number of memories', '10')
+    .action(async (opts) => {
+      showMiniBanner();
+      showSection('MEMORY');
+      const memories = await getRecentMemories(parseInt(opts.limit, 10) || 10);
+      if (memories.length === 0) {
+        info('No persistent memories stored.');
+        console.log('');
+        return;
+      }
+
+      memories.forEach((memoryItem) => {
+        kvDisplay([
+          ['ID', memoryItem.id],
+          ['Category', memoryItem.category],
+          ['Source', memoryItem.source],
+          ['When', memoryItem.timestamp],
+          ['Content', memoryItem.content],
+        ]);
+        console.log('');
+      });
+    });
+
+  memory
+    .command('search <query...>')
+    .description('Search persistent memories')
+    .action(async (queryParts) => {
+      const query = queryParts.join(' ');
+      showMiniBanner();
+      showSection('MEMORY SEARCH');
+      info(`Query: ${query}`);
+      console.log('');
+
+      const matches = await searchMemories(query);
+      if (matches.length === 0) {
+        warn('No matching memories.');
+        console.log('');
+        return;
+      }
+
+      matches.slice(0, 10).forEach((memoryItem) => {
+        kvDisplay([
+          ['Category', memoryItem.category],
+          ['Source', memoryItem.source],
+          ['When', memoryItem.timestamp],
+          ['Content', memoryItem.content],
+        ]);
+        console.log('');
+      });
+    });
+
+  memory
+    .command('clear')
+    .description('Clear all persistent memories')
+    .action(async () => {
+      await clearMemories();
+      success('Persistent memory cleared.');
+    });
+
+  memory
+    .command('export [file]')
+    .description('Export persistent memories to JSON')
+    .action(async (file) => {
+      const target = resolve(file || `darksol-memory-export-${Date.now()}.json`);
+      await exportMemories(target);
+      success(`Memory exported to ${target}`);
+    });
+
   // ═══════════════════════════════════════
   // SETUP COMMAND
   // ═══════════════════════════════════════
@@ -666,7 +765,7 @@ export function cli(argv) {
   ai
     .command('chat')
     .description('Start interactive AI trading chat')
-    .option('-p, --provider <name>', 'LLM provider (openai, anthropic, openrouter, ollama)')
+    .option('-p, --provider <name>', 'LLM provider (openai, anthropic, openrouter, minimax, ollama)')
     .option('-m, --model <model>', 'Model name')
     .action((opts) => startChat(opts));
 
@@ -785,6 +884,93 @@ export function cli(argv) {
     .command('agent')
     .description('Secure agent signer — PK-isolated wallet for AI agents');
 
+  agent
+    .command('task <goal...>')
+    .description('Run the agent loop against a goal')
+    .option('--max-steps <n>', 'Maximum loop steps', '10')
+    .option('--allow-actions', 'Allow mutating tools such as swap/send/script-run')
+    .action(async (goalParts, opts) => {
+      showMiniBanner();
+      showSection('AGENT TASK');
+      const goal = goalParts.join(' ').trim();
+      info(`Goal: ${goal}`);
+      info(`Mode: ${opts.allowActions ? 'actions enabled' : 'safe mode'}`);
+      console.log('');
+
+      const result = await runAgentTask(goal, {
+        maxSteps: parseInt(opts.maxSteps, 10),
+        allowActions: opts.allowActions,
+        onProgress: (event) => {
+          if (event.type === 'thought') {
+            info(`Step ${event.step}: ${event.action}`);
+            if (event.thought) console.log(`  ${theme.dim(event.thought)}`);
+          }
+          if (event.type === 'observation') {
+            const summary = event.observation?.summary || event.observation?.error || '';
+            if (summary) console.log(`  ${theme.dim(summary)}`);
+            console.log('');
+          }
+        },
+      });
+
+      showSection('AGENT RESULT');
+      kvDisplay([
+        ['Status', result.status],
+        ['Steps', `${result.stepsTaken}/${result.maxSteps}`],
+        ['Stop Reason', result.stopReason],
+      ]);
+      console.log('');
+      if (result.final) {
+        success(result.final);
+        console.log('');
+      }
+    });
+
+  agent
+    .command('plan <goal...>')
+    .description('Generate a concise agent plan for a goal')
+    .action(async (goalParts) => {
+      showMiniBanner();
+      showSection('AGENT PLAN');
+      const goal = goalParts.join(' ').trim();
+      const plan = await planAgentGoal(goal);
+      info(plan.summary);
+      console.log('');
+      plan.steps.forEach((step, index) => console.log(`  ${theme.gold(String(index + 1).padStart(2, ' '))}. ${step}`));
+      console.log('');
+    });
+
+  agent
+    .command('status')
+    .description('Show the latest agent task or plan status')
+    .action(() => {
+      showMiniBanner();
+      showSection('AGENT STATUS');
+      const status = getAgentStatus();
+      if (!status || !status.status) {
+        warn('No agent runs recorded yet.');
+        console.log('');
+        return;
+      }
+
+      kvDisplay([
+        ['Status', status.status || '-'],
+        ['Goal', status.goal || '-'],
+        ['Summary', status.summary || '-'],
+        ['Steps', status.maxSteps ? `${status.stepsTaken || 0}/${status.maxSteps}` : String(status.stepsTaken || 0)],
+        ['Actions', status.allowActions ? 'enabled' : 'safe mode'],
+        ['Started', status.startedAt || '-'],
+        ['Completed', status.completedAt || '-'],
+        ['Updated', status.updatedAt || '-'],
+      ]);
+      if (Array.isArray(status.plan) && status.plan.length > 0) {
+        console.log('');
+        showSection('LAST PLAN');
+        status.plan.forEach((step) => console.log(`  ${theme.dim(step)}`));
+      }
+      console.log('');
+    });
+
   agent
     .command('start [wallet]')
     .description('Start the agent signing proxy')
@@ -951,6 +1137,9 @@ export function cli(argv) {
         ['Output', cfg.output],
         ['Slippage', `${cfg.slippage}%`],
         ['Gas Multiplier', `${cfg.gasMultiplier}x`],
+        ['Soul User', cfg.soul?.userName || theme.dim('(not set)')],
+        ['Agent Name', cfg.soul?.agentName || 'Darksol'],
+        ['Tone', cfg.soul?.tone || theme.dim('(not set)')],
         ['Mail', cfg.mailEmail || theme.dim('(not set)')],
         ['Version', PKG_VERSION],
         ['Config File', configPath()],
@@ -1203,8 +1392,10 @@ function showCommandList() {
     ['dca', 'Dollar-cost averaging orders'],
     ['ai chat', 'Standalone AI chat session'],
     ['ai execute', 'Parse + execute a trade via AI'],
-    ['agent start', 'Start secure agent signer'],
+    ['agent task', 'Run bounded agent loop for a goal'],
     ['keys', 'API key vault'],
+    ['soul', 'Identity and agent personality'],
+    ['memory', 'Persistent cross-session memory'],
     ['script', 'Execution scripts & strategies'],
     ['market', 'Market intel & token data'],
     ['oracle', 'On-chain random oracle'],

package/src/config/keys.js

@@ -84,6 +84,14 @@ export const SERVICES = {
     docsUrl: 'https://openrouter.ai/keys',
     validate: (key) => key.startsWith('sk-or-'),
   },
+  minimax: {
+    name: 'MiniMax',
+    category: 'llm',
+    description: 'MiniMax-M2.5 via OpenAI-compatible chat completions',
+    envVar: 'MINIMAX_API_KEY',
+    docsUrl: 'https://platform.minimax.io/docs/guides/models-intro',
+    validate: (key) => key.length > 10,
+  },
   ollama: {
     name: 'Ollama (Local)',
     category: 'llm',
@@ -420,7 +428,7 @@ export function hasKey(service) {
  */
 export function hasAnyLLM() {
   // Cloud providers — need real validated API keys
-  if (['openai', 'anthropic', 'openrouter', 'bankr'].some(s => hasKey(s))) return true;
+  if (['openai', 'anthropic', 'openrouter', 'minimax', 'bankr'].some(s => hasKey(s))) return true;
   // Ollama — check if explicitly configured via hasKey (validates URL format)
   if (hasKey('ollama')) return true;
   return false;

package/src/config/store.js

@@ -19,6 +19,31 @@ const config = new Conf({
     },
     slippage: { type: 'number', default: 0.5 },
     gasMultiplier: { type: 'number', default: 1.1 },
+    soul: {
+      type: 'object',
+      default: {
+        userName: '',
+        agentName: 'Darksol',
+        tone: '',
+        createdAt: '',
+      },
+    },
+    agentState: {
+      type: 'object',
+      default: {
+        status: '',
+        goal: '',
+        summary: '',
+        plan: [],
+        stepsTaken: 0,
+        maxSteps: 0,
+        allowActions: false,
+        startedAt: null,
+        completedAt: null,
+        stopReason: '',
+        updatedAt: null,
+      },
+    },
     dca: {
       type: 'object',
       default: {
@@ -48,6 +73,10 @@ export function setConfig(key, value) {
   config.set(key, value);
 }
 
+export function deleteConfig(key) {
+  config.delete(key);
+}
+
 export function getAllConfig() {
   return config.store;
 }