mevoric 2.0.0 → 2.2.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "mevoric",
-  "version": "2.0.0",
+  "version": "2.2.0",
   "description": "Unified memory + agent bridge for Claude Code. Semantic recall, cross-tab messaging, session checkpoints — one MCP server.",
   "type": "module",
   "main": "server.mjs",
@@ -29,10 +29,13 @@
   "files": [
     "server.mjs",
     "init.mjs",
+    "watcher.mjs",
     "README.md",
     "LICENSE"
   ],
   "dependencies": {
-    "@modelcontextprotocol/sdk": "^1.0.0"
+    "@anthropic-ai/claude-agent-sdk": "^0.2.54",
+    "@modelcontextprotocol/sdk": "^1.0.0",
+    "node-notifier": "^10.0.1"
   }
 }

package/server.mjs

@@ -28,6 +28,7 @@ import {
 } from 'fs';
 import { resolve, dirname } from 'path';
 import { randomBytes, randomUUID } from 'crypto';
+import { spawn } from 'child_process';
 import { homedir, tmpdir, platform } from 'os';
 
 // ============================================================
@@ -66,6 +67,10 @@ const MEMORY_SERVER_URL = process.env.MEVORIC_SERVER_URL
 // Session-level conversation ID for memory tools
 const sessionConversationId = randomUUID();
 
+// Cache retrieved memories so judge_memories can evaluate them locally
+// Map<conversationId, [{mem0_id, memory, score}]>
+const retrievalCache = new Map();
+
 // Write conversation ID to temp file so external tools can reference it
 const CONVID_FILE = resolve(tmpdir(), 'mevoric-convid');
 try { writeFileSync(CONVID_FILE, sessionConversationId); } catch {}
