specmem-hardwicksoftware 3.7.16 → 3.7.19

package/dist/database.js

@@ -724,8 +724,16 @@ export class DatabaseManager {
         let success = true;
         let errorMsg;
         let rowsAffected;
+        // CRITICAL FIX: Use dedicated client with ensureSearchPath to prevent
+        // schema cross-contamination. pool.query() can race with the fire-and-forget
+        // search_path set in pool.on('connect'), causing writes to wrong schema.
+        const client = await this.pool.connect();
         try {
-            const result = await this.pool.query(text, params);
+            if (this.currentSchema) {
+                const safeSchema = '"' + this.currentSchema.replace(/"/g, '""') + '"';
+                await client.query('SET search_path TO ' + safeSchema + ', public');
+            }
+            const result = await client.query(text, params);
             rowsAffected = result.rowCount ?? undefined;
             const duration = Date.now() - start;
             // Emit db:query:complete event via LWJEB
@@ -747,6 +755,9 @@ export class DatabaseManager {
             coordinator?.emitDBQueryComplete(queryId, queryType, duration, false, undefined, errorMsg);
             throw error;
         }
+        finally {
+            client.release();
+        }
     }
     /**
      * Execute query with GUARANTEED schema isolation.

package/dist/mcp/toolRegistry.js

@@ -54,8 +54,9 @@ import { SmartSearch } from '../tools/goofy/smartSearch.js';
 // Import memory drilldown tools - gallery view + full drill-down
 import { FindMemoryGallery } from '../tools/goofy/findMemoryGallery.js';
 import { GetMemoryFull } from '../tools/goofy/getMemoryFull.js';
-// Import project memory import tool - carry context across projects
+// Import project memory import/export tools - carry context across projects
 import { ImportProjectMemories } from '../tools/goofy/importProjectMemories.js';
+import { ExportProjectMemories } from '../tools/goofy/exportProjectMemories.js';
 // Import MCP-based team communication tools (NEW - replaces HTTP team member comms)
 import { createTeamCommTools } from './tools/teamComms.js';
 // Import embedding server control tools (Phase 4 - user start/stop/status)
@@ -502,8 +503,9 @@ export function createToolRegistry(db, embeddingProvider) {
     // Camera roll drilldown tools - zoom in/out on memories and code
     registry.register(new DrillDown(db));
     registry.register(new GetMemoryByDrilldownID(db));
-    // Project memory import tool - import memories from other projects
+    // Project memory import/export tools - carry context across projects
     registry.register(new ImportProjectMemories(db, cachingProvider));
+    registry.register(new ExportProjectMemories(db));
     // Team communication tools - multi-team member coordination
     const teamCommTools = createTeamCommTools();
     for (const tool of teamCommTools) {

package/dist/tools/goofy/exportProjectMemories.js

@@ -0,0 +1,243 @@
+/**
+ * exportProjectMemories - export memories from current project to JSON
+ *
+ * dumps memories from the current project schema so you can
+ * back them up, share them, or import them elsewhere
+ */
+import { logger } from '../../utils/logger.js';
+import { getProjectPathForInsert } from '../../services/ProjectContext.js';
+
+export class ExportProjectMemories {
+    db;
+    name = 'export_project_memories';
+    description = 'Export memories from the current project to JSON. Use for backups, sharing, or transferring memories between machines. Returns JSON array of memories.';
+    inputSchema = {
+        type: 'object',
+        properties: {
+            query: {
+                type: 'string',
+                description: 'Optional semantic search query to filter which memories to export. If omitted, exports all (up to limit).'
+            },
+            tags: {
+                type: 'array',
+                items: { type: 'string' },
+                description: 'Optional tag filter - only export memories with these tags'
+            },
+            memoryTypes: {
+                type: 'array',
+                items: {
+                    type: 'string',
+                    enum: ['episodic', 'semantic', 'procedural', 'working', 'consolidated']
+                },
+                description: 'Optional memory type filter'
+            },
+            importance: {
+                type: 'array',
+                items: {
+                    type: 'string',
+                    enum: ['critical', 'high', 'medium', 'low', 'trivial']
+                },
+                description: 'Optional importance filter'
+            },
+            limit: {
+                type: 'number',
+                default: 500,
+                minimum: 1,
+                maximum: 50000,
+                description: 'Max number of memories to export (default: 500)'
+            },
+            outputPath: {
+                type: 'string',
+                description: 'Optional file path to write JSON output. If omitted, returns in response.'
+            },
+            includeEmbeddings: {
+                type: 'boolean',
+                default: false,
+                description: 'Include embedding vectors in export (large, usually not needed)'
+            }
+        },
+        required: []
+    };
+
+    constructor(db) {
+        this.db = db;
+    }
+
+    async execute(params) {
+        const { query, tags, memoryTypes, importance, outputPath, includeEmbeddings = false } = params;
+        const limit = Math.min(params.limit || 500, 50000);
+        const startTime = Date.now();
+
+        try {
+            const currentSchema = this.db.getProjectSchemaName();
+            const currentProjectPath = getProjectPathForInsert();
+
+            logger.info({
+                currentSchema,
+                currentProjectPath,
+                limit,
+                query: query?.slice(0, 50),
+                tags,
+                outputPath
+            }, 'Starting memory export');
+
+            // Build query
+            const conditions = [];
+            const queryParams = [];
+            let paramIndex = 1;
+
+            if (tags && tags.length > 0) {
+                conditions.push(`tags && $${paramIndex}::text[]`);
+                queryParams.push(tags);
+                paramIndex++;
+            }
+
+            if (memoryTypes && memoryTypes.length > 0) {
+                conditions.push(`memory_type = ANY($${paramIndex}::text[])`);
+                queryParams.push(memoryTypes);
+                paramIndex++;
+            }
+
+            if (importance && importance.length > 0) {
+                conditions.push(`importance = ANY($${paramIndex}::text[])`);
+                queryParams.push(importance);
+                paramIndex++;
+            }
+
+            const embedSelect = includeEmbeddings ? ', embedding' : '';
+            let selectQuery;
+
+            if (query) {
+                // Semantic search - need embedding
+                let embedding;
+                try {
+                    const embProvider = this.db._embeddingProvider || null;
+                    if (embProvider) {
+                        embedding = await embProvider.generateEmbedding(query);
+                    }
+                } catch (e) {
+                    logger.warn({ error: e?.message }, 'Could not generate embedding for query filter');
+                }
+
+                if (embedding) {
+                    conditions.push(`embedding IS NOT NULL`);
+                    const whereClause = conditions.length > 0 ? 'WHERE ' + conditions.join(' AND ') : '';
+                    selectQuery = `
+                        SELECT id, content, memory_type, importance, tags, metadata,
+                               project_path, created_at, updated_at, expires_at,
+                               1 - (embedding <=> $${paramIndex}::vector) as similarity
+                               ${embedSelect}
+                        FROM memories
+                        ${whereClause}
+                        ORDER BY embedding <=> $${paramIndex}::vector
+                        LIMIT $${paramIndex + 1}
+                    `;
+                    queryParams.push(`[${embedding.join(',')}]`);
+                    queryParams.push(limit);
+                } else {
+                    // Fallback to text search
+                    conditions.push(`content ILIKE $${paramIndex}`);
+                    queryParams.push(`%${query}%`);
+                    paramIndex++;
+                    const whereClause = conditions.length > 0 ? 'WHERE ' + conditions.join(' AND ') : '';
+                    selectQuery = `
+                        SELECT id, content, memory_type, importance, tags, metadata,
+                               project_path, created_at, updated_at, expires_at
+                               ${embedSelect}
+                        FROM memories
+                        ${whereClause}
+                        ORDER BY created_at DESC
+                        LIMIT $${paramIndex}
+                    `;
+                    queryParams.push(limit);
+                }
+            } else {
+                const whereClause = conditions.length > 0 ? 'WHERE ' + conditions.join(' AND ') : '';
+                selectQuery = `
+                    SELECT id, content, memory_type, importance, tags, metadata,
+                           project_path, created_at, updated_at, expires_at
+                           ${embedSelect}
+                    FROM memories
+                    ${whereClause}
+                    ORDER BY created_at DESC
+                    LIMIT $${paramIndex}
+                `;
+                queryParams.push(limit);
+            }
+
+            const result = await this.db.query(selectQuery, queryParams);
+            const memories = result.rows.map(row => ({
+                id: row.id,
+                content: row.content,
+                memory_type: row.memory_type,
+                importance: row.importance,
+                tags: row.tags,
+                metadata: row.metadata,
+                project_path: row.project_path,
+                created_at: row.created_at,
+                updated_at: row.updated_at,
+                expires_at: row.expires_at,
+                ...(row.similarity !== undefined ? { similarity: Math.round(row.similarity * 1000) / 1000 } : {}),
+                ...(includeEmbeddings && row.embedding ? { embedding: row.embedding } : {})
+            }));
+
+            const duration = Date.now() - startTime;
+
+            // Write to file if outputPath specified
+            if (outputPath) {
+                const fs = await import('fs');
+                const exportData = {
+                    exportedAt: new Date().toISOString(),
+                    sourceProject: currentProjectPath,
+                    sourceSchema: currentSchema,
+                    totalExported: memories.length,
+                    filters: { query, tags, memoryTypes, importance, limit },
+                    memories
+                };
+                fs.writeFileSync(outputPath, JSON.stringify(exportData, null, 2));
+
+                return {
+                    content: [{
+                        type: 'text',
+                        text: JSON.stringify({
+                            success: true,
+                            exported: memories.length,
+                            outputPath,
+                            sourceSchema: currentSchema,
+                            duration: `${duration}ms`,
+                            fileSizeKB: Math.round(fs.statSync(outputPath).size / 1024)
+                        }, null, 2)
+                    }]
+                };
+            }
+
+            // Return inline
+            return {
+                content: [{
+                    type: 'text',
+                    text: JSON.stringify({
+                        success: true,
+                        exported: memories.length,
+                        sourceProject: currentProjectPath,
+                        sourceSchema: currentSchema,
+                        duration: `${duration}ms`,
+                        memories
+                    }, null, 2)
+                }]
+            };
+
+        } catch (err) {
+            const errMsg = err instanceof Error ? err.message : String(err);
+            logger.error({ error: errMsg }, 'Memory export failed');
+            return {
+                content: [{
+                    type: 'text',
+                    text: JSON.stringify({
+                        error: 'Memory export failed',
+                        details: errMsg
+                    }, null, 2)
+                }]
+            };
+        }
+    }
+}

package/dist/tools/goofy/importProjectMemories.js

@@ -104,12 +104,12 @@ export class ImportProjectMemories {
                 return {
                     content: [{
                         type: 'text',
-                        text: formatHumanReadable({
+                        text: JSON.stringify({
                             error: `Source schema '${sourceSchema}' not found`,
                             sourceProject,
                             availableSchemas: schemaList || 'none',
                             hint: 'Make sure the source project path is correct and has been used with SpecMem before'
-                        })
+                        }, null, 2)
                     }]
                 };
             }
@@ -176,12 +176,12 @@ export class ImportProjectMemories {
                 return {
                     content: [{
                         type: 'text',
-                        text: formatHumanReadable({
+                        text: JSON.stringify({
                             result: 'No memories found matching criteria in source project',
                             sourceProject,
                             sourceSchema,
                             filters: { tags, memoryTypes, importance, query: query?.slice(0, 50) }
-                        })
+                        }, null, 2)
                     }]
                 };
             }
@@ -200,7 +200,7 @@ export class ImportProjectMemories {
                 return {
                     content: [{
                         type: 'text',
-                        text: formatHumanReadable({
+                        text: JSON.stringify({
                             dryRun: true,
                             wouldImport: sourceMemories.rows.length,
                             sourceProject,
@@ -210,7 +210,7 @@ export class ImportProjectMemories {
                             previewNote: sourceMemories.rows.length > 10
                                 ? `Showing 10 of ${sourceMemories.rows.length} memories`
                                 : undefined
-                        })
+                        }, null, 2)
                     }]
                 };
             }
@@ -315,7 +315,7 @@ export class ImportProjectMemories {
             return {
                 content: [{
                     type: 'text',
-                    text: formatHumanReadable(result)
+                    text: JSON.stringify(result, null, 2)
                 }]
             };
 
@@ -325,11 +325,11 @@ export class ImportProjectMemories {
             return {
                 content: [{
                     type: 'text',
-                    text: formatHumanReadable({
+                    text: JSON.stringify({
                         error: 'Memory import failed',
                         details: errMsg,
                         sourceProject
-                    })
+                    }, null, 2)
                 }]
             };
         }

package/mcp-proxy.cjs

@@ -53,50 +53,84 @@ function parseMessages(buffer) {
   let remaining = buffer;
 
   while (remaining.length > 0) {
-    // Look for Content-Length header
-    const headerEnd = remaining.indexOf('\r\n\r\n');
-    if (headerEnd === -1) break;
-
-    const header = remaining.substring(0, headerEnd);
-    const match = header.match(/Content-Length:\s*(\d+)/i);
-    if (!match) {
-      // Skip malformed data
-      remaining = remaining.substring(headerEnd + 4);
-      continue;
-    }
+    remaining = remaining.trimStart();
+    if (remaining.length === 0) break;
+
+    // Mode 1: Content-Length framed (MCP spec)
+    if (remaining.startsWith('Content-Length:')) {
+      const headerEnd = remaining.indexOf('\r\n\r\n');
+      if (headerEnd === -1) break;
+
+      const header = remaining.substring(0, headerEnd);
+      const match = header.match(/Content-Length:\s*(\d+)/i);
+      if (!match) {
+        remaining = remaining.substring(headerEnd + 4);
+        continue;
+      }
+
+      const contentLength = parseInt(match[1], 10);
+      const bodyStart = headerEnd + 4;
+      const bodyEnd = bodyStart + contentLength;
+
+      if (remaining.length < bodyEnd) break;
 
-    const contentLength = parseInt(match[1], 10);
-    const bodyStart = headerEnd + 4;
-    const bodyEnd = bodyStart + contentLength;
+      const body = remaining.substring(bodyStart, bodyEnd);
+      remaining = remaining.substring(bodyEnd);
 
-    if (remaining.length < bodyEnd) {
-      break; // Incomplete message, wait for more data
+      try {
+        messages.push(JSON.parse(body));
+      } catch (e) {
+        log(`Parse error (framed): ${e.message}`);
+      }
+      continue;
     }
 
-    const body = remaining.substring(bodyStart, bodyEnd);
-    remaining = remaining.substring(bodyEnd);
+    // Mode 2: Raw JSON (newline-delimited) — Claude Code sends this
+    if (remaining[0] === '{') {
+      // Find the end of this JSON object by tracking braces
+      let depth = 0;
+      let inString = false;
+      let escape = false;
+      let end = -1;
+      for (let i = 0; i < remaining.length; i++) {
+        const ch = remaining[i];
+        if (escape) { escape = false; continue; }
+        if (ch === '\\' && inString) { escape = true; continue; }
+        if (ch === '"') { inString = !inString; continue; }
+        if (inString) continue;
+        if (ch === '{') depth++;
+        if (ch === '}') { depth--; if (depth === 0) { end = i + 1; break; } }
+      }
+      if (end === -1) break; // Incomplete JSON
 
-    try {
-      messages.push(JSON.parse(body));
-    } catch (e) {
-      log(`Parse error: ${e.message} body=${body.substring(0, 100)}`);
+      const jsonStr = remaining.substring(0, end);
+      remaining = remaining.substring(end);
+
+      try {
+        messages.push(JSON.parse(jsonStr));
+      } catch (e) {
+        log(`Parse error (raw): ${e.message}`);
+      }
+      continue;
     }
+
+    // Skip unknown byte
+    remaining = remaining.substring(1);
   }
 
   return { messages, remaining };
 }
 
-function frameMessage(obj) {
-  const body = JSON.stringify(obj);
-  return `Content-Length: ${Buffer.byteLength(body)}\r\n\r\n${body}`;
+function serializeMessage(obj) {
+  return JSON.stringify(obj) + '\n';
 }
 
 // ============================================================================
-// Send message to Claude (stdout)
+// Send message to Claude (stdout) — newline-delimited JSON per MCP SDK
 // ============================================================================
 function sendToClient(msg) {
   try {
-    process.stdout.write(frameMessage(msg));
+    process.stdout.write(serializeMessage(msg));
   } catch (e) {
     log(`stdout write error: ${e.message}`);
   }
@@ -106,8 +140,20 @@ function sendToClient(msg) {
 // Send message to MCP server (child stdin)
 // ============================================================================
 function sendToServer(msg) {
-  if (!child || !childReady || child.killed) {
-    // Queue it
+  // CRITICAL: Always forward initialize and notifications/initialized immediately
+  // even before childReady — these are what MAKE the child ready.
+  // Without this, deadlock: proxy waits for init response, bootstrap waits for init request.
+  const isInitFlow = msg.method === 'initialize' || msg.method === 'notifications/initialized';
+
+  if (!child || child.killed) {
+    if (pendingQueue.length < MAX_QUEUE_SIZE) {
+      pendingQueue.push(msg);
+      log(`Queued message (no child) (${pendingQueue.length} pending): ${msg.method || msg.id || '?'}`);
+    }
+    return;
+  }
+
+  if (!childReady && !isInitFlow) {
     if (pendingQueue.length < MAX_QUEUE_SIZE) {
       pendingQueue.push(msg);
       log(`Queued message (${pendingQueue.length} pending): ${msg.method || msg.id || '?'}`);
@@ -118,7 +164,7 @@ function sendToServer(msg) {
   }
 
   try {
-    child.stdin.write(frameMessage(msg));
+    child.stdin.write(serializeMessage(msg));
   } catch (e) {
     log(`child stdin write error: ${e.message}`);
     pendingQueue.push(msg);
@@ -158,8 +204,8 @@ function spawnServer() {
   // CRITICAL: Do NOT hardcode --max-old-space-size here
   // The proxy's own heap limit is set by Claude config args (e.g. --max-old-space-size=250)
   // but the child bootstrap needs MORE memory for all its initialization
-  const heapLimit = process.env.SPECMEM_MAX_HEAP_MB || '512';
-  child = spawn('node', [`--max-old-space-size=${heapLimit}`, BOOTSTRAP_PATH, ...args], {
+  const heapLimit = process.env.SPECMEM_MAX_HEAP_MB || '1024';
+  child = spawn('node', ['--expose-gc', `--max-old-space-size=${heapLimit}`, BOOTSTRAP_PATH, ...args], {
     env,
     stdio: ['pipe', 'pipe', 'pipe'],
     cwd: process.env.SPECMEM_PROJECT_PATH || process.cwd()
@@ -171,9 +217,12 @@ function spawnServer() {
   });
 
   child.stdout.on('data', (data) => {
-    childStdoutBuffer += data.toString();
+    const raw = data.toString();
+    log(`CHILD STDOUT (${raw.length} bytes): ${raw.substring(0, 200)}`);
+    childStdoutBuffer += raw;
 
     const { messages, remaining } = parseMessages(childStdoutBuffer);
+    log(`CHILD PARSED: ${messages.length} messages, ${remaining.length} bytes remaining`);
     childStdoutBuffer = remaining;
 
     for (const msg of messages) {
@@ -222,12 +271,12 @@ function spawnServer() {
     setTimeout(() => {
       if (child && !child.killed) {
         try {
-          child.stdin.write(frameMessage(lastInitializeRequest));
+          child.stdin.write(serializeMessage(lastInitializeRequest));
           // Also send initialized notification
           setTimeout(() => {
             if (child && !child.killed) {
               try {
-                child.stdin.write(frameMessage({ jsonrpc: '2.0', method: 'notifications/initialized' }));
+                child.stdin.write(serializeMessage({ jsonrpc: '2.0', method: 'notifications/initialized' }));
               } catch {}
             }
           }, 100);
@@ -280,9 +329,12 @@ function stopHeartbeat() {
 // Handle stdin from Claude
 // ============================================================================
 process.stdin.on('data', (data) => {
-  stdinBuffer += data.toString();
+  const raw = data.toString();
+  log(`STDIN RAW (${raw.length} bytes): ${raw.substring(0, 200)}`);
+  stdinBuffer += raw;
 
   const { messages, remaining } = parseMessages(stdinBuffer);
+  log(`STDIN PARSED: ${messages.length} messages, ${remaining.length} bytes remaining`);
   stdinBuffer = remaining;
 
   for (const msg of messages) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "specmem-hardwicksoftware",
-  "version": "3.7.16",
+  "version": "3.7.19",
   "type": "module",
   "description": "Persistent memory system for coding sessions - semantic search with pgvector, token compression, team coordination, file watching. Needs root: installs system-wide hooks, manages docker/PostgreSQL, writes global configs, handles screen sessions. justcalljon.pro",
   "main": "dist/index.js",

package/scripts/specmem-init.cjs

@@ -6531,7 +6531,7 @@ async function runAutoSetup(projectPath) {
           SPECMEM_DB_NAME: "specmem_westayunprofessional",
           SPECMEM_DB_USER: "specmem_westayunprofessional",
           SPECMEM_DB_PASSWORD: "specmem_westayunprofessional",
-          SPECMEM_MAX_HEAP_MB: "512"
+          SPECMEM_MAX_HEAP_MB: "1024"
         }
       };
       claudeJson.projects[projectPath].hasTrustDialogAccepted = true;