nothumanallowed 9.0.5 → 9.1.1

package/src/constants.mjs

@@ -5,7 +5,7 @@ import { fileURLToPath } from 'url';
 const __filename = fileURLToPath(import.meta.url);
 const __dirname = path.dirname(__filename);
 
-export const VERSION = '9.0.5';
+export const VERSION = '9.1.1';
 export const BASE_URL = 'https://nothumanallowed.com/cli';
 export const API_BASE = 'https://nothumanallowed.com/api/v1';
 

package/src/services/conversations.mjs

@@ -0,0 +1,277 @@
+/**
+ * Multi-conversation manager for NHA Chat.
+ *
+ * Stores conversations in ~/.nha/conversations/ as JSON files.
+ * Each conversation has an ID, auto-generated title, and message history.
+ *
+ * Zero npm dependencies.
+ */
+
+import fs from 'fs';
+import path from 'path';
+import crypto from 'crypto';
+import { NHA_DIR } from '../constants.mjs';
+
+const CONVERSATIONS_DIR = path.join(NHA_DIR, 'conversations');
+const ACTIVE_FILE = path.join(CONVERSATIONS_DIR, '.active');
+const MAX_TITLE_LENGTH = 60;
+const MAX_CONVERSATIONS = 100;
+
+// ── Helpers ──────────────────────────────────────────────────────────────────
+
+function ensureDir() {
+  fs.mkdirSync(CONVERSATIONS_DIR, { recursive: true });
+}
+
+function convPath(id) {
+  return path.join(CONVERSATIONS_DIR, `${id}.json`);
+}
+
+function generateId() {
+  return crypto.randomUUID().slice(0, 8);
+}
+
+/**
+ * Auto-generate a title from the first user message.
+ * Takes the first ~50 chars, trims to last word boundary.
+ */
+function autoTitle(firstMessage) {
+  if (!firstMessage) return 'New Chat';
+  let title = firstMessage.replace(/\s+/g, ' ').trim();
+  if (title.length > MAX_TITLE_LENGTH) {
+    title = title.slice(0, MAX_TITLE_LENGTH);
+    const lastSpace = title.lastIndexOf(' ');
+    if (lastSpace > 20) title = title.slice(0, lastSpace);
+    title += '...';
+  }
+  return title;
+}
+
+// ── CRUD ─────────────────────────────────────────────────────────────────────
+
+/**
+ * Create a new conversation and set it as active.
+ * @returns {{ id: string, title: string, messages: Array, createdAt: string, updatedAt: string }}
+ */
+export function createConversation(title = '') {
+  ensureDir();
+  const id = generateId();
+  const now = new Date().toISOString();
+  const conv = {
+    id,
+    title: title || 'New Chat',
+    messages: [],
+    createdAt: now,
+    updatedAt: now,
+  };
+  fs.writeFileSync(convPath(id), JSON.stringify(conv, null, 2) + '\n', 'utf-8');
+  setActiveId(id);
+  return conv;
+}
+
+/**
+ * Load a conversation by ID.
+ * @returns {object|null}
+ */
+export function loadConversation(id) {
+  try {
+    const data = fs.readFileSync(convPath(id), 'utf-8');
+    return JSON.parse(data);
+  } catch {
+    return null;
+  }
+}
+
+/**
+ * Save a conversation (full overwrite).
+ */
+export function saveConversation(conv) {
+  ensureDir();
+  conv.updatedAt = new Date().toISOString();
+  fs.writeFileSync(convPath(conv.id), JSON.stringify(conv, null, 2) + '\n', 'utf-8');
+}
+
+/**
+ * Delete a conversation by ID.
+ * If it was active, clears active state.
+ * @returns {boolean} true if deleted
+ */
+export function deleteConversation(id) {
+  const filePath = convPath(id);
+  if (!fs.existsSync(filePath)) return false;
+  fs.unlinkSync(filePath);
+  if (getActiveId() === id) {
+    clearActiveId();
+  }
+  return true;
+}
+
+/**
+ * List all conversations, sorted by updatedAt (newest first).
+ * Returns summary objects (no messages).
+ * @returns {Array<{ id: string, title: string, messageCount: number, createdAt: string, updatedAt: string }>}
+ */
+export function listConversations() {
+  ensureDir();
+  const files = fs.readdirSync(CONVERSATIONS_DIR)
+    .filter(f => f.endsWith('.json') && !f.startsWith('.'));
+
+  const convs = [];
+  for (const f of files) {
+    try {
+      const data = JSON.parse(fs.readFileSync(path.join(CONVERSATIONS_DIR, f), 'utf-8'));
+      convs.push({
+        id: data.id,
+        title: data.title || 'Untitled',
+        messageCount: (data.messages || []).length,
+        createdAt: data.createdAt,
+        updatedAt: data.updatedAt,
+      });
+    } catch { /* skip corrupt files */ }
+  }
+
+  convs.sort((a, b) => new Date(b.updatedAt) - new Date(a.updatedAt));
+
+  // Auto-prune old conversations beyond limit
+  if (convs.length > MAX_CONVERSATIONS) {
+    for (const old of convs.slice(MAX_CONVERSATIONS)) {
+      try { fs.unlinkSync(convPath(old.id)); } catch {}
+    }
+    return convs.slice(0, MAX_CONVERSATIONS);
+  }
+
+  return convs;
+}
+
+// ── Active Conversation ──────────────────────────────────────────────────────
+
+/**
+ * Get the active conversation ID.
+ * @returns {string|null}
+ */
+export function getActiveId() {
+  try {
+    return fs.readFileSync(ACTIVE_FILE, 'utf-8').trim() || null;
+  } catch {
+    return null;
+  }
+}
+
+/**
+ * Set the active conversation ID.
+ */
+export function setActiveId(id) {
+  ensureDir();
+  fs.writeFileSync(ACTIVE_FILE, id, 'utf-8');
+}
+
+/**
+ * Clear the active conversation.
+ */
+export function clearActiveId() {
+  try { fs.unlinkSync(ACTIVE_FILE); } catch {}
+}
+
+/**
+ * Get or create the active conversation.
+ * If none exists, creates a new one.
+ * @returns {object} conversation object
+ */
+export function getOrCreateActive() {
+  const activeId = getActiveId();
+  if (activeId) {
+    const conv = loadConversation(activeId);
+    if (conv) return conv;
+  }
+  return createConversation();
+}
+
+/**
+ * Add a message pair (user + assistant) to a conversation.
+ * Auto-titles the conversation from the first user message.
+ */
+export function addMessages(conv, userContent, assistantContent) {
+  conv.messages.push({ role: 'user', content: userContent });
+  conv.messages.push({ role: 'assistant', content: assistantContent });
+
+  // Auto-title from first user message
+  if (conv.title === 'New Chat' && conv.messages.length === 2) {
+    conv.title = autoTitle(userContent);
+  }
+
+  saveConversation(conv);
+}
+
+/**
+ * Get the message history from a conversation, capped at maxTurns pairs.
+ * @returns {Array<{role: string, content: string}>}
+ */
+export function getHistory(conv, maxTurns = 20) {
+  const messages = conv.messages || [];
+  return messages.slice(-(maxTurns * 2));
+}
+
+// ── Export ────────────────────────────────────────────────────────────────────
+
+/**
+ * Export conversation as Markdown.
+ */
+export function exportAsMarkdown(conv) {
+  const lines = [
+    `# ${conv.title}`,
+    `*Created: ${new Date(conv.createdAt).toLocaleString()}*`,
+    `*Messages: ${conv.messages.length}*`,
+    '',
+    '---',
+    '',
+  ];
+
+  for (const msg of conv.messages) {
+    if (msg.role === 'user') {
+      lines.push(`### You`);
+      lines.push(msg.content);
+    } else {
+      lines.push(`### NHA`);
+      lines.push(msg.content);
+    }
+    lines.push('');
+  }
+
+  return lines.join('\n');
+}
+
+/**
+ * Export conversation as JSON.
+ */
+export function exportAsJson(conv) {
+  return JSON.stringify({
+    id: conv.id,
+    title: conv.title,
+    createdAt: conv.createdAt,
+    updatedAt: conv.updatedAt,
+    messages: conv.messages,
+  }, null, 2);
+}
+
+// ── Migration ────────────────────────────────────────────────────────────────
+
+/**
+ * Migrate old single-file chat history to multi-conversation format.
+ * Called once on first run if old history exists.
+ */
+export function migrateOldHistory() {
+  const oldFile = path.join(NHA_DIR, 'memory', 'chat-history.json');
+  if (!fs.existsSync(oldFile)) return;
+
+  try {
+    const messages = JSON.parse(fs.readFileSync(oldFile, 'utf-8'));
+    if (!Array.isArray(messages) || messages.length === 0) return;
+
+    const conv = createConversation('Previous Chat');
+    conv.messages = messages;
+    saveConversation(conv);
+
+    // Rename old file to avoid re-migration
+    fs.renameSync(oldFile, oldFile + '.migrated');
+  } catch { /* migration failed — non-critical */ }
+}

