@darksol/terminal 0.8.1 → 0.9.1

package/src/llm/engine.js

@@ -1,19 +1,14 @@
 import fetch from 'node-fetch';
-import { getKeyFromEnv, getKey, SERVICES } from '../config/keys.js';
+import { getKeyFromEnv, getKey } 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
-// ──────────────────────────────────────────────────
+import { SessionMemory, extractMemories, searchMemories } from '../memory/index.js';
+import { formatSystemPrompt as formatSoulSystemPrompt } from '../soul/index.js';
 
 const PROVIDERS = {
   openai: {
     url: 'https://api.openai.com/v1/chat/completions',
     defaultModel: 'gpt-4o',
-    authHeader: (key) => ({ 'Authorization': `Bearer ${key}` }),
+    authHeader: (key) => ({ Authorization: `Bearer ${key}` }),
     parseResponse: (data) => data.choices?.[0]?.message?.content,
     parseUsage: (data) => data.usage,
   },
@@ -25,9 +20,9 @@ const PROVIDERS = {
       model,
       max_tokens: 4096,
       system: systemPrompt,
-      messages: messages.map(m => ({
-        role: m.role === 'system' ? 'user' : m.role,
-        content: m.content,
+      messages: messages.map((message) => ({
+        role: message.role === 'system' ? 'user' : message.role,
+        content: message.content,
       })),
     }),
     parseResponse: (data) => data.content?.[0]?.text,
@@ -37,15 +32,22 @@ const PROVIDERS = {
     url: 'https://openrouter.ai/api/v1/chat/completions',
     defaultModel: 'anthropic/claude-sonnet-4-20250514',
     authHeader: (key) => ({
-      'Authorization': `Bearer ${key}`,
+      Authorization: `Bearer ${key}`,
       'HTTP-Referer': 'https://darksol.net',
       'X-Title': 'DARKSOL Terminal',
     }),
     parseResponse: (data) => data.choices?.[0]?.message?.content,
     parseUsage: (data) => data.usage,
   },
+  minimax: {
+    url: 'https://api.minimax.io/v1/chat/completions',
+    defaultModel: 'MiniMax-M2.5',
+    authHeader: (key) => ({ Authorization: `Bearer ${key}` }),
+    parseResponse: (data) => data.choices?.[0]?.message?.content,
+    parseUsage: (data) => data.usage,
+  },
   ollama: {
-    url: null, // Set from config
+    url: null,
     defaultModel: 'llama3.1',
     authHeader: () => ({}),
     parseResponse: (data) => data.choices?.[0]?.message?.content || data.message?.content,
@@ -60,32 +62,23 @@ const PROVIDERS = {
   },
 };
 
-// ──────────────────────────────────────────────────
-// 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;
+    this.sessionMemory = opts.sessionMemory || new SessionMemory({ maxTurns: opts.maxTurns || 20 });
+    this.maxRelevantMemories = opts.maxRelevantMemories || 5;
 
-    // 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);
@@ -93,7 +86,6 @@ export class LLMEngine {
     }
 
     if (!this.apiKey && this.provider !== 'ollama') {
-      // Try auto-stored keys as last resort
       const { getKeyAuto } = await import('../config/keys.js');
       this.apiKey = getKeyAuto(this.provider);
     }
@@ -111,47 +103,42 @@ export class LLMEngine {
       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
+      this.apiKey = 'ollama';
     }
 
     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 systemPrompt = opts.skipContext
+      ? (opts.systemPrompt || this.systemPrompt || '')
+      : await this._buildSystemPrompt(userMessage, opts.systemPrompt);
     const messages = [];
-    if (this.systemPrompt && this.provider !== 'anthropic') {
-      messages.push({ role: 'system', content: this.systemPrompt });
+
+    if (systemPrompt && this.provider !== 'anthropic') {
+      messages.push({ role: 'system', content: systemPrompt });
     }
 
-    // Add conversation history
-    for (const msg of this.conversationHistory) {
-      messages.push(msg);
+    if (!opts.skipContext) {
+      for (const message of this.sessionMemory.getContext()) {
+        messages.push(message);
+      }
     }
 
     messages.push({ role: 'user', content: userMessage });
 
-    // Build request body
     let body;
     if (providerConfig.buildBody) {
-      body = providerConfig.buildBody(this.model, messages, this.systemPrompt);
+      body = providerConfig.buildBody(this.model, messages, systemPrompt);
     } else {
       body = {
         model: this.model,
@@ -160,21 +147,17 @@ export class LLMEngine {
         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, {
+    const response = await fetch(providerConfig.url, {
       method: 'POST',
-      headers,
+      headers: {
+        'Content-Type': 'application/json',
+        ...providerConfig.authHeader(this.apiKey),
+      },
       body: JSON.stringify(body),
     });
 
@@ -187,18 +170,21 @@ export class LLMEngine {
     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();
+      this.sessionMemory.addTurn('user', userMessage);
+      this.sessionMemory.addTurn('assistant', content);
+      await this.sessionMemory.compact(this);
+
+      if (!opts.skipMemoryExtraction) {
+        await extractMemories(userMessage, 'user');
+        await extractMemories(content, 'assistant');
+      }
     }
 
     return {
@@ -209,24 +195,17 @@ export class LLMEngine {
     };
   }
 
-  /**
-   * 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.',
+      `${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];
@@ -239,17 +218,11 @@ export class LLMEngine {
     return result;
   }
 
-  /**
-   * Clear conversation history
-   */
   clearHistory() {
-    this.conversationHistory = [];
+    this.sessionMemory.clear();
     return this;
   }
 
-  /**
-   * Get usage stats
-   */
   getUsage() {
     return {
       calls: this.totalCalls,
@@ -261,36 +234,37 @@ export class LLMEngine {
     };
   }
 
-  /**
-   * 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);
+  async _buildSystemPrompt(userMessage, overridePrompt) {
+    const parts = [];
+    const soulPrompt = formatSoulSystemPrompt();
+    if (soulPrompt) parts.push(soulPrompt);
+    if (overridePrompt || this.systemPrompt) parts.push(overridePrompt || this.systemPrompt);
 
-    while (this.conversationHistory.length > 2 && estimateTokens(this.conversationHistory) > this.maxHistoryTokens) {
-      // Remove oldest pair (user + assistant)
-      this.conversationHistory.splice(0, 2);
+    const summary = this.sessionMemory.getSummary();
+    if (summary) {
+      parts.push(`Session summary:\n${summary}`);
     }
+
+    const relevantMemories = await searchMemories(userMessage);
+    if (relevantMemories.length > 0) {
+      parts.push(
+        `Relevant persistent memories:\n${relevantMemories
+          .slice(0, this.maxRelevantMemories)
+          .map((memory) => `- [${memory.category}] ${memory.content}`)
+          .join('\n')}`
+      );
+    }
+
+    return parts.filter(Boolean).join('\n\n');
   }
 }
 
-// ──────────────────────────────────────────────────
-// 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);

package/src/memory/index.js

@@ -0,0 +1,275 @@
+import { mkdir, readFile, writeFile } from 'fs/promises';
+import { existsSync } from 'fs';
+import { homedir } from 'os';
+import { join } from 'path';
+import { randomUUID } from 'crypto';
+
+const MEMORY_DIR = join(homedir(), '.darksol', 'memory');
+const MEMORY_FILE = join(MEMORY_DIR, 'memory.json');
+const MEMORY_CATEGORIES = new Set(['preference', 'fact', 'decision', 'lesson']);
+const MEMORY_PATTERNS = [
+  { regex: /\b(i prefer|i like|i usually|my favorite)\b/i, category: 'preference' },
+  { regex: /\b(remember that|remember this|my address is|i live at|my phone number is)\b/i, category: 'fact' },
+  { regex: /\b(always|never|from now on|do not|don't)\b/i, category: 'decision' },
+  { regex: /\b(i learned|lesson|next time|that means)\b/i, category: 'lesson' },
+];
+
+/**
+ * Ensure the memory directory and file exist.
+ * @returns {Promise<void>}
+ */
+async function ensureMemoryStore() {
+  await mkdir(MEMORY_DIR, { recursive: true });
+  if (!existsSync(MEMORY_FILE)) {
+    await writeFile(MEMORY_FILE, '[]\n', 'utf8');
+  }
+}
+
+/**
+ * Load all persistent memories from disk.
+ * @returns {Promise<Array<{id: string, content: string, category: string, timestamp: string, source: string}>>}
+ */
+export async function loadMemories() {
+  await ensureMemoryStore();
+
+  try {
+    const raw = await readFile(MEMORY_FILE, 'utf8');
+    const parsed = JSON.parse(raw);
+    return Array.isArray(parsed) ? parsed : [];
+  } catch {
+    return [];
+  }
+}
+
+/**
+ * Persist the full memory list.
+ * @param {Array<object>} memories
+ * @returns {Promise<void>}
+ */
+async function writeMemories(memories) {
+  await ensureMemoryStore();
+  await writeFile(MEMORY_FILE, `${JSON.stringify(memories, null, 2)}\n`, 'utf8');
+}
+
+/**
+ * Save a memory item to disk.
+ * @param {string} content
+ * @param {'preference'|'fact'|'decision'|'lesson'} category
+ * @param {string} [source='user']
+ * @returns {Promise<object|null>}
+ */
+export async function saveMemory(content, category, source = 'user') {
+  const trimmed = String(content || '').trim();
+  if (!trimmed) return null;
+
+  const finalCategory = MEMORY_CATEGORIES.has(category) ? category : 'fact';
+  const memories = await loadMemories();
+  const duplicate = memories.find((memory) => memory.content.toLowerCase() === trimmed.toLowerCase());
+  if (duplicate) return duplicate;
+
+  const entry = {
+    id: randomUUID(),
+    content: trimmed,
+    category: finalCategory,
+    timestamp: new Date().toISOString(),
+    source,
+  };
+
+  memories.push(entry);
+  await writeMemories(memories);
+  return entry;
+}
+
+/**
+ * Search memories by a text query.
+ * @param {string} query
+ * @returns {Promise<Array<object>>}
+ */
+export async function searchMemories(query) {
+  const trimmed = String(query || '').trim().toLowerCase();
+  if (!trimmed) return [];
+
+  const terms = trimmed.split(/\s+/).filter(Boolean);
+  const memories = await loadMemories();
+
+  return memories
+    .map((memory) => {
+      const haystack = `${memory.content} ${memory.category} ${memory.source}`.toLowerCase();
+      const score = terms.reduce((sum, term) => sum + (haystack.includes(term) ? 1 : 0), 0);
+      return { memory, score };
+    })
+    .filter(({ score }) => score > 0)
+    .sort((a, b) => {
+      if (b.score !== a.score) return b.score - a.score;
+      return new Date(b.memory.timestamp).getTime() - new Date(a.memory.timestamp).getTime();
+    })
+    .map(({ memory }) => memory);
+}
+
+/**
+ * Return the most recent N memories.
+ * @param {number} [n=10]
+ * @returns {Promise<Array<object>>}
+ */
+export async function getRecentMemories(n = 10) {
+  const memories = await loadMemories();
+  return [...memories]
+    .sort((a, b) => new Date(b.timestamp).getTime() - new Date(a.timestamp).getTime())
+    .slice(0, n);
+}
+
+/**
+ * Remove memories older than maxAge milliseconds.
+ * @param {number} maxAge
+ * @returns {Promise<number>}
+ */
+export async function pruneMemories(maxAge) {
+  if (!Number.isFinite(maxAge) || maxAge <= 0) return 0;
+
+  const cutoff = Date.now() - maxAge;
+  const memories = await loadMemories();
+  const kept = memories.filter((memory) => new Date(memory.timestamp).getTime() >= cutoff);
+  await writeMemories(kept);
+  return memories.length - kept.length;
+}
+
+/**
+ * Remove all persistent memories.
+ * @returns {Promise<void>}
+ */
+export async function clearMemories() {
+  await ensureMemoryStore();
+  await writeMemories([]);
+}
+
+/**
+ * Export memories to a JSON file and return its path.
+ * @param {string} filePath
+ * @returns {Promise<string>}
+ */
+export async function exportMemories(filePath) {
+  const memories = await loadMemories();
+  await writeFile(filePath, `${JSON.stringify(memories, null, 2)}\n`, 'utf8');
+  return filePath;
+}
+
+/**
+ * Attempt to extract memory-worthy statements from a message.
+ * @param {string} content
+ * @param {string} [source='user']
+ * @returns {Promise<Array<object>>}
+ */
+export async function extractMemories(content, source = 'user') {
+  const text = String(content || '').trim();
+  if (!text) return [];
+
+  const segments = text
+    .split(/[\n\r]+|(?<=[.!?])\s+/)
+    .map((segment) => segment.trim())
+    .filter(Boolean);
+
+  const saved = [];
+  for (const segment of segments) {
+    for (const pattern of MEMORY_PATTERNS) {
+      if (pattern.regex.test(segment)) {
+        const memory = await saveMemory(segment, pattern.category, source);
+        if (memory) saved.push(memory);
+        break;
+      }
+    }
+  }
+
+  return saved;
+}
+
+/**
+ * In-session conversation memory with rolling compaction.
+ */
+export class SessionMemory {
+  /**
+   * @param {{maxTurns?: number}} [opts]
+   */
+  constructor(opts = {}) {
+    this.maxTurns = opts.maxTurns || 20;
+    this.messages = [];
+    this.summary = '';
+  }
+
+  /**
+   * Add a new turn to the current session.
+   * @param {'user'|'assistant'|'system'} role
+   * @param {string} content
+   * @returns {void}
+   */
+  addTurn(role, content) {
+    const trimmed = String(content || '').trim();
+    if (!trimmed) return;
+    this.messages.push({ role, content: trimmed });
+  }
+
+  /**
+   * Return recent conversation turns.
+   * @returns {Array<{role: string, content: string}>}
+   */
+  getContext() {
+    return [...this.messages];
+  }
+
+  /**
+   * Return the current summary, if one exists.
+   * @returns {string}
+   */
+  getSummary() {
+    return this.summary;
+  }
+
+  /**
+   * Clear all session memory.
+   * @returns {void}
+   */
+  clear() {
+    this.messages = [];
+    this.summary = '';
+  }
+
+  /**
+   * Compact older turns into a short summary with help from the LLM.
+   * @param {{complete: (prompt: string, opts?: object) => Promise<{content: string}>}} llm
+   * @returns {Promise<void>}
+   */
+  async compact(llm) {
+    if (this.messages.length <= this.maxTurns) return;
+
+    const overflow = this.messages.length - this.maxTurns;
+    const batchSize = Math.max(overflow, Math.ceil(this.maxTurns / 2));
+    const olderMessages = this.messages.splice(0, batchSize);
+    const transcript = olderMessages
+      .map((message) => `${message.role.toUpperCase()}: ${message.content}`)
+      .join('\n');
+
+    const prompt = [
+      'Summarize this conversation context for future replies.',
+      'Preserve preferences, decisions, constraints, open tasks, and factual details.',
+      'Keep it under 180 words.',
+      this.summary ? `Existing summary:\n${this.summary}` : '',
+      `Conversation to compact:\n${transcript}`,
+    ].filter(Boolean).join('\n\n');
+
+    try {
+      const result = await llm.complete(prompt, {
+        ephemeral: true,
+        skipContext: true,
+        skipMemoryExtraction: true,
+      });
+      this.summary = String(result.content || '').trim() || this.summary;
+    } catch {
+      const fallback = olderMessages
+        .slice(-4)
+        .map((message) => `${message.role}: ${message.content}`)
+        .join(' | ');
+      this.summary = [this.summary, fallback].filter(Boolean).join(' | ').slice(-1200);
+    }
+  }
+}
+
+export { MEMORY_DIR, MEMORY_FILE };