persyst-mcp 1.1.0 → 2.1.0

package/src/tools.js

@@ -2,6 +2,13 @@
  * tools.js — MCP Tool Definitions & Handlers
  * 
  * Defines all 19 tools that AI agents can call via MCP.
+ * 
+ * v2.0 changes:
+ * - Bug 1: Uses memoryExistsByHashPrefix for git dedup
+ * - Bug 3: Exports cleanupWatchers for graceful shutdown
+ * - Bug 7 + Feature 4: Memory content size validation
+ * - Feature 1: Cache invalidation on write operations
+ * - Feature 2: Contradiction detection on add_memory
  */
 
 import { z } from 'zod';
@@ -21,6 +28,7 @@ import {
   getMemoriesByEntity,
   getAllEntities,
   memoryExists,
+  memoryExistsByHashPrefix,
   getMemoryByContent,
   boostMemory,
   logContradiction,
@@ -28,15 +36,67 @@ import {
   getAttestationsByDateRange,
   getMemoryHistoryChain,
   searchAllMemoriesFts,
-  getAnyMemoryById
+  getAnyMemoryById,
+  searchVector,
+  getMemoryById,
+  getActiveMemoryCount
 } from './database.js';
 import { searchHybrid, getOptimizedContext, consolidateMemories } from './search.js';
 import { getRecentCommits } from './git.js';
 import { verifyChainIntegrity } from './attestation.js';
+import { searchCache } from './cache.js';
+
+// ============================================================
+// CONSTANTS
+// ============================================================
+
+/** Maximum allowed memory content length (50,000 characters) */
+const MAX_MEMORY_CONTENT_LENGTH = 50000;
+
+/** Minimum content length (must have actual content) */
+const MIN_MEMORY_CONTENT_LENGTH = 1;
+
+// ============================================================
+// WATCHER REGISTRY
+// ============================================================
 
 // In-memory registry of active git watchers
 const watchers = new Map();
 
+/**
+ * Clean up all active git watchers. Called during graceful shutdown.
+ * (Bug 3 fix: prevents memory leak from orphaned setInterval handles)
+ */
+export function cleanupWatchers() {
+  for (const [repoPath, intervalId] of watchers.entries()) {
+    clearInterval(intervalId);
+    console.error(`[persyst-watcher] Stopped watching: ${repoPath}`);
+  }
+  watchers.clear();
+}
+
+// ============================================================
+// VALIDATION HELPERS
+// ============================================================
+
+/**
+ * Validate memory content for size and emptiness.
+ * @param {string} content - The content to validate
+ * @returns {{ valid: boolean, error?: string }} Validation result
+ */
+function validateMemoryContent(content) {
+  if (!content || content.trim().length < MIN_MEMORY_CONTENT_LENGTH) {
+    return { valid: false, error: 'Memory content cannot be empty or whitespace-only.' };
+  }
+  if (content.length > MAX_MEMORY_CONTENT_LENGTH) {
+    return {
+      valid: false,
+      error: `Memory content exceeds maximum length of ${MAX_MEMORY_CONTENT_LENGTH} characters (got ${content.length}). Please split into smaller memories.`
+    };
+  }
+  return { valid: true };
+}
+
 /**
  * Register all MCP tools on the server.
  * @param {McpServer} server - The MCP server instance
@@ -66,6 +126,13 @@ export function registerTools(server) {
     },
     async ({ content, importance, agent_id, session_id }) => {
       try {
+        // Bug 7 + Feature 4: Validate content size
+        const validation = validateMemoryContent(content);
+        if (!validation.valid) {
+          return text({ error: validation.error });
+        }
+
+        // Deduplication check
         const existing = getMemoryByContent(content);
         if (existing) {
           boostMemory(existing.id);
@@ -85,7 +152,48 @@ export function registerTools(server) {
         const embedding = await generateEmbedding(content);
         insertVector(id, embedding);
 
-        return text({ success: true, id, message: `Memory #${id} stored` });
+        // Feature 1: Invalidate search cache on write
+        searchCache.invalidate();
+
+        // Feature 2: Contradiction Detection
+        let contradictions = [];
+        try {
+          const similarHits = searchVector(embedding, 3);
+          for (const hit of similarHits) {
+            const hitId = Number(hit.rowid);
+            if (hitId === id) continue; // Skip self
+
+            const sim = Math.max(0, 1 - (hit.distance * hit.distance) / 2);
+            if (sim > 0.75) {
+              const existingMemory = getMemoryById(hitId);
+              if (!existingMemory) continue;
+
+              // Check if content is substantially different (Jaccard distance > 0.5)
+              const jaccard = jaccardDistance(content, existingMemory.content);
+              if (jaccard > 0.5) {
+                // This is a contradiction: similar topic, different content
+                logContradiction(hitId, id, `Auto-detected contradiction (similarity: ${sim.toFixed(3)}, content_diff: ${jaccard.toFixed(3)})`);
+                contradictions.push({
+                  old_memory_id: hitId,
+                  old_content_preview: existingMemory.content.slice(0, 100),
+                  similarity: sim.toFixed(4),
+                  content_difference: jaccard.toFixed(4)
+                });
+              }
+            }
+          }
+        } catch (e) {
+          // Contradiction detection is best-effort, don't fail the memory insertion
+          console.error(`[persyst] Contradiction detection error: ${e.message}`);
+        }
+
+        const result = { success: true, id, message: `Memory #${id} stored` };
+        if (contradictions.length > 0) {
+          result.contradictions_detected = contradictions;
+          result.message += `. Detected ${contradictions.length} contradiction(s) — older memories archived.`;
+        }
+
+        return text(result);
       } catch (err) {
         return text({ error: err.message });
       }
@@ -145,6 +253,12 @@ export function registerTools(server) {
     },
     async ({ id, content, agent_id }) => {
       try {
+        // Bug 7 + Feature 4: Validate content size
+        const validation = validateMemoryContent(content);
+        if (!validation.valid) {
+          return text({ error: validation.error });
+        }
+
         const oldMemory = getMemory(id);
         if (!oldMemory) return text({ error: `Memory #${id} not found` });
 
@@ -161,6 +275,9 @@ export function registerTools(server) {
         // Record contradiction and archive the old one
         logContradiction(id, newId, 'Content updated via update_memory');
 
+        // Feature 1: Invalidate search cache on write
+        searchCache.invalidate();
+
         return text({
           success: true,
           id: newId,
@@ -183,6 +300,10 @@ export function registerTools(server) {
       try {
         const deleted = deleteMemory(id);
         if (!deleted) return text({ error: `Memory #${id} not found` });
+
+        // Feature 1: Invalidate search cache on write
+        searchCache.invalidate();
+
         return text({ success: true, id, message: `Memory #${id} deleted` });
       } catch (err) {
         return text({ error: err.message });
@@ -234,13 +355,14 @@ export function registerTools(server) {
     },
     async ({ repo_path, count }) => {
       try {
-        const commits = getRecentCommits(repo_path, count);
+        const commits = await getRecentCommits(repo_path, count);
         let added = 0;
         let skipped = 0;
 
         for (const commit of commits) {
           const hashPrefix = commit.hash.slice(0, 7);
-          if (memoryExists(`[${hashPrefix}]%`)) {
+          // Bug 1 fix: use LIKE-based query for hash prefix matching
+          if (memoryExistsByHashPrefix(`[${hashPrefix}]%`)) {
             skipped++;
             continue;
           }
@@ -272,6 +394,9 @@ export function registerTools(server) {
           added++;
         }
 
+        // Feature 1: Invalidate search cache after git ingestion
+        if (added > 0) searchCache.invalidate();
+
         return text({
           success: true,
           added,
@@ -465,11 +590,12 @@ export function registerTools(server) {
         const intervalId = setInterval(async () => {
           console.error(`[persyst-watcher] Running scheduled ingestion for: ${repo_path}`);
           try {
-            const result = getRecentCommits(repo_path, 10);
+            const result = await getRecentCommits(repo_path, 10);
             let added = 0;
             for (const commit of result) {
               const hashPrefix = commit.hash.slice(0, 7);
-              if (memoryExists(`[${hashPrefix}]%`)) continue;
+              // Bug 1 fix: use LIKE-based query for hash prefix matching
+              if (memoryExistsByHashPrefix(`[${hashPrefix}]%`)) continue;
 
               const id = insertMemory(commit.fullText, commit.importance, {
                 source_type: 'git',
@@ -489,6 +615,7 @@ export function registerTools(server) {
               added++;
             }
             if (added > 0) {
+              searchCache.invalidate();
               console.error(`[persyst-watcher] Ingested ${added} new commits from ${repo_path}`);
             }
           } catch (e) {
@@ -545,7 +672,7 @@ export function registerTools(server) {
 }
 
 // ============================================================
-// HELPER
+// HELPERS
 // ============================================================
 
 /** Format a response as MCP text content */
@@ -554,3 +681,24 @@ function text(data) {
     content: [{ type: 'text', text: JSON.stringify(data, null, 2) }]
   };
 }
+
+/**
+ * Compute Jaccard distance between two text strings.
+ * Used for contradiction detection — higher distance means more different content.
+ * @param {string} a - First text
+ * @param {string} b - Second text
+ * @returns {number} Distance score between 0 (identical) and 1 (completely different)
+ */
+function jaccardDistance(a, b) {
+  const wordsA = new Set(a.toLowerCase().split(/\s+/));
+  const wordsB = new Set(b.toLowerCase().split(/\s+/));
+
+  let intersection = 0;
+  for (const word of wordsA) {
+    if (wordsB.has(word)) intersection++;
+  }
+
+  const union = wordsA.size + wordsB.size - intersection;
+  if (union === 0) return 0;
+  return 1 - (intersection / union);
+}