@darksol/terminal 0.1.1 → 0.2.1

package/src/llm/engine.js

@@ -0,0 +1,286 @@
+import fetch from 'node-fetch';
+import { getKeyFromEnv, getKey, SERVICES } from '../config/keys.js';
+import { getConfig } from '../config/store.js';
+import { theme } from '../ui/theme.js';
+import { spinner, kvDisplay, success, error, warn, info } from '../ui/components.js';
+import { showSection } from '../ui/banner.js';
+
+// ──────────────────────────────────────────────────
+// LLM PROVIDER ADAPTERS
+// ──────────────────────────────────────────────────
+
+const PROVIDERS = {
+  openai: {
+    url: 'https://api.openai.com/v1/chat/completions',
+    defaultModel: 'gpt-4o',
+    authHeader: (key) => ({ 'Authorization': `Bearer ${key}` }),
+    parseResponse: (data) => data.choices?.[0]?.message?.content,
+    parseUsage: (data) => data.usage,
+  },
+  anthropic: {
+    url: 'https://api.anthropic.com/v1/messages',
+    defaultModel: 'claude-sonnet-4-20250514',
+    authHeader: (key) => ({ 'x-api-key': key, 'anthropic-version': '2023-06-01' }),
+    buildBody: (model, messages, systemPrompt) => ({
+      model,
+      max_tokens: 4096,
+      system: systemPrompt,
+      messages: messages.map(m => ({
+        role: m.role === 'system' ? 'user' : m.role,
+        content: m.content,
+      })),
+    }),
+    parseResponse: (data) => data.content?.[0]?.text,
+    parseUsage: (data) => ({ input: data.usage?.input_tokens, output: data.usage?.output_tokens }),
+  },
+  openrouter: {
+    url: 'https://openrouter.ai/api/v1/chat/completions',
+    defaultModel: 'anthropic/claude-sonnet-4-20250514',
+    authHeader: (key) => ({
+      'Authorization': `Bearer ${key}`,
+      'HTTP-Referer': 'https://darksol.net',
+      'X-Title': 'DARKSOL Terminal',
+    }),
+    parseResponse: (data) => data.choices?.[0]?.message?.content,
+    parseUsage: (data) => data.usage,
+  },
+  ollama: {
+    url: null, // Set from config
+    defaultModel: 'llama3.1',
+    authHeader: () => ({}),
+    parseResponse: (data) => data.choices?.[0]?.message?.content || data.message?.content,
+    parseUsage: () => ({ input: 0, output: 0 }),
+  },
+};
+
+// ──────────────────────────────────────────────────
+// LLM ENGINE
+// ──────────────────────────────────────────────────
+
+export class LLMEngine {
+  constructor(opts = {}) {
+    this.provider = opts.provider || getConfig('llm.provider') || 'openai';
+    this.model = opts.model || getConfig('llm.model') || null;
+    this.apiKey = opts.apiKey || null;
+    this.conversationHistory = [];
+    this.systemPrompt = '';
+    this.maxHistoryTokens = opts.maxHistory || 8000;
+    this.temperature = opts.temperature ?? 0.7;
+
+    // Usage tracking
+    this.totalInputTokens = 0;
+    this.totalOutputTokens = 0;
+    this.totalCalls = 0;
+  }
+
+  /**
+   * Initialize the engine — resolve API key
+   */
+  async init(vaultPassword) {
+    if (!this.apiKey) {
+      // Try env first, then vault
+      this.apiKey = getKeyFromEnv(this.provider);
+      if (!this.apiKey && vaultPassword) {
+        this.apiKey = await getKey(this.provider, vaultPassword);
+      }
+    }
+
+    if (!this.apiKey && this.provider !== 'ollama') {
+      throw new Error(`No API key for ${this.provider}. Run: darksol keys add ${this.provider}`);
+    }
+
+    const providerConfig = PROVIDERS[this.provider];
+    if (!providerConfig) {
+      throw new Error(`Unknown LLM provider: ${this.provider}. Supported: ${Object.keys(PROVIDERS).join(', ')}`);
+    }
+
+    if (!this.model) {
+      this.model = providerConfig.defaultModel;
+    }
+
+    // Ollama URL from config
+    if (this.provider === 'ollama') {
+      const host = this.apiKey || getConfig('llm.ollamaHost') || 'http://localhost:11434';
+      PROVIDERS.ollama.url = `${host}/v1/chat/completions`;
+      this.apiKey = 'ollama'; // placeholder
+    }
+
+    return this;
+  }
+
+  /**
+   * Set the system prompt (persona/context for the LLM)
+   */
+  setSystemPrompt(prompt) {
+    this.systemPrompt = prompt;
+    return this;
+  }
+
+  /**
+   * Send a message and get a response
+   */
+  async chat(userMessage, opts = {}) {
+    const providerConfig = PROVIDERS[this.provider];
+
+    // Build messages array
+    const messages = [];
+    if (this.systemPrompt && this.provider !== 'anthropic') {
+      messages.push({ role: 'system', content: this.systemPrompt });
+    }
+
+    // Add conversation history
+    for (const msg of this.conversationHistory) {
+      messages.push(msg);
+    }
+
+    messages.push({ role: 'user', content: userMessage });
+
+    // Build request body
+    let body;
+    if (providerConfig.buildBody) {
+      body = providerConfig.buildBody(this.model, messages, this.systemPrompt);
+    } else {
+      body = {
+        model: this.model,
+        messages,
+        temperature: opts.temperature ?? this.temperature,
+        max_tokens: opts.maxTokens || 4096,
+      };
+
+      // JSON mode if requested
+      if (opts.json) {
+        body.response_format = { type: 'json_object' };
+      }
+    }
+
+    const url = providerConfig.url;
+    const headers = {
+      'Content-Type': 'application/json',
+      ...providerConfig.authHeader(this.apiKey),
+    };
+
+    const response = await fetch(url, {
+      method: 'POST',
+      headers,
+      body: JSON.stringify(body),
+    });
+
+    if (!response.ok) {
+      const errText = await response.text();
+      throw new Error(`LLM API error (${response.status}): ${errText.slice(0, 200)}`);
+    }
+
+    const data = await response.json();
+    const content = providerConfig.parseResponse(data);
+    const usage = providerConfig.parseUsage(data);
+
+    // Track usage
+    this.totalCalls++;
+    if (usage) {
+      this.totalInputTokens += usage.input_tokens || usage.prompt_tokens || usage.input || 0;
+      this.totalOutputTokens += usage.output_tokens || usage.completion_tokens || usage.output || 0;
+    }
+
+    // Store in history
+    if (!opts.ephemeral) {
+      this.conversationHistory.push({ role: 'user', content: userMessage });
+      this.conversationHistory.push({ role: 'assistant', content });
+      this._trimHistory();
+    }
+
+    return {
+      content,
+      usage,
+      model: this.model,
+      provider: this.provider,
+    };
+  }
+
+  /**
+   * One-shot completion (no history)
+   */
+  async complete(prompt, opts = {}) {
+    return this.chat(prompt, { ...opts, ephemeral: true });
+  }
+
+  /**
+   * Get structured JSON response
+   */
+  async json(prompt, opts = {}) {
+    const result = await this.chat(
+      prompt + '\n\nRespond with valid JSON only. No markdown, no explanation.',
+      { ...opts, ephemeral: true }
+    );
+
+    try {
+      // Extract JSON from response (handle markdown code blocks)
+      let jsonStr = result.content;
+      const match = jsonStr.match(/```(?:json)?\s*([\s\S]*?)\s*```/);
+      if (match) jsonStr = match[1];
+
+      result.parsed = JSON.parse(jsonStr.trim());
+    } catch {
+      result.parsed = null;
+    }
+
+    return result;
+  }
+
+  /**
+   * Clear conversation history
+   */
+  clearHistory() {
+    this.conversationHistory = [];
+    return this;
+  }
+
+  /**
+   * Get usage stats
+   */
+  getUsage() {
+    return {
+      calls: this.totalCalls,
+      inputTokens: this.totalInputTokens,
+      outputTokens: this.totalOutputTokens,
+      totalTokens: this.totalInputTokens + this.totalOutputTokens,
+      provider: this.provider,
+      model: this.model,
+    };
+  }
+
+  /**
+   * Trim history to stay within token budget (rough estimate)
+   */
+  _trimHistory() {
+    // Rough: 1 token ≈ 4 chars
+    const estimateTokens = (msgs) => msgs.reduce((sum, m) => sum + Math.ceil(m.content.length / 4), 0);
+
+    while (this.conversationHistory.length > 2 && estimateTokens(this.conversationHistory) > this.maxHistoryTokens) {
+      // Remove oldest pair (user + assistant)
+      this.conversationHistory.splice(0, 2);
+    }
+  }
+}
+
+// ──────────────────────────────────────────────────
+// FACTORY
+// ──────────────────────────────────────────────────
+
+/**
+ * Create and initialize an LLM engine
+ */
+export async function createLLM(opts = {}) {
+  const engine = new LLMEngine(opts);
+  await engine.init(opts.vaultPassword);
+  return engine;
+}
+
+/**
+ * Quick one-shot LLM call (auto-resolves provider/key)
+ */
+export async function ask(prompt, opts = {}) {
+  const engine = await createLLM(opts);
+  return engine.complete(prompt, opts);
+}
+
+export { PROVIDERS };