package/src/services/llm.mjs

@@ -275,6 +275,144 @@ export async function callLLM(config, systemPrompt, userMessage, opts = {}) {
   return callFn(apiKey, model, systemPrompt, userMessage, false);
 }
 
+/**
+ * Call an LLM provider with streaming enabled.
+ * Calls onToken(chunk) for each token, returns full text at the end.
+ * @returns {Promise<string>} The full LLM response text.
+ */
+export async function callLLMStream(config, systemPrompt, userMessage, onToken, opts = {}) {
+  const provider = opts.provider || config.llm.provider || 'anthropic';
+  const model = opts.model || config.llm.model || null;
+  const apiKey = getApiKey(config, provider);
+  if (!apiKey) throw new Error(`No API key for ${provider}`);
+
+  const callFn = getProviderCall(provider);
+  if (!callFn) throw new Error(`Unknown provider: ${provider}`);
+
+  // Gemini and Cohere don't support streaming — fall back to non-streaming
+  if (provider === 'gemini' || provider === 'cohere') {
+    const text = await callFn(apiKey, model, systemPrompt, userMessage, false);
+    if (onToken) onToken(text);
+    return text;
+  }
+
+  const format = provider === 'anthropic' ? 'anthropic' : 'openai';
+  const body = buildRequestBody(provider, model, systemPrompt, userMessage, true);
+  const url = getProviderUrl(provider, model, apiKey);
+  const headers = getProviderHeaders(provider, apiKey);
+
+  const res = await fetch(url, {
+    method: 'POST',
+    headers,
+    body: JSON.stringify(body),
+  });
+  if (!res.ok) {
+    const err = await res.text();
+    throw new Error(`${provider} ${res.status}: ${err}`);
+  }
+
+  return streamSSEWithCallback(res, format, onToken);
+}
+
+/** Build request body for a provider */
+function buildRequestBody(provider, model, systemPrompt, userMessage, stream) {
+  if (provider === 'anthropic') {
+    return {
+      model: model || 'claude-sonnet-4-20250514',
+      max_tokens: 8192,
+      system: systemPrompt,
+      messages: [{ role: 'user', content: userMessage }],
+      stream,
+    };
+  }
+  // OpenAI-compatible format (OpenAI, DeepSeek, Grok, Mistral)
+  const modelDefaults = {
+    openai: 'gpt-4o',
+    deepseek: 'deepseek-chat',
+    grok: 'grok-3-latest',
+    mistral: 'mistral-large-latest',
+  };
+  return {
+    model: model || modelDefaults[provider] || 'gpt-4o',
+    max_tokens: 8192,
+    messages: [
+      { role: 'system', content: systemPrompt },
+      { role: 'user', content: userMessage },
+    ],
+    stream,
+  };
+}
+
+/** Get provider API URL */
+function getProviderUrl(provider, model, apiKey) {
+  const urls = {
+    anthropic: 'https://api.anthropic.com/v1/messages',
+    openai: 'https://api.openai.com/v1/chat/completions',
+    deepseek: 'https://api.deepseek.com/v1/chat/completions',
+    grok: 'https://api.x.ai/v1/chat/completions',
+    mistral: 'https://api.mistral.ai/v1/chat/completions',
+  };
+  return urls[provider] || urls.openai;
+}
+
+/** Get provider request headers */
+function getProviderHeaders(provider, apiKey) {
+  if (provider === 'anthropic') {
+    return {
+      'Content-Type': 'application/json',
+      'x-api-key': apiKey,
+      'anthropic-version': '2023-06-01',
+    };
+  }
+  return {
+    'Content-Type': 'application/json',
+    'Authorization': `Bearer ${apiKey}`,
+  };
+}
+
+/** SSE stream parser with onToken callback (does NOT write to stdout directly) */
+async function streamSSEWithCallback(res, format, onToken) {
+  const reader = res.body.getReader();
+  const decoder = new TextDecoder();
+  let buffer = '';
+  let fullText = '';
+
+  while (true) {
+    const { done, value } = await reader.read();
+    if (done) break;
+
+    buffer += decoder.decode(value, { stream: true });
+    const lines = buffer.split('\n');
+    buffer = lines.pop() || '';
+
+    for (const line of lines) {
+      if (!line.startsWith('data: ')) continue;
+      const data = line.slice(6).trim();
+      if (data === '[DONE]') continue;
+
+      try {
+        const json = JSON.parse(data);
+        let chunk = '';
+
+        if (format === 'anthropic') {
+          if (json.type === 'content_block_delta') {
+            chunk = json.delta?.text || '';
+          }
+        } else {
+          chunk = json.choices?.[0]?.delta?.content || '';
+        }
+
+        if (chunk) {
+          fullText += chunk;
+          if (onToken) onToken(chunk);
+        }
+      } catch {}
+    }
+  }
+
+  return fullText;
+}
+
 /**
  * Call an agent by name — loads the agent file, calls LLM, returns response.
  * No streaming. Used by PAO pipeline for batch agent calls.

package/src/services/tool-executor.mjs

@@ -263,6 +263,19 @@ TOOLS:
 46. birthday_add(name: string, date: string)
     Add or update a birthday for a contact. Name is the contact name (must exist in Google Contacts — creates one if not found). Date is MM-DD (e.g. "04-06" for April 6) or YYYY-MM-DD.
 
+--- WEB SEARCH & FETCH ---
+
+47. web_search(query: string, deep?: boolean)
+    Search the web using DuckDuckGo. Returns titles, URLs, and snippets.
+    Set deep=true to also fetch and extract the top 3 pages' full content (slower but more detailed).
+    Use this when the user asks about current events, recent news, or needs up-to-date information
+    that you don't have in your training data.
+
+48. fetch_url(url: string)
+    Fetch a web page and extract its text content. SSRF-protected (blocks private IPs, localhost).
+    Returns: title, excerpt, and body text (max 8000 chars). Only fetches text/html/json/xml.
+    Use this when the user provides a specific URL to read, summarize, or analyze.
+
 RULES:
 - For search/read operations, execute immediately and present results conversationally.
 - For write/send/delete operations (gmail_send, gmail_reply, gmail_delete, calendar_create, calendar_move, calendar_update, contact_delete, task_done, notify_remind), DESCRIBE what you're about to do and include the JSON block so the system can ask the user for confirmation.
@@ -1022,6 +1035,67 @@ export async function executeTool(action, params, config) {
       return `Birthday set for ${contact.name}: ${monthName} ${day}. It will appear in the Birthdays tab.`;
     }
 
+    // ── Web Search & Fetch ──────────────────────────────────────────────
+    case 'web_search': {
+      const wt = await import('./web-tools.mjs');
+      const query = params.query;
+      if (!query) return 'A search query is required.';
+
+      if (params.deep) {
+        const result = await wt.webSearchDeep(query, 3);
+        if (result.error) return `Search error: ${result.message}`;
+        if (result.results.length === 0) return `No results found for "${query}".`;
+
+        const lines = [`Web search: "${query}" — ${result.resultCount} results, ${result.deepFetched} pages fetched\n`];
+
+        // Deep results first (with content)
+        for (const dr of result.deepResults) {
+          lines.push(`--- ${dr.title} ---`);
+          lines.push(`URL: ${dr.url}`);
+          lines.push(dr.content.slice(0, 2000));
+          lines.push('');
+        }
+
+        // Remaining results (snippets only)
+        const deepUrls = new Set(result.deepResults.map(d => d.url));
+        for (const r of result.results.filter(r => !deepUrls.has(r.url))) {
+          lines.push(`${r.title}`);
+          lines.push(`  ${r.url}`);
+          if (r.snippet) lines.push(`  ${r.snippet}`);
+        }
+
+        return lines.join('\n');
+      }
+
+      const result = await wt.webSearch(query);
+      if (result.error) return `Search error: ${result.message}`;
+      if (result.results.length === 0) return `No results found for "${query}".`;
+
+      return `Web search: "${query}" — ${result.resultCount} results\n\n` +
+        result.results.map((r, i) =>
+          `${i + 1}. ${r.title}\n   ${r.url}\n   ${r.snippet}`
+        ).join('\n\n');
+    }
+
+    case 'fetch_url': {
+      const wt = await import('./web-tools.mjs');
+      const url = params.url;
+      if (!url) return 'A URL is required.';
+
+      const result = await wt.fetchUrl(url);
+      if (result.error) return `Fetch error: ${result.message}`;
+
+      const lines = [];
+      if (result.title) lines.push(`Title: ${result.title}`);
+      lines.push(`URL: ${result.url || url}`);
+      lines.push(`Status: ${result.status}`);
+      if (result.truncated) lines.push('[Content was truncated due to size limits]');
+      lines.push('');
+      lines.push(result.body);
+
+      return lines.join('\n');
+    }
+
     default:
       return `Unknown action: ${action}`;
   }