specmem-hardwicksoftware 3.7.17 → 3.7.20

package/dist/codebase/codebaseIndexer.js

@@ -900,7 +900,7 @@ export class CodebaseIndexer {
         const analyzableLanguages = [
             'typescript', 'typescript-react', 'javascript', 'javascript-react',
             'python', 'go', 'rust', 'java', 'kotlin', 'scala',
-            'ruby', 'php', 'c', 'cpp', 'swift'
+            'ruby', 'php', 'c', 'cpp', 'swift', 'html'
         ];
         return analyzableLanguages.includes(language);
     }

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/findWhatISaid.js

@@ -821,7 +821,7 @@ export class FindWhatISaid {
                 });
             }
             catch (embeddingError) {
-                clearTimeout(embeddingTimeoutId); // Prevent dangling timer on error path
+                // embeddingTimeoutId is scoped inside withEmbeddingRetry — already cleared there
                 const embeddingDuration = Date.now() - embeddingStartTime;
                 const err = embeddingError;
                 // ============================================================================

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/embedding-sandbox/frankenstein-embeddings.py

@@ -293,32 +293,48 @@ def _detect_best_onnx_file():
     """
     Detect CPU features and return the best ONNX model file name.
     Priority: avx512_vnni > avx512 > avx2 > default
+    Falls back to whatever .onnx file exists if the optimal one isn't found.
     """
+    # Ordered by preference (best first)
+    candidates = []
+
     try:
         with open('/proc/cpuinfo', 'r') as f:
             cpuinfo = f.read().lower()
 
-        # Check for AVX512 VNNI (best for INT8)
         if 'avx512_vnni' in cpuinfo or 'avx512vnni' in cpuinfo:
-            print("🚀 CPU supports AVX512-VNNI - using optimized INT8 model", file=sys.stderr)
-            return "onnx/model_qint8_avx512_vnni.onnx"
-
-        # Check for AVX512 (good INT8 support)
+            candidates.append(("onnx/model_qint8_avx512_vnni.onnx", "AVX512-VNNI"))
         if 'avx512f' in cpuinfo or 'avx512' in cpuinfo:
-            print("🚀 CPU supports AVX512 - using INT8 quantized model", file=sys.stderr)
-            return "onnx/model_qint8_avx512.onnx"
-
-        # Check for AVX2 (common, decent performance)
+            candidates.append(("onnx/model_qint8_avx512.onnx", "AVX512"))
         if 'avx2' in cpuinfo:
-            print("🚀 CPU supports AVX2 - using UINT8 quantized model", file=sys.stderr)
-            return "onnx/model_quint8_avx2.onnx"
-
-        # Fallback to unoptimized
-        print("ℹ️ Using default ONNX model (no AVX optimization)", file=sys.stderr)
-        return "onnx/model.onnx"
+            candidates.append(("onnx/model_quint8_avx2.onnx", "AVX2"))
     except Exception as e:
         print(f"⚠️ Could not detect CPU features: {e}", file=sys.stderr)
-        return "onnx/model.onnx"
+
+    # Always add standard fallbacks
+    candidates.append(("onnx/model_quantized.onnx", "quantized"))
+    candidates.append(("onnx/model.onnx", "default"))
+
+    # Check which files actually exist in the bundled model dir
+    bundled_dir = os.path.join(os.path.dirname(os.path.abspath(__file__)), 'models', 'all-MiniLM-L6-v2')
+    for onnx_file, label in candidates:
+        full_path = os.path.join(bundled_dir, onnx_file)
+        if os.path.isfile(full_path):
+            print(f"🚀 Using {label} ONNX model: {onnx_file}", file=sys.stderr)
+            return onnx_file
+
+    # Last resort: find ANY .onnx file in the bundled dir
+    onnx_dir = os.path.join(bundled_dir, 'onnx')
+    if os.path.isdir(onnx_dir):
+        for f in os.listdir(onnx_dir):
+            if f.endswith('.onnx'):
+                result = f"onnx/{f}"
+                print(f"🔍 Auto-detected ONNX model: {result}", file=sys.stderr)
+                return result
+
+    # Nothing found - return default and let SentenceTransformer handle it
+    print("ℹ️ No bundled ONNX model found - using default", file=sys.stderr)
+    return "onnx/model.onnx"
 
 _BEST_ONNX_FILE = _detect_best_onnx_file()
 

package/embedding-sandbox/server.mjs

@@ -57,6 +57,13 @@ const getMachineSocketPath = () => {
 const SOCKET_PATH = process.env.SOCKET_PATH || getMachineSocketPath();
 const MODEL_NAME = 'Xenova/all-MiniLM-L6-v2';
 
+// Bundled model: shipped with npm package, used as fallback when HF cache unavailable
+import { fileURLToPath } from 'url';
+import { dirname } from 'path';
+const __filename_esm = fileURLToPath(import.meta.url);
+const __dirname_esm = dirname(__filename_esm);
+const BUNDLED_MODEL_DIR = join(__dirname_esm, 'models', 'all-MiniLM-L6-v2');
+
 // Dynamic dimensions - detected from model and database
 let NATIVE_DIM = null;
 let TARGET_DIM = null;
@@ -78,13 +85,39 @@ async function loadModel() {
   try {
     console.log('[Sandbox] Loading model from local cache...');
 
-    // Force local-only mode - will fail if model not pre-downloaded
-    extractor = await pipeline('feature-extraction', MODEL_NAME, {
-      // Use local cache only - no downloads allowed
-      local_files_only: true,
-      // Use CPU only (safer, no GPU driver access)
-      device: 'cpu'
-    });
+    // Try HF cache first, fall back to bundled model
+    let modelSource = MODEL_NAME;
+    try {
+      extractor = await pipeline('feature-extraction', MODEL_NAME, {
+        local_files_only: true,
+        device: 'cpu'
+      });
+    } catch (hfErr) {
+      // HF cache miss — try bundled model shipped with npm package
+      if (existsSync(BUNDLED_MODEL_DIR)) {
+        console.log(`[Sandbox] HF cache miss, loading bundled model: ${BUNDLED_MODEL_DIR}`);
+        // Ensure model.onnx exists (bundled may only have model_quint8_avx2.onnx)
+        const onnxDir = join(BUNDLED_MODEL_DIR, 'onnx');
+        const modelOnnx = join(onnxDir, 'model.onnx');
+        if (!existsSync(modelOnnx) && existsSync(onnxDir)) {
+          // Find any .onnx file and symlink as model.onnx
+          const { readdirSync, symlinkSync } = await import('fs');
+          const onnxFiles = readdirSync(onnxDir).filter(f => f.endsWith('.onnx'));
+          if (onnxFiles.length > 0) {
+            try { symlinkSync(onnxFiles[0], modelOnnx); } catch {}
+          }
+        }
+        extractor = await pipeline('feature-extraction', BUNDLED_MODEL_DIR, {
+          local_files_only: true,
+          device: 'cpu'
+        });
+        modelSource = BUNDLED_MODEL_DIR;
+      } else {
+        throw hfErr;
+      }
+    }
+
+    // Skip the duplicate pipeline call below — extractor is already loaded
 
     modelReady = true;