feat(tools): persistent memory + web research tools for the agent

apps/desktop/src/tools/index.js

@@ -9,8 +9,10 @@ import { files } from './files.js';
 import { net } from './net.js';
 import { apps } from './apps.js';
 import { browser } from './browser.js';
+import { web } from './web.js';
+import { memory } from './memory.js';
 
-const BUILTIN = [sysinfo, shell, files, net, apps, browser];
+const BUILTIN = [sysinfo, shell, files, net, apps, browser, web, memory];
 const TIMEOUT_MS = 30_000;
 
 class ToolRegistry {

apps/desktop/src/tools/memory.js

@@ -0,0 +1,75 @@
+// Persistent memory — the agent remembers across tasks and restarts.
+// Plain markdown files under ~/.mona-agent/memory/.
+
+import fs from 'node:fs';
+import path from 'node:path';
+import os from 'node:os';
+
+const MEM_DIR = process.env.MONA_MEMORY_DIR || path.join(os.homedir(), '.mona-agent', 'memory');
+const MAX_NOTE = 4000;
+
+function ensureDir() {
+  fs.mkdirSync(MEM_DIR, { recursive: true });
+}
+
+function todayFile() {
+  const d = new Date();
+  const ymd = `${d.getFullYear()}-${String(d.getMonth() + 1).padStart(2, '0')}-${String(d.getDate()).padStart(2, '0')}`;
+  return path.join(MEM_DIR, `${ymd}.md`);
+}
+
+function allFiles() {
+  ensureDir();
+  return fs.readdirSync(MEM_DIR).filter((f) => f.endsWith('.md')).map((f) => path.join(MEM_DIR, f));
+}
+
+export const memory = {
+  name: 'memory',
+  description: 'Persistent memory across tasks: remember facts, recall/search them, list recent notes.',
+  args: {
+    action: 'string — remember | recall | list',
+    note: 'string — text to remember (for remember)',
+    query: 'string — search terms (for recall)',
+  },
+  platform: 'any',
+
+  async run(args) {
+    const action = String(args.action || 'recall').toLowerCase();
+
+    if (action === 'remember') {
+      const note = String(args.note || '').trim().slice(0, MAX_NOTE);
+      if (!note) return { error: 'note required' };
+      ensureDir();
+      const stamp = new Date().toISOString();
+      fs.appendFileSync(todayFile(), `\n## ${stamp}\n${note}\n`);
+      return { ok: true, stored: todayFile(), chars: note.length };
+    }
+
+    if (action === 'list') {
+      ensureDir();
+      const files = allFiles().map((f) => ({
+        file: path.basename(f),
+        bytes: fs.statSync(f).size,
+      }));
+      return { files: files.reverse().slice(0, 14) };
+    }
+
+    // recall (default): substring search across memory files, newest first
+    const query = String(args.query || '').trim();
+    const files = allFiles().sort().reverse();
+    const hits = [];
+    for (const f of files.slice(0, 40)) {
+      let content;
+      try { content = fs.readFileSync(f, 'utf8'); } catch { continue; }
+      const lines = content.split('\n');
+      for (let i = 0; i < lines.length; i++) {
+        if (!query || lines[i].toLowerCase().includes(query.toLowerCase())) {
+          hits.push({ file: path.basename(f), line: i + 1, text: lines[i].slice(0, 300) });
+          if (hits.length >= 20) break;
+        }
+      }
+      if (hits.length >= 20) break;
+    }
+    return { query: query || '(all recent)', hits };
+  },
+};

apps/desktop/src/tools/web.js

@@ -0,0 +1,89 @@
+// Web research — search the web and fetch page content.
+// Pure Node, no external dependencies, multi-OS.
+
+const UA = 'Mozilla/5.0 (Macintosh; Intel Mac OS X 14_8) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/17.6 Safari/605.1.15 mona-agent/2.x';
+const FETCH_TIMEOUT_MS = 15000;
+const MAX_TEXT = 10000;
+
+async function httpGet(url, headers = {}) {
+  const res = await fetch(url, {
+    headers: { 'user-agent': UA, accept: 'text/html,application/xhtml+xml', ...headers },
+    signal: AbortSignal.timeout(FETCH_TIMEOUT_MS),
+  });
+  if (!res.ok) throw new Error(`HTTP ${res.status} for ${url}`);
+  return res.text();
+}
+
+/** Crude but effective HTML → text extraction (no external deps). */
+export function htmlToText(html) {
+  let t = String(html || '');
+  t = t.replace(/<script[\s\S]*?<\/script>/gi, ' ')
+       .replace(/<style[\s\S]*?<\/style>/gi, ' ')
+       .replace(/<noscript[\s\S]*?<\/noscript>/gi, ' ');
+  t = t.replace(/<[^>]+>/g, ' ');
+  t = t.replace(/&nbsp;/gi, ' ')
+       .replace(/&amp;/gi, '&')
+       .replace(/&lt;/gi, '<')
+       .replace(/&gt;/gi, '>')
+       .replace(/&quot;/gi, '"')
+       .replace(/&#39;/gi, "'");
+  t = t.replace(/\s+/g, ' ').trim();
+  return t.slice(0, MAX_TEXT);
+}
+
+/** DuckDuckGo HTML search → [{title, url, snippet}] (no API key needed). */
+export async function ddgSearch(query, max = 8) {
+  const q = encodeURIComponent(String(query || '').slice(0, 200));
+  const html = await httpGet(`https://html.duckduckgo.com/html/?q=${q}`);
+  const results = [];
+  const itemRe = /<a[^>]+class="result__a"[^>]+href="([^"]+)"[^>]*>([\s\S]*?)<\/a>[\s\S]*?<a[^>]+class="result__snippet"[^>]*>([\s\S]*?)<\/a>/gi;
+  let m;
+  while ((m = itemRe.exec(html)) !== null && results.length < max) {
+    const rawUrl = m[1];
+    let url = rawUrl;
+    if (rawUrl.startsWith('//')) url = 'https:' + rawUrl;
+    // DuckDuckGo redirect links: extract the real target
+    const uddg = rawUrl.match(/uddg=([^&]+)/);
+    if (uddg) {
+      try { url = decodeURIComponent(uddg[1]); } catch { /* keep raw */ }
+    }
+    if (!url.startsWith('http')) continue;
+    results.push({
+      title: htmlToText(m[2]).slice(0, 120),
+      url,
+      snippet: htmlToText(m[3]).slice(0, 300),
+    });
+  }
+  return results;
+}
+
+export const web = {
+  name: 'web',
+  description: 'Web research: search the web (DuckDuckGo) and fetch page content as text.',
+  args: {
+    action: 'string — search | fetch',
+    query: 'string — search terms (for search)',
+    url: 'string — full URL (for fetch)',
+    max: 'number — max results (search, default 8)',
+  },
+  platform: 'any',
+
+  async run(args) {
+    const action = String(args.action || 'search').toLowerCase();
+    if (action === 'search') {
+      const query = String(args.query || '').trim();
+      if (!query) return { error: 'query required' };
+      const results = await ddgSearch(query, Math.min(parseInt(args.max || 8, 10) || 8, 10));
+      if (!results.length) return { results: [], note: 'No results returned.' };
+      return { results };
+    }
+    if (action === 'fetch') {
+      const url = String(args.url || '').trim();
+      if (!/^https?:\/\//i.test(url)) return { error: 'A valid http(s) URL is required' };
+      const html = await httpGet(url);
+      const text = htmlToText(html);
+      return { url, textLength: text.length, text: text.slice(0, MAX_TEXT) };
+    }
+    return { error: `Unknown action: ${action} (use search | fetch)` };
+  },
+};