package/src/llm/intent.js

@@ -0,0 +1,310 @@
+import { createLLM } from './engine.js';
+import { quickPrice } from '../utils/helpers.js';
+import { getConfig } from '../config/store.js';
+import { theme } from '../ui/theme.js';
+import { spinner, kvDisplay, success, error, warn, info } from '../ui/components.js';
+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.
+
+CAPABILITIES:
+- Parse natural language trade instructions into structured 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
+
+USER CONTEXT:
+- Active chain: {{chain}}
+- Active wallet: {{wallet}}
+- Slippage setting: {{slippage}}%
+
+When parsing trade instructions, respond with 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",
+  "warnings": ["array of risk warnings"],
+  "command": "the CLI command to execute"
+}`;
+
+// ──────────────────────────────────────────────────
+// INTENT PARSER
+// ──────────────────────────────────────────────────
+
+/**
+ * Parse natural language into a trading intent
+ * @param {string} input - User's natural language input
+ * @param {object} opts - { provider, model, vaultPassword }
+ * @returns {Promise<object>} Parsed intent
+ */
+export async function parseIntent(input, opts = {}) {
+  const spin = spinner('Understanding your intent...').start();
+
+  try {
+    const llm = await createLLM(opts);
+    const chain = getConfig('chain') || 'base';
+    const wallet = getConfig('activeWallet') || '(not set)';
+    const slippage = getConfig('slippage') || 0.5;
+
+    const systemPrompt = INTENT_SYSTEM_PROMPT
+      .replace('{{chain}}', chain)
+      .replace('{{wallet}}', wallet)
+      .replace('{{slippage}}', slippage);
+
+    llm.setSystemPrompt(systemPrompt);
+
+    // Enrich with price data if we detect a token mention
+    let context = '';
+    const tokenPattern = /\b([A-Z]{2,10})\b/g;
+    const tokens = [...new Set(input.toUpperCase().match(tokenPattern) || [])];
+
+    if (tokens.length > 0 && tokens.length <= 3) {
+      const prices = [];
+      for (const t of tokens) {
+        if (['ETH', 'THE', 'FOR', 'AND', 'BUY', 'SELL', 'DCA', 'SWAP'].includes(t)) continue;
+        const p = await quickPrice(t);
+        if (p) prices.push(`${p.symbol}: $${p.price} (liquidity: $${p.liquidity}, 24h: ${p.change24h}%)`);
+      }
+      if (prices.length > 0) {
+        context = `\n\nCurrent market data:\n${prices.join('\n')}`;
+      }
+    }
+
+    const prompt = `Parse this trading instruction and respond with JSON:\n\n"${input}"${context}`;
+    const result = await llm.json(prompt);
+
+    spin.succeed('Intent parsed');
+
+    if (result.parsed) {
+      return {
+        ...result.parsed,
+        raw: result.content,
+        model: result.model,
+      };
+    }
+
+    return {
+      action: 'unknown',
+      reasoning: result.content,
+      confidence: 0,
+      raw: result.content,
+      model: result.model,
+    };
+  } catch (err) {
+    spin.fail('Intent parsing failed');
+    error(err.message);
+    return { action: 'error', error: err.message };
+  }
+}
+
+// ──────────────────────────────────────────────────
+// INTERACTIVE CHAT
+// ──────────────────────────────────────────────────
+
+/**
+ * Start an interactive trading chat session
+ */
+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('');
+
+  const spin = spinner('Initializing AI...').start();
+  let llm;
+
+  try {
+    llm = await createLLM(opts);
+    const chain = getConfig('chain') || 'base';
+    const wallet = getConfig('activeWallet') || '(not set)';
+    const slippage = getConfig('slippage') || 0.5;
+
+    const systemPrompt = INTENT_SYSTEM_PROMPT
+      .replace('{{chain}}', chain)
+      .replace('{{wallet}}', wallet)
+      .replace('{{slippage}}', slippage);
+
+    llm.setSystemPrompt(systemPrompt);
+    spin.succeed(`AI ready (${llm.provider}/${llm.model})`);
+  } catch (err) {
+    spin.fail('Failed to initialize AI');
+    error(err.message);
+    info('Add an API key: darksol keys add openai');
+    return;
+  }
+
+  const inquirer = (await import('inquirer')).default;
+
+  while (true) {
+    const { input } = await inquirer.prompt([{
+      type: 'input',
+      name: 'input',
+      message: theme.gold('You:'),
+      validate: (v) => v.length > 0 || 'Say something',
+    }]);
+
+    if (['exit', 'quit', 'q'].includes(input.toLowerCase())) {
+      const usage = llm.getUsage();
+      console.log('');
+      info(`Session: ${usage.calls} calls, ${usage.totalTokens} tokens`);
+      break;
+    }
+
+    const spin2 = spinner('Thinking...').start();
+    try {
+      // 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 skipTokens = ['ETH', 'THE', 'FOR', 'AND', 'BUY', 'SELL', 'DCA', 'SWAP', 'WHAT', 'PRICE', 'HOW', 'MUCH'];
+
+      const priceData = [];
+      for (const t of tokens.filter(t => !skipTokens.includes(t)).slice(0, 3)) {
+        const p = await quickPrice(t);
+        if (p) priceData.push(`${p.symbol}: $${p.price} (liq: $${p.liquidity})`);
+      }
+
+      if (priceData.length > 0) {
+        enriched += `\n\n[Live data: ${priceData.join(', ')}]`;
+      }
+
+      const result = await llm.chat(enriched);
+      spin2.succeed('');
+
+      // Display response
+      console.log('');
+      console.log(theme.gold('  DARKSOL AI:'));
+      const lines = result.content.split('\n');
+      for (const line of lines) {
+        console.log(theme.dim('  ') + line);
+      }
+      console.log('');
+
+    } catch (err) {
+      spin2.fail('Error');
+      error(err.message);
+    }
+  }
+}
+
+// ──────────────────────────────────────────────────
+// STRATEGY ADVISOR
+// ──────────────────────────────────────────────────
+
+/**
+ * Get a DCA strategy recommendation
+ */
+export async function adviseStrategy(tokenSymbol, budget, timeframe, opts = {}) {
+  const spin = spinner('Analyzing strategy...').start();
+
+  try {
+    const llm = await createLLM(opts);
+    llm.setSystemPrompt(`You are a DCA strategy advisor for crypto trading on Base/Ethereum. 
+Give specific, actionable DCA recommendations with exact amounts and intervals.
+Always include risk warnings. Be concise.`);
+
+    // Get live price data
+    const price = await quickPrice(tokenSymbol);
+    const priceInfo = price
+      ? `Current price: $${price.price}, Liquidity: $${price.liquidity}, 24h change: ${price.change24h}%`
+      : 'Price data unavailable';
+
+    const prompt = `DCA strategy for ${tokenSymbol}:
+Budget: $${budget}
+Timeframe: ${timeframe}
+${priceInfo}
+
+Recommend: interval, amount per buy, total orders, entry/exit conditions, risk level.`;
+
+    const result = await llm.complete(prompt);
+    spin.succeed('Strategy ready');
+
+    showSection(`DCA STRATEGY — ${tokenSymbol.toUpperCase()}`);
+    const lines = result.content.split('\n');
+    for (const line of lines) {
+      if (line.trim()) console.log('  ' + line);
+    }
+    console.log('');
+
+    return result;
+  } catch (err) {
+    spin.fail('Strategy analysis failed');
+    error(err.message);
+  }
+}
+
+/**
+ * Analyze a token for trading
+ */
+export async function analyzeToken(query, opts = {}) {
+  const spin = spinner(`Analyzing ${query}...`).start();
+
+  try {
+    const llm = await createLLM(opts);
+    llm.setSystemPrompt(`You are a crypto token analyst. Provide factual analysis based on on-chain data.
+Include: price analysis, liquidity assessment, volume trends, risk factors.
+Be objective. Never guarantee returns.`);
+
+    const price = await quickPrice(query);
+    if (!price) {
+      spin.fail('Token not found');
+      return;
+    }
+
+    const prompt = `Analyze this token:
+Symbol: ${price.symbol} (${price.name})
+Chain: ${price.chain}
+Price: $${price.price}
+24h Change: ${price.change24h}%
+Liquidity: $${price.liquidity}
+24h Volume: $${price.volume24h}
+DEX: ${price.dex}
+Contract: ${price.contract}
+
+Provide: sentiment, liquidity assessment, risk level (1-10), key considerations.`;
+
+    const result = await llm.complete(prompt);
+    spin.succeed('Analysis ready');
+
+    showSection(`TOKEN ANALYSIS — ${price.symbol}`);
+    kvDisplay([
+      ['Price', `$${price.price}`],
+      ['24h', `${price.change24h}%`],
+      ['Liquidity', `$${price.liquidity}`],
+      ['Volume', `$${price.volume24h}`],
+    ]);
+    console.log('');
+
+    const lines = result.content.split('\n');
+    for (const line of lines) {
+      if (line.trim()) console.log('  ' + line);
+    }
+    console.log('');
+
+    return result;
+  } catch (err) {
+    spin.fail('Analysis failed');
+    error(err.message);
+  }
+}
+
+export { INTENT_SYSTEM_PROMPT };