@@ -682,13 +687,19 @@ async function handleRetrieveMemories(args) {
       .filter(m => (m.score || 0) >= SCORE_THRESHOLD)
       .slice(0, MAX_RESULTS)
       .map((m, i) => ({
+        mem0_id: m.mem0_id,
         memory: m.memory,
         score: Math.round((m.score || 0) * 1000) / 1000,
         rank: i + 1
       }));
 
+    // Cache for judge_memories (includes mem0_id for verdict posting)
+    if (filtered.length > 0) {
+      retrievalCache.set(sessionConversationId, filtered);
+    }
+
     return {
-      memories: filtered,
+      memories: filtered.map(m => ({ memory: m.memory, score: m.score, rank: m.rank })),
       conversation_id: sessionConversationId,
       ...(filtered.length === 0 && raw.length > 0
         ? { note: `${raw.length} memories found but none above relevance threshold (${SCORE_THRESHOLD})` }
@@ -726,6 +737,134 @@ async function handleStoreConversation(args) {
   }
 }
 
+const JUDGE_PROMPT = `You are evaluating whether a retrieved memory helped answer a user's question.
+
+USER QUERY:
+{query}
+
+ASSISTANT RESPONSE:
+{response}
+
+RETRIEVED MEMORY:
+{memory}
+
+EVALUATION — walk through these steps:
+
+Step 1: Find evidence. Quote any part of the response that uses information from this memory.
+        Did you find evidence? Answer YES or NO.
+
+Step 2:
+  If YES (memory was used): Is the information in the memory correct based on the response?
+    - If correct → verdict: "strengthen"
+    - If incorrect → verdict: "correct", and provide the corrected text
+
+  If NO (memory was NOT used): Why wasn't it used?
+    - If the memory is irrelevant to the query → verdict: "drop"
+    - If the memory is related but wasn't needed → verdict: "weaken"
+
+Return JSON only:
+{
+  "evidence": "quote from response, or 'none'",
+  "reasoning": "your step-by-step reasoning",
+  "verdict": "strengthen" | "weaken" | "correct" | "drop",
+  "confidence": 0.0 to 1.0,
+  "corrected_content": "only if verdict is correct, otherwise null"
+}`;
+
+const CONFIDENCE_THRESHOLD = 0.85;
+
+function getCleanEnv() {
+  const env = { ...process.env };
+  delete env.ANTHROPIC_API_KEY;
+  delete env.CLAUDECODE;
+  return env;
+}
+
+async function judgeOneMemory(queryText, responseText, memoryContent) {
+  const prompt = JUDGE_PROMPT
+    .replace('{query}', queryText)
+    .replace('{response}', responseText)
+    .replace('{memory}', memoryContent);
+
+  let claudeQuery;
+  try {
+    const sdk = await import('@anthropic-ai/claude-agent-sdk');
+    claudeQuery = sdk.query;
+  } catch {
+    throw new Error('Claude Agent SDK not available');
+  }
+
+  let fullText = '';
+  for await (const ev of claudeQuery({
+    prompt,
+    options: {
+      maxTurns: 1,
+      allowedTools: [],
+      model: 'haiku',
+      permissionMode: 'bypassPermissions',
+      allowDangerouslySkipPermissions: true,
+      persistSession: false,
+      env: getCleanEnv(),
+    }
+  })) {
+    if (ev?.type === 'assistant' && ev.message?.content) {
+      for (const block of ev.message.content) {
+        if (block.type === 'text' && block.text) fullText += block.text;
+      }
+    }
+    if (ev?.type === 'result' && ev.text) fullText = ev.text;
+  }
+
+  let cleaned = fullText.trim();
+  if (cleaned.startsWith('```')) cleaned = cleaned.split('\n', 2)[1] ? cleaned.slice(cleaned.indexOf('\n') + 1) : cleaned.slice(3);
+  if (cleaned.endsWith('```')) cleaned = cleaned.slice(0, -3);
+  cleaned = cleaned.trim();
+
+  return JSON.parse(cleaned);
+}
+
+async function runJudgeInBackground(memories, queryText, responseText, convId, userId) {
+  let judged = 0;
+  let failed = 0;
+
+  for (const mem of memories) {
+    try {
+      const judgment = await judgeOneMemory(queryText, responseText, mem.memory);
+      const verdict = judgment.verdict || 'weaken';
+      const confidence = parseFloat(judgment.confidence) || 0;
+      const note = judgment.reasoning || '';
+      const corrected = judgment.corrected_content || null;
+
+      // Confidence guard: strengthen always passes, everything else needs >= 85%
+      const actionTaken = (verdict === 'strengthen' || confidence >= CONFIDENCE_THRESHOLD)
+        ? 'logged' : `blocked_low_confidence (${Math.round(confidence * 100)}%)`;
+
+      // POST verdict to Newcode for storage
+      try {
+        await memoryFetch('/api/verdict', {
+          mem0_id: mem.mem0_id,
+          conversation_id: convId,
+          user_id: userId,
+          verdict,
+          judge_note: note,
+          corrected_content: corrected,
+          action_taken: actionTaken,
+        }, 10000);
+      } catch {
+        // Storage failed but judgment succeeded — log locally
+        console.error(`[Mevoric] Failed to store verdict for ${mem.mem0_id}`);
+      }
+
+      judged++;
+    } catch (err) {
+      failed++;
+      console.error(`[Mevoric] Judge failed for memory: ${err.message}`);
+    }
+  }
+
+  console.error(`[Mevoric] Judge complete: ${judged} judged, ${failed} failed out of ${memories.length}`);
+}
+
 async function handleJudgeMemories(args) {
   const convId = args.conversation_id || sessionConversationId;
   const queryText = args.query_text;
@@ -735,18 +874,22 @@ async function handleJudgeMemories(args) {
   }
   const userId = args.user_id || 'lloyd';
 
-  try {
-    const data = await memoryFetch('/feedback', {
-      conversation_id: convId,
-      user_id: userId,
-      query_text: queryText,
-      response_text: responseText
-    }, 30000);
-
-    return { status: data.status || 'judging', conversation_id: convId };
-  } catch (err) {
-    return { error: err.message, conversation_id: convId };
+  // Get cached memories from this conversation's retrieve call
+  const memories = retrievalCache.get(convId);
+  if (!memories || memories.length === 0) {
+    return { status: 'skipped', reason: 'No memories retrieved in this conversation to judge', conversation_id: convId };
   }
+
+  // Run judging in background — don't block the tool response
+  runJudgeInBackground(memories, queryText, responseText, convId, userId)
+    .catch(err => console.error(`[Mevoric] Background judge error: ${err.message}`));
+
+  return {
+    status: 'judging',
+    count: memories.length,
+    conversation_id: convId,
+    note: 'Evaluating locally via Claude SDK. Verdicts will be posted to Newcode.'
+  };
 }
 
 // ============================================================
@@ -1242,6 +1385,22 @@ async function runIngest() {
     } catch {} // Best-effort
   }
 
+  // --- 5. Broadcast session-end notification (picked up by watcher) ---
+  try {
+    mkdirSync(MESSAGES_DIR, { recursive: true });
+    const summary = userMsg.slice(0, 100) || 'session ended';
+    const msgData = JSON.stringify({
+      fromName: name,
+      toName: '*',
+      broadcast: true,
+      to: '*',
+      content: `${name} finished: ${summary}`,
+      timestamp: new Date().toISOString()
+    });
+    const msgFile = resolve(MESSAGES_DIR, `${Date.now()}-${randomBytes(4).toString('hex')}.json`);
+    writeFileSync(msgFile, msgData);
+  } catch {}
+
   process.exit(0);
 }
 
@@ -1308,8 +1467,31 @@ async function runCheckMessages() {
 // CLI: --bootstrap-context (SessionStart hook mode)
 // ============================================================
 
+function ensureWatcherRunning() {
+  const pidFile = resolve(DATA_DIR, 'watcher.pid');
+  try {
+    const pid = parseInt(readFileSync(pidFile, 'utf8').trim(), 10);
+    if (pid && isProcessAlive(pid)) return; // already running
+  } catch {}
+
+  // Spawn watcher as detached background process
+  const watcherPath = resolve(dirname(new URL(import.meta.url).pathname.replace(/^\/([A-Z]:)/, '$1')), 'watcher.mjs');
+  if (!existsSync(watcherPath)) return;
+
+  const child = spawn(process.execPath, [watcherPath], {
+    detached: true,
+    stdio: 'ignore',
+    windowsHide: true,
+  });
+  child.unref();
+
+  // Save PID so we can check next time
+  try { writeFileSync(pidFile, String(child.pid), 'utf8'); } catch {}
+}
+
 async function runBootstrapContext() {
   ensureDirs();
+  ensureWatcherRunning();
 
   const chunks = [];
   for await (const chunk of process.stdin) chunks.push(chunk);

package/watcher.mjs

@@ -0,0 +1,146 @@
+#!/usr/bin/env node
+
+/**
+ * Mevoric Notification Watcher
+ *
+ * Background heartbeat that polls for new agent messages every N seconds
+ * and pops a Windows toast notification when one arrives.
+ *
+ * Zero API credits. Just reads files on a timer.
+ *
+ * Usage:
+ *   node watcher.mjs              # default 5 second poll
+ *   node watcher.mjs --interval 3 # 3 second poll
+ *   node watcher.mjs --test       # send a test notification then exit
+ */
+
+import { readdirSync, readFileSync, writeFileSync } from 'fs';
+import { resolve } from 'path';
+import { execSync } from 'child_process';
+import { platform } from 'os';
+
+// ── Config ──────────────────────────────────────────────
+
+const DATA_DIR = process.env.MEVORIC_DATA_DIR
+  || process.env.AGENT_BRIDGE_DATA_DIR
+  || (platform() === 'win32'
+    ? resolve(process.env.LOCALAPPDATA || '', 'agent-bridge')
+    : resolve(process.env.HOME || '', '.local', 'share', 'mevoric'));
+
+const MESSAGES_DIR = resolve(DATA_DIR, 'messages');
+const CURSOR_FILE = resolve(DATA_DIR, 'watcher.cursor');
+
+const args = process.argv.slice(2);
+const intervalIdx = args.indexOf('--interval');
+const POLL_MS = (intervalIdx !== -1 && args[intervalIdx + 1])
+  ? parseInt(args[intervalIdx + 1], 10) * 1000
+  : 5000;
+
+// ── Cursor (tracks what we've already notified about) ───
+
+function loadCursor() {
+  try {
+    return parseInt(readFileSync(CURSOR_FILE, 'utf8').trim(), 10) || Date.now();
+  } catch {
+    return Date.now();
+  }
+}
+
+function saveCursor(ts) {
+  try {
+    writeFileSync(CURSOR_FILE, String(ts), 'utf8');
+  } catch {}
+}
+
+// ── Popup Notification ───────────────────────────────────
+
+function notify(title, body) {
+  if (platform() !== 'win32') {
+    console.log(`[NOTIFY] ${title}: ${body}`);
+    return;
+  }
+
+  // WScript.Shell Popup — works on all Windows, bypasses DND, auto-closes after 5s
+  const safeTitle = title.replace(/'/g, "''");
+  const safeBody = body.replace(/'/g, "''");
+
+  try {
+    execSync(
+      `powershell -NoProfile -Command "(New-Object -ComObject WScript.Shell).Popup('${safeBody}', 5, 'Mevoric: ${safeTitle}', 0x40)"`,
+      { stdio: 'ignore', timeout: 8000 }
+    );
+  } catch {
+    console.log(`[NOTIFY] ${title}: ${body}`);
+  }
+}
+
+// ── Poll for new messages ───────────────────────────────
+
+function checkMessages(lastTs) {
+  let files;
+  try {
+    files = readdirSync(MESSAGES_DIR).filter(f => f.endsWith('.json')).sort();
+  } catch {
+    return { messages: [], highestTs: lastTs };
+  }
+
+  const newMessages = [];
+  let highestTs = lastTs;
+
+  for (const file of files) {
+    const ts = parseInt(file.split('-')[0], 10);
+    if (isNaN(ts) || ts <= lastTs) continue;
+
+    try {
+      const msg = JSON.parse(readFileSync(resolve(MESSAGES_DIR, file), 'utf8'));
+      newMessages.push(msg);
+      if (ts > highestTs) highestTs = ts;
+    } catch {
+      // malformed, skip
+    }
+  }
+
+  return { messages: newMessages, highestTs };
+}
+
+// ── Test mode ───────────────────────────────────────────
+
+if (args.includes('--test')) {
+  console.log('Sending test notification...');
+  notify('emergence-main-2', 'Hey Lloyd, I finished restoring the editor. PIE is ready.');
+  setTimeout(() => process.exit(0), 3000);
+} else {
+
+// ── Main loop ───────────────────────────────────────────
+
+let cursor = loadCursor();
+
+console.log(`[Mevoric Watcher] Polling every ${POLL_MS / 1000}s`);
+console.log(`[Mevoric Watcher] Messages dir: ${MESSAGES_DIR}`);
+console.log(`[Mevoric Watcher] Cursor: ${new Date(cursor).toISOString()}`);
+
+setInterval(() => {
+  const { messages, highestTs } = checkMessages(cursor);
+
+  if (messages.length > 0) {
+    for (const msg of messages) {
+      const from = msg.fromName || msg.from || 'unknown';
+      const preview = (msg.content || '').slice(0, 120);
+      const target = msg.broadcast ? 'broadcast' : `→ ${msg.toName || msg.to}`;
+
+      console.log(`[${new Date().toLocaleTimeString()}] ${from} (${target}): ${preview}`);
+      notify(`${from}`, preview);
+    }
+
+    cursor = highestTs;
+    saveCursor(cursor);
+  }
+}, POLL_MS);
+
+// Keep alive
+process.on('SIGINT', () => {
+  console.log('\n[Mevoric Watcher] Stopped.');
+  process.exit(0);
+});
+
+} // end else (not --test)