persyst-mcp 2.2.5 → 2.2.7

package/src/setup-wasm.js

@@ -9,62 +9,57 @@ const require = createRequire(import.meta.url);
 const onnxWebPath = require.resolve('onnxruntime-web');
 const wasmDir = path.dirname(onnxWebPath);
 
-// Redirect native Node session creation to WebAssembly session creation
 ONNX_NODE.InferenceSession.create = ONNX_WEB.InferenceSession.create;
 
-// Override URL.createObjectURL to return file URL of the existing local file
 const originalCreateObjectURL = URL.createObjectURL;
-URL.createObjectURL = (blob) => {
+const patchedCreateObjectURL = (blob) => {
   const type = blob.type || '';
   if (type.includes('javascript') || type.includes('mjs')) {
     const filePath = path.join(wasmDir, 'ort-wasm-simd-threaded.asyncify.mjs');
-    const fileUrl = pathToFileURL(filePath).href;
-    return fileUrl;
+    return pathToFileURL(filePath).href;
   }
   return originalCreateObjectURL(blob);
 };
+URL.createObjectURL = patchedCreateObjectURL;
+
+function readLocalFile(filePath, urlStr) {
+  const normalized = path.normalize(filePath);
+  const buffer = fs.readFileSync(normalized);
+  let contentType = 'application/octet-stream';
+  if (normalized.endsWith('.wasm')) contentType = 'application/wasm';
+  else if (normalized.endsWith('.mjs') || normalized.endsWith('.js')) contentType = 'text/javascript';
+  else if (normalized.endsWith('.onnx') || normalized.endsWith('.ort')) contentType = 'application/octet-stream';
+  return new Response(buffer, {
+    status: 200,
+    statusText: 'OK',
+    headers: { 'Content-Type': contentType }
+  });
+}
 
-// Override global fetch to load ONNX WASM binaries and model files from local disk
 const originalFetch = globalThis.fetch;
-globalThis.fetch = async (url, options) => {
+const patchedFetch = async (url, options) => {
   const urlStr = typeof url === 'string' ? url : url.url;
-  
-  let isLocal = false;
-  let filePath = '';
-  
-  if (urlStr.startsWith('file://')) {
-    isLocal = true;
-    filePath = fileURLToPath(urlStr);
-  } else if (!urlStr.startsWith('http://') && !urlStr.startsWith('https://') && !urlStr.startsWith('data:')) {
-    isLocal = true;
-    filePath = urlStr;
-  }
-  
-  // Intercept onnxruntime-web CDN URLs and route them to node_modules/onnxruntime-web/dist
+
+  // onnxruntime-web WASM binaries — resolve from node_modules
   if (urlStr.includes('onnxruntime-web') || urlStr.includes('ort-wasm')) {
-    isLocal = true;
     const filename = urlStr.split('/').pop().split('?')[0].split('#')[0];
-    filePath = path.join(wasmDir, filename);
+    return readLocalFile(path.join(wasmDir, filename), urlStr);
   }
-  
-  if (isLocal) {
-    filePath = path.normalize(filePath);
+
+  // file:// URLs — Node.js fetch does not support them natively
+  if (urlStr.startsWith('file://')) {
+    return readLocalFile(fileURLToPath(urlStr), urlStr);
+  }
+
+  // fallback for any non-http/https/data URL (onnxruntime internal schemes, bare paths)
+  if (!urlStr.startsWith('http://') && !urlStr.startsWith('https://') && !urlStr.startsWith('data:')) {
     try {
-      const buffer = fs.readFileSync(filePath);
-      let contentType = 'application/octet-stream';
-      if (filePath.endsWith('.wasm')) contentType = 'application/wasm';
-      else if (filePath.endsWith('.mjs') || filePath.endsWith('.js')) contentType = 'text/javascript';
-      
-      return new Response(buffer, {
-        status: 200,
-        statusText: 'OK',
-        headers: { 'Content-Type': contentType }
-      });
-    } catch (err) {
-      console.error('[persyst] Failed to read local file:', filePath, err.message);
-      throw err;
+      return readLocalFile(urlStr, urlStr);
+    } catch (e) {
+      throw e;
     }
   }
-  
+
   return originalFetch(url, options);
 };
+globalThis.fetch = patchedFetch;

package/src/text-utils.js

@@ -0,0 +1,52 @@
+/**
+ * text-utils.js — Shared text-processing helpers used across Persyst.
+ *
+ * Keeping these in one place avoids duplicated logic and divergent behavior
+ * between modules.
+ */
+
+/**
+ * Compute Jaccard similarity between two text strings.
+ * Uses word-level tokenization for efficiency.
+ *
+ * @param {string} a - First text
+ * @param {string} b - Second text
+ * @returns {number} Similarity score between 0 and 1
+ */
+export function jaccardSimilarity(a, b) {
+  if (!a || !b) return 0;
+
+  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;
+  return union === 0 ? 0 : intersection / union;
+}
+
+/**
+ * Compute Jaccard distance between two text strings.
+ * Distance = 1 - similarity, so 0 means identical and 1 means completely different.
+ *
+ * @param {string} a - First text
+ * @param {string} b - Second text
+ * @returns {number} Distance score between 0 and 1
+ */
+export function jaccardDistance(a, b) {
+  return 1 - jaccardSimilarity(a, b);
+}
+
+/**
+ * Log informational messages to stderr only when PERSYST_DEBUG or DEBUG is enabled.
+ * Prevents MCP hosts (Cursor, Antigravity, VS Code) from treating startup info logs as MCP errors.
+ */
+export function logInfo(...args) {
+  if (process.env.PERSYST_DEBUG || process.env.DEBUG) {
+    console.error(...args);
+  }
+}
+

package/src/tools.js

@@ -14,8 +14,10 @@
 import { z } from 'zod';
 import { generateEmbedding } from './embeddings.js';
 import db, {
+  stmts,
   insertMemory,
   insertVector,
+  redactSecrets,
   getMemory,
   updateMemoryContent,
   deleteMemory,
@@ -45,6 +47,7 @@ import db, {
   getNamespaceStats
 } from './database.js';
 import { searchHybrid, getOptimizedContext, consolidateMemories } from './search.js';
+import { jaccardDistance } from './text-utils.js';
 import { getRecentCommits } from './git.js';
 import { verifyChainIntegrity } from './attestation.js';
 import { searchCache } from './cache.js';
@@ -109,24 +112,28 @@ export async function addMemoryInternal({ content, importance = 1.0, agent_id, s
   try {
     const normalizedAgentId = agent_id ? agent_id.toLowerCase() : null;
 
+    // Redact secrets/credentials on write
+    const redactedContent = redactSecrets(content);
+
     // Bug 7 + Feature 4: Validate content size
-    const validation = validateMemoryContent(content);
+    const validation = validateMemoryContent(redactedContent);
     if (!validation.valid) {
       return { error: validation.error };
     }
 
-    // Derive namespace from agent_id and shared flag
-    const namespace = (shared || !normalizedAgentId) ? 'shared' : normalizedAgentId;
+    // Derive namespace from agent_id, project env, and shared flag
+    const project = process.env.PERSYST_PROJECT;
+    const defaultNs = project || 'shared';
+    const namespace = (shared && !project) ? 'shared' : (normalizedAgentId || defaultNs);
 
     // Deduplication check (namespace-aware)
-    const existing = getMemoryByContent(content, namespace);
+    const existing = getMemoryByContent(redactedContent, namespace);
     if (existing) {
       // Re-attribute provenance to the calling agent if it was previously auto-attributed to log-watcher
       const prov = getProvenance(existing.id);
       if (prov && (prov.source_id === 'antigravity-worker' || prov.source_id === 'user-dialogue') && normalizedAgentId) {
         try {
-          db.prepare("UPDATE provenance SET source_type = 'agent', source_id = ?, confidence = 1.0 WHERE memory_id = ?")
-            .run(normalizedAgentId, existing.id);
+          stmts.updateProvenanceOwner.run(normalizedAgentId, existing.id);
           incrementAgentStat(normalizedAgentId, 'created');
         } catch (e) {
           console.error(`[persyst] Re-attribute provenance error: ${e.message}`);
@@ -141,20 +148,20 @@ export async function addMemoryInternal({ content, importance = 1.0, agent_id, s
       };
     }
 
-    const id = insertMemory(content, importance, {
+    const id = insertMemory(redactedContent, importance, {
       source_type: normalizedAgentId ? 'agent' : 'manual',
       source_id: normalizedAgentId,
       confidence: 1.0
     }, namespace);
 
-    const embedding = await generateEmbedding(content);
+    const embedding = await generateEmbedding(redactedContent);
     insertVector(id, embedding);
 
     // Feature 1: Invalidate search cache on write
     searchCache.invalidate();
 
     // Broadcast to SSE subscribers (HTTP gateway + SSE clients)
-    memoryEventBus.emit('memory_added', { id, content, namespace, source: normalizedAgentId || 'manual' });
+    memoryEventBus.emit('memory_added', { id, content: redactedContent, namespace, source: normalizedAgentId || 'manual' });
 
     // Feature 2: Contradiction Detection
     let contradictions = [];
@@ -169,20 +176,20 @@ export async function addMemoryInternal({ content, importance = 1.0, agent_id, s
           const existingMemory = getMemoryById(hitId, namespace);
           if (!existingMemory) continue;
 
-          const jaccard = jaccardDistance(content, existingMemory.content);
+          const jaccard = jaccardDistance(redactedContent, existingMemory.content);
           // Contradiction: similar topic (high similarity), but differing key terms
           if (jaccard > 0 && jaccard < 0.65) {
             // Fetch provenances for trust calculation
             const oldProv = getProvenance(hitId);
             let oldReputation = 1.0;
             if (oldProv && oldProv.source_type === 'agent' && oldProv.source_id) {
-              const agentRow = db.prepare('SELECT reputation_score FROM agent_stats WHERE agent_id = ?').get(oldProv.source_id);
+              const agentRow = stmts.getReputationScore.get(oldProv.source_id);
               if (agentRow) oldReputation = agentRow.reputation_score;
             }
 
             let newReputation = 1.0;
             if (normalizedAgentId) {
-              const agentRow = db.prepare('SELECT reputation_score FROM agent_stats WHERE agent_id = ?').get(normalizedAgentId);
+              const agentRow = stmts.getReputationScore.get(normalizedAgentId);
               if (agentRow) newReputation = agentRow.reputation_score;
             }
 
@@ -191,7 +198,11 @@ export async function addMemoryInternal({ content, importance = 1.0, agent_id, s
 
             const isSelfUpdate = oldProv && oldProv.source_type === 'agent' && oldProv.source_id === normalizedAgentId;
 
-            if (isSelfUpdate || trustNew > trustOld) {
+            if (isSelfUpdate) {
+              continue; // Same agent: treat as complementary, not contradictory
+            }
+
+            if (trustNew > trustOld) {
               // New is preferred
               logContradiction(hitId, id, `Auto-detected contradiction: new memory is more trustworthy (similarity: ${sim.toFixed(3)}, content_diff: ${jaccard.toFixed(3)})`);
               contradictions.push({
@@ -300,9 +311,22 @@ export function registerTools(server) {
     },
     async ({ query, limit, agent_id, session_id }) => {
       try {
-        // Derive namespace from agent_id (null = search all)
-        const namespace = agent_id || null;
+        // Derive namespace from agent_id or PERSYST_PROJECT env
+        const namespace = agent_id || process.env.PERSYST_PROJECT || null;
         const results = await searchHybrid(query, limit, agent_id, session_id, namespace);
+
+        // Broadcast retrieval event to SSE subscribers and monitor
+        if (results && results.length > 0) {
+          memoryEventBus.emit('memory_retrieved', {
+            tool: 'search_memories',
+            query,
+            count: results.length,
+            agent_id: agent_id || 'unknown',
+            namespace: namespace || 'shared',
+            memory_ids: results.map(r => r.id)
+          });
+        }
+
         return text({
           results,
           count: results.length,
@@ -320,12 +344,25 @@ export function registerTools(server) {
     'get_memory',
     'Get a specific memory by its ID. Boosts its importance automatically.',
     {
-      id: z.number().describe('Memory ID to retrieve')
+      id: z.number().describe('Memory ID to retrieve'),
+      agent_id: z.string().optional().describe('Agent ID — restricts access to this agent\'s namespace + shared')
     },
-    async ({ id }) => {
+    async ({ id, agent_id }) => {
       try {
-        const memory = getMemory(id);
+        const namespace = agent_id ? agent_id.toLowerCase() : null;
+        const memory = getMemory(id, namespace);
         if (!memory) return text({ error: `Memory #${id} not found` });
+
+        // Broadcast retrieval event
+        memoryEventBus.emit('memory_retrieved', {
+          tool: 'get_memory',
+          query: `#${id}`,
+          count: 1,
+          agent_id: agent_id || 'unknown',
+          namespace: memory.namespace || 'shared',
+          memory_ids: [id]
+        });
+
         return text(memory);
       } catch (err) {
         return text({ error: err.message });
@@ -346,13 +383,17 @@ export function registerTools(server) {
       try {
         const normalizedAgentId = agent_id ? agent_id.toLowerCase() : null;
 
+        // Redact secrets/credentials on update
+        const redactedContent = redactSecrets(content);
+
         // Bug 7 + Feature 4: Validate content size
-        const validation = validateMemoryContent(content);
+        const validation = validateMemoryContent(redactedContent);
         if (!validation.valid) {
           return text({ error: validation.error });
         }
 
-        const oldMemory = getMemory(id);
+        const namespace = normalizedAgentId;
+        const oldMemory = getMemory(id, namespace);
         if (!oldMemory) return text({ error: `Memory #${id} not found` });
 
         // Retrieve old agent_id from provenance
@@ -361,7 +402,7 @@ export function registerTools(server) {
 
         // Insert new version
         const newId = insertMemory(
-          content,
+          redactedContent,
           oldMemory.importance_score,
           {
             source_type: resolvedAgentId ? 'agent' : 'manual',
@@ -372,7 +413,7 @@ export function registerTools(server) {
           id
         );
 
-        const embedding = await generateEmbedding(content);
+        const embedding = await generateEmbedding(redactedContent);
         insertVector(newId, embedding);
 
         // Record contradiction and archive the old one
@@ -381,6 +422,9 @@ export function registerTools(server) {
         // Feature 1: Invalidate search cache on write
         searchCache.invalidate();
 
+        // Broadcast update to SSE subscribers
+        memoryEventBus.emit('memory_updated', { old_id: id, new_id: newId, namespace: oldMemory.namespace || 'shared' });
+
         return text({
           success: true,
           id: newId,
@@ -397,10 +441,15 @@ export function registerTools(server) {
     'delete_memory',
     'Permanently delete a memory by its ID.',
     {
-      id: z.number().describe('Memory ID to delete')
+      id: z.number().describe('Memory ID to delete'),
+      agent_id: z.string().optional().describe('Agent ID — restricts deletion to this agent\'s namespace + shared')
     },
-    async ({ id }) => {
+    async ({ id, agent_id }) => {
       try {
+        const namespace = agent_id ? agent_id.toLowerCase() : null;
+        const memory = getMemory(id, namespace);
+        if (!memory) return text({ error: `Memory #${id} not found` });
+
         const deleted = deleteMemory(id);
         if (!deleted) return text({ error: `Memory #${id} not found` });
 
@@ -408,7 +457,7 @@ export function registerTools(server) {
         searchCache.invalidate();
 
         // Broadcast deletion to SSE subscribers
-        memoryEventBus.emit('memory_deleted', { id });
+        memoryEventBus.emit('memory_deleted', { id, namespace: memory.namespace || 'shared' });
 
         return text({ success: true, id, message: `Memory #${id} deleted` });
       } catch (err) {
@@ -427,7 +476,7 @@ export function registerTools(server) {
     },
     async ({ limit, agent_id }) => {
       try {
-        const namespace = agent_id || null;
+        const namespace = agent_id || process.env.PERSYST_PROJECT || null;
         const memories = getRecentMemories(limit, namespace);
         return text({ memories, count: memories.length, namespace: namespace || 'all' });
       } catch (err) {
@@ -446,7 +495,7 @@ export function registerTools(server) {
     },
     async ({ limit, agent_id }) => {
       try {
-        const namespace = agent_id || null;
+        const namespace = agent_id || process.env.PERSYST_PROJECT || null;
         const memories = getImportantMemories(limit, namespace);
         return text({ memories, count: memories.length, namespace: namespace || 'all' });
       } catch (err) {
@@ -482,7 +531,7 @@ export function registerTools(server) {
             source_type: 'git',
             source_id: commit.hash,
             confidence: 0.8
-          });
+          }, process.env.PERSYST_PROJECT || 'shared');
 
           const embedding = await generateEmbedding(commit.fullText);
           insertVector(id, embedding);
@@ -545,14 +594,16 @@ export function registerTools(server) {
     {
       entity_name: z.string().describe('Name of the entity'),
       memory_id: z.number().describe('ID of the memory to link'),
-      relation: z.string().default('mentions').describe('Relationship type')
+      relation: z.string().default('mentions').describe('Relationship type'),
+      agent_id: z.string().optional().describe('Agent ID — restricts linking to this agent\'s namespace + shared')
     },
-    async ({ entity_name, memory_id, relation }) => {
+    async ({ entity_name, memory_id, relation, agent_id }) => {
       try {
+        const namespace = agent_id ? agent_id.toLowerCase() : null;
         const entity = getEntityByName(entity_name);
         if (!entity) return text({ error: `Entity "${entity_name}" not found.` });
 
-        const memory = getMemory(memory_id);
+        const memory = getMemory(memory_id, namespace);
         if (!memory) return text({ error: `Memory #${memory_id} not found` });
 
         insertEdge(entity.id, memory_id, relation, 'entity', 'memory');
@@ -790,8 +841,23 @@ export function registerTools(server) {
     },
     async ({ query, max_tokens, agent_id, session_id, intent }) => {
       try {
-        const namespace = agent_id || null;
+        const namespace = agent_id || process.env.PERSYST_PROJECT || null;
         const contextData = await getOptimizedContext(query, max_tokens, agent_id, session_id, namespace, intent);
+
+        // Broadcast context retrieval event
+        const retrievedCount = contextData?.memories?.length ?? 0;
+        if (retrievedCount > 0) {
+          memoryEventBus.emit('memory_retrieved', {
+            tool: 'get_optimized_context',
+            query,
+            count: retrievedCount,
+            agent_id: agent_id || 'unknown',
+            namespace: namespace || 'shared',
+            token_budget: max_tokens,
+            memory_ids: contextData.memories.map(m => m.id)
+          });
+        }
+
         return text(contextData);
       } catch (err) {
         return text({ error: err.message });
@@ -830,27 +896,6 @@ function text(data) {
   };
 }
 
-/**
- * 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);
-}
-
 /**
  * Compute word-level diff between two text strings using dynamic programming.
  * Highlights additions as [+added+] and deletions as [-deleted-].