persyst-mcp 2.2.4 → 2.2.6

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,41 @@
+/**
+ * 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);
+}

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,9 +47,11 @@ 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';
+import { memoryEventBus } from './events.js';
 
 // ============================================================
 // CONSTANTS
@@ -108,8 +112,11 @@ 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 };
     }
@@ -118,14 +125,13 @@ export async function addMemoryInternal({ content, importance = 1.0, agent_id, s
     const namespace = (shared || !normalizedAgentId) ? 'shared' : normalizedAgentId;
 
     // 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}`);
@@ -140,18 +146,21 @@ 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: redactedContent, namespace, source: normalizedAgentId || 'manual' });
+
     // Feature 2: Contradiction Detection
     let contradictions = [];
     try {
@@ -165,20 +174,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;
             }
 
@@ -187,7 +196,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({
@@ -316,11 +329,13 @@ 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` });
         return text(memory);
       } catch (err) {
@@ -342,13 +357,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
@@ -357,7 +376,7 @@ export function registerTools(server) {
 
         // Insert new version
         const newId = insertMemory(
-          content,
+          redactedContent,
           oldMemory.importance_score,
           {
             source_type: resolvedAgentId ? 'agent' : 'manual',
@@ -368,7 +387,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
@@ -377,6 +396,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,
@@ -393,16 +415,24 @@ 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` });
 
         // Feature 1: Invalidate search cache on write
         searchCache.invalidate();
 
+        // Broadcast deletion to SSE subscribers
+        memoryEventBus.emit('memory_deleted', { id, namespace: memory.namespace || 'shared' });
+
         return text({ success: true, id, message: `Memory #${id} deleted` });
       } catch (err) {
         return text({ error: err.message });
@@ -538,14 +568,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');
@@ -778,12 +810,13 @@ export function registerTools(server) {
       query: z.string().describe('The search query context'),
       max_tokens: z.number().default(4000).describe('Token budget for LLM context compression (default: 4000)'),
       agent_id: z.string().optional().describe('Agent ID requesting context — filters to this agent\'s namespace + shared'),
-      session_id: z.string().optional().describe('Session ID')
+      session_id: z.string().optional().describe('Session ID'),
+      intent: z.string().optional().describe('The active task intent / category (e.g. debugging, ui_styling, database_management)')
     },
-    async ({ query, max_tokens, agent_id, session_id }) => {
+    async ({ query, max_tokens, agent_id, session_id, intent }) => {
       try {
         const namespace = agent_id || null;
-        const contextData = await getOptimizedContext(query, max_tokens, agent_id, session_id, namespace);
+        const contextData = await getOptimizedContext(query, max_tokens, agent_id, session_id, namespace, intent);
         return text(contextData);
       } catch (err) {
         return text({ error: err.message });
@@ -822,27 +855,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-].