specmem-hardwicksoftware 3.6.1 → 3.7.1

package/dist/init/claudeConfigInjector.js

@@ -41,27 +41,72 @@ const HOOKS_DIR = path.join(CLAUDE_CONFIG_DIR, 'hooks');
 const COMMANDS_DIR = path.join(CLAUDE_CONFIG_DIR, 'commands');
 //  stores per-project MCP configs in ~/.claude.json under "projects" key
 const CLAUDE_JSON_PATH = path.join(HOME_DIR, '.claude.json');
-// SpecMem directory detection - works from both src/ and dist/
+// SpecMem directory detection - dynamically resolves from how specmem was launched
+// Handles bootstrap.cjs AND bootstrap.js, works with ANY install location
+function hasBootstrap(dir) {
+    return fs.existsSync(path.join(dir, 'bootstrap.cjs')) ||
+           fs.existsSync(path.join(dir, 'bootstrap.js'));
+}
 function getSpecmemRoot() {
-    // Check environment variable first
-    if (process.env.SPECMEM_ROOT) {
+    // 1. Check environment variable (explicit override)
+    if (process.env.SPECMEM_ROOT && hasBootstrap(process.env.SPECMEM_ROOT)) {
         return process.env.SPECMEM_ROOT;
     }
-    // Try to detect from current file location
-    // When compiled: dist/init/claudeConfigInjector.js -> need to go up 2 levels
-    // When in src: src/init/claudeConfigInjector.ts -> need to go up 2 levels
-    const currentDir = __dirname;
-    const possibleRoot = path.resolve(currentDir, '..', '..');
-    // Verify by checking for bootstrap.js
-    const bootstrapPath = path.join(possibleRoot, 'bootstrap.js');
-    if (fs.existsSync(bootstrapPath)) {
-        return possibleRoot;
-    }
-    // Fallback to cwd
-    return process.cwd();
+    // 2. Detect from current file location (__dirname is most reliable)
+    // dist/init/claudeConfigInjector.js -> go up 2 levels to package root
+    const fromThisFile = path.resolve(__dirname, '..', '..');
+    if (hasBootstrap(fromThisFile)) {
+        return fromThisFile;
+    }
+    // 3. Detect from process.argv - what script launched us
+    // e.g. node /usr/local/lib/.../bootstrap.cjs or /usr/lib/.../bin/specmem-cli.cjs
+    for (const arg of process.argv) {
+        if (typeof arg === 'string' && arg.includes('specmem')) {
+            // Resolve symlinks to get real path
+            try {
+                const realArg = fs.realpathSync(arg);
+                // Walk up from the script to find package root
+                let candidate = path.dirname(realArg);
+                for (let i = 0; i < 4; i++) {
+                    if (hasBootstrap(candidate)) return candidate;
+                    if (fs.existsSync(path.join(candidate, 'package.json'))) {
+                        try {
+                            const pkg = JSON.parse(fs.readFileSync(path.join(candidate, 'package.json'), 'utf-8'));
+                            if (pkg.name === 'specmem-hardwicksoftware') return candidate;
+                        } catch { /* ignore */ }
+                    }
+                    candidate = path.dirname(candidate);
+                }
+            } catch { /* ignore resolve errors */ }
+        }
+    }
+    // 4. Try resolving the `specmem` command via PATH (execSync imported at top)
+    try {
+        const whichResult = execSync('which specmem 2>/dev/null', { encoding: 'utf-8' }).trim();
+        if (whichResult) {
+            const realBin = fs.realpathSync(whichResult);
+            // specmem binary is at <root>/bin/specmem-cli.cjs -> go up 2 levels
+            const candidate = path.resolve(path.dirname(realBin), '..');
+            if (hasBootstrap(candidate)) return candidate;
+        }
+    } catch { /* which not available or specmem not in PATH */ }
+    // 5. Fallback to cwd (dev mode - running from source)
+    if (hasBootstrap(process.cwd())) {
+        return process.cwd();
+    }
+    // 6. Last resort - return __dirname-based path even without bootstrap
+    return fromThisFile;
+}
+// Find the actual bootstrap file (cjs or js)
+function findBootstrapPath(root) {
+    for (const name of ['bootstrap.cjs', 'bootstrap.js']) {
+        const p = path.join(root, name);
+        if (fs.existsSync(p)) return p;
+    }
+    return path.join(root, 'bootstrap.cjs'); // default
 }
 const SPECMEM_ROOT = getSpecmemRoot();
-const BOOTSTRAP_PATH = path.join(SPECMEM_ROOT, 'bootstrap.js');
+const BOOTSTRAP_PATH = findBootstrapPath(SPECMEM_ROOT);
 const SOURCE_HOOKS_DIR = path.join(SPECMEM_ROOT, 'claude-hooks');
 const SOURCE_COMMANDS_DIR = path.join(SPECMEM_ROOT, 'commands');
 // ============================================================================
@@ -155,7 +200,7 @@ export function isSpecmemMcpConfigured(projectPath) {
         return false;
     }
     const specmem = config.mcpServers.specmem;
-    // Check if it points to a valid bootstrap.js
+    // Check if it points to a valid bootstrap file (cjs or js)
     if (!specmem.args || specmem.args.length < 2) {
         return false;
     }
@@ -167,8 +212,8 @@ export function isSpecmemMcpConfigured(projectPath) {
     // If projectPath specified, check if env has correct project path
     if (projectPath) {
         const configuredPath = specmem.env?.SPECMEM_PROJECT_PATH;
-        // ${PWD} is expanded at runtime by  Code, so it's valid
-        if (configuredPath && configuredPath !== '${PWD}' && configuredPath !== projectPath) {
+        // ${PWD} and ${cwd} are expanded at runtime by Claude Code, so they're valid
+        if (configuredPath && configuredPath !== '${PWD}' && configuredPath !== '${cwd}' && configuredPath !== projectPath) {
             return false;
         }
     }
@@ -179,11 +224,11 @@ export function isSpecmemMcpConfigured(projectPath) {
  * Returns true if changes were made
  */
 function configureMcpServer() {
-    // Verify bootstrap.js exists
+    // Verify bootstrap file exists (cjs or js)
     if (!fs.existsSync(BOOTSTRAP_PATH)) {
         return {
             configured: false,
-            error: `bootstrap.js not found at ${BOOTSTRAP_PATH}`
+            error: `bootstrap not found at ${BOOTSTRAP_PATH}`
         };
     }
     const config = safeReadJson(CONFIG_PATH, {});
@@ -265,8 +310,9 @@ function fixProjectMcpConfigs() {
     // Scan all project entries
     for (const [projectPath, projectConfig] of Object.entries(claudeJson.projects)) {
         const config = projectConfig;
-        // Check if this project has a specmem MCP server config
-        if (config?.mcpServers?.specmem) {
+        if (!config) continue;
+        // Case 1: Project has specmem MCP config but with outdated path
+        if (config.mcpServers?.specmem) {
             const specmem = config.mcpServers.specmem;
             const args = specmem.args || [];
             // Check if the args contain an outdated specmem path
@@ -275,28 +321,49 @@ function fixProjectMcpConfigs() {
                 if (typeof arg === 'string' &&
                     arg.includes('specmem') &&
                     arg !== BOOTSTRAP_PATH &&
-                    (arg.endsWith('index.js') || arg.endsWith('bootstrap.js'))) {
+                    (arg.endsWith('index.js') || arg.endsWith('bootstrap.js') || arg.endsWith('bootstrap.cjs'))) {
                     needsUpdate = true;
                     return BOOTSTRAP_PATH;
                 }
                 return arg;
             });
             if (needsUpdate) {
-                // Update the args
                 specmem.args = updatedArgs;
-                // Ensure SPECMEM_PROJECT_PATH is set to actual project path
-                // CRITICAL: ${PWD} doesn't get expanded by  Code, use literal path
                 if (!specmem.env) {
                     specmem.env = {};
                 }
                 if (!specmem.env.SPECMEM_PROJECT_PATH || specmem.env.SPECMEM_PROJECT_PATH === '${PWD}' || specmem.env.SPECMEM_PROJECT_PATH === '${cwd}') {
-                    specmem.env.SPECMEM_PROJECT_PATH = projectPath; // Use the actual project path key
+                    specmem.env.SPECMEM_PROJECT_PATH = projectPath;
                 }
                 logger.info({ projectPath, oldArgs: args, newArgs: updatedArgs }, '[ConfigInjector] Fixed outdated specmem path in project config');
                 fixed++;
                 modified = true;
             }
         }
+        // Case 2: Project has mcpServers but NO specmem entry (empty {} or missing key)
+        // This empty override hides the global config.json MCP server, so we inject it
+        else if (config.mcpServers && !config.mcpServers.specmem) {
+            // Don't clobber other MCP servers - only add specmem
+            config.mcpServers.specmem = {
+                command: 'node',
+                args: ['--max-old-space-size=250', BOOTSTRAP_PATH],
+                env: {
+                    HOME: HOME_DIR,
+                    SPECMEM_PROJECT_PATH: '${cwd}',
+                    SPECMEM_WATCHER_ROOT_PATH: '${cwd}',
+                    SPECMEM_CODEBASE_PATH: '${cwd}',
+                    SPECMEM_DB_HOST: process.env.SPECMEM_DB_HOST || 'localhost',
+                    SPECMEM_DB_PORT: process.env.SPECMEM_DB_PORT || '5432',
+                    SPECMEM_SESSION_WATCHER_ENABLED: 'true',
+                    SPECMEM_WATCHER_ENABLED: 'true',
+                    SPECMEM_DASHBOARD_ENABLED: 'true',
+                    SPECMEM_DASHBOARD_PORT: process.env.SPECMEM_DASHBOARD_PORT || '8595',
+                }
+            };
+            logger.info({ projectPath }, '[ConfigInjector] Injected specmem MCP server into project with empty mcpServers');
+            fixed++;
+            modified = true;
+        }
     }
     // Write back if modified
     if (modified) {

package/dist/mcp/toolRegistry.js

@@ -54,6 +54,8 @@ 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 { ImportProjectMemories } from '../tools/goofy/importProjectMemories.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)
@@ -500,6 +502,8 @@ 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
+    registry.register(new ImportProjectMemories(db, cachingProvider));
     // Team communication tools - multi-team member coordination
     const teamCommTools = createTeamCommTools();
     for (const tool of teamCommTools) {

package/dist/tools/goofy/importProjectMemories.js

@@ -0,0 +1,337 @@
+/**
+ * importProjectMemories - import memories from another project schema
+ *
+ * copies memories from project A into the current project
+ * so you can carry context across projects fr fr
+ */
+import { randomUUID } from 'crypto';
+import { logger } from '../../utils/logger.js';
+import { getProjectSchema } from '../../db/projectNamespacing.js';
+import { getProjectPathForInsert } from '../../services/ProjectContext.js';
+import { formatHumanReadable } from '../../utils/humanReadableOutput.js';
+
+export class ImportProjectMemories {
+    db;
+    embeddingProvider;
+    name = 'import_project_memories';
+    description = 'Import memories from another project into the current project. Use this to carry context across projects - e.g. import /specmem memories into /AEGIS_AI.';
+    inputSchema = {
+        type: 'object',
+        properties: {
+            sourceProject: {
+                type: 'string',
+                description: 'Absolute path of the source project to import from (e.g. "/specmem", "/AEGIS_AI")'
+            },
+            query: {
+                type: 'string',
+                description: 'Optional semantic search query to filter which memories to import. If omitted, imports all (up to limit).'
+            },
+            tags: {
+                type: 'array',
+                items: { type: 'string' },
+                description: 'Optional tag filter - only import 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: 100,
+                minimum: 1,
+                maximum: 1000,
+                description: 'Max number of memories to import (default: 100)'
+            },
+            dryRun: {
+                type: 'boolean',
+                default: false,
+                description: 'Preview what would be imported without actually importing'
+            }
+        },
+        required: ['sourceProject']
+    };
+
+    constructor(db, embeddingProvider) {
+        this.db = db;
+        this.embeddingProvider = embeddingProvider;
+    }
+
+    async execute(params) {
+        const { sourceProject, query, tags, memoryTypes, importance, dryRun = false } = params;
+        const limit = Math.min(params.limit || 100, 1000);
+        const startTime = Date.now();
+
+        try {
+            // Get schema names
+            const sourceSchema = getProjectSchema(sourceProject);
+            const currentSchema = this.db.getProjectSchemaName();
+            const currentProjectPath = getProjectPathForInsert();
+
+            logger.info({
+                sourceProject,
+                sourceSchema,
+                currentSchema,
+                limit,
+                dryRun,
+                query: query?.slice(0, 50),
+                tags
+            }, 'Starting memory import');
+
+            // Verify source schema exists
+            const schemaCheck = await this.db.query(
+                `SELECT schema_name FROM information_schema.schemata WHERE schema_name = $1`,
+                [sourceSchema]
+            );
+
+            if (schemaCheck.rows.length === 0) {
+                // List available schemas for helpful error
+                const available = await this.db.query(
+                    `SELECT schema_name FROM information_schema.schemata WHERE schema_name LIKE 'specmem_%' ORDER BY schema_name`
+                );
+                const schemaList = available.rows.map(r => r.schema_name).join(', ');
+                return {
+                    content: [{
+                        type: 'text',
+                        text: formatHumanReadable({
+                            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'
+                        })
+                    }]
+                };
+            }
+
+            // Build query to fetch memories from source schema
+            const conditions = [];
+            const queryParams = [];
+            let paramIndex = 1;
+
+            // Filter by tags
+            if (tags && tags.length > 0) {
+                conditions.push(`tags && $${paramIndex}::text[]`);
+                queryParams.push(tags);
+                paramIndex++;
+            }
+
+            // Filter by memory types
+            if (memoryTypes && memoryTypes.length > 0) {
+                conditions.push(`memory_type = ANY($${paramIndex}::text[])`);
+                queryParams.push(memoryTypes);
+                paramIndex++;
+            }
+
+            // Filter by importance
+            if (importance && importance.length > 0) {
+                conditions.push(`importance = ANY($${paramIndex}::text[])`);
+                queryParams.push(importance);
+                paramIndex++;
+            }
+
+            // Build the SELECT query against source schema
+            const whereClause = conditions.length > 0 ? `WHERE ${conditions.join(' AND ')}` : '';
+
+            let selectQuery;
+            if (query && this.embeddingProvider) {
+                // Semantic search - generate embedding for query, order by similarity
+                const embedding = await this.embeddingProvider.generateEmbedding(query);
+                const embeddingStr = `[${embedding.join(',')}]`;
+                queryParams.push(embeddingStr);
+                selectQuery = `
+                    SELECT id, content, memory_type, importance, tags, metadata,
+                           embedding, role, created_at, updated_at, expires_at,
+                           1 - (embedding <=> $${paramIndex}::vector) as similarity
+                    FROM "${sourceSchema}".memories
+                    ${whereClause}
+                    ORDER BY embedding <=> $${paramIndex}::vector
+                    LIMIT ${limit}
+                `;
+                paramIndex++;
+            } else {
+                selectQuery = `
+                    SELECT id, content, memory_type, importance, tags, metadata,
+                           embedding, role, created_at, updated_at, expires_at
+                    FROM "${sourceSchema}".memories
+                    ${whereClause}
+                    ORDER BY created_at DESC
+                    LIMIT ${limit}
+                `;
+            }
+
+            const sourceMemories = await this.db.query(selectQuery, queryParams);
+
+            if (sourceMemories.rows.length === 0) {
+                return {
+                    content: [{
+                        type: 'text',
+                        text: formatHumanReadable({
+                            result: 'No memories found matching criteria in source project',
+                            sourceProject,
+                            sourceSchema,
+                            filters: { tags, memoryTypes, importance, query: query?.slice(0, 50) }
+                        })
+                    }]
+                };
+            }
+
+            // Dry run - just show what would be imported
+            if (dryRun) {
+                const preview = sourceMemories.rows.slice(0, 10).map(m => ({
+                    content: m.content?.slice(0, 100) + (m.content?.length > 100 ? '...' : ''),
+                    type: m.memory_type,
+                    importance: m.importance,
+                    tags: m.tags,
+                    similarity: m.similarity ? Math.round(m.similarity * 100) + '%' : undefined,
+                    created: m.created_at
+                }));
+
+                return {
+                    content: [{
+                        type: 'text',
+                        text: formatHumanReadable({
+                            dryRun: true,
+                            wouldImport: sourceMemories.rows.length,
+                            sourceProject,
+                            sourceSchema,
+                            targetSchema: currentSchema,
+                            preview,
+                            previewNote: sourceMemories.rows.length > 10
+                                ? `Showing 10 of ${sourceMemories.rows.length} memories`
+                                : undefined
+                        })
+                    }]
+                };
+            }
+
+            // Actually import - insert into current schema with new UUIDs
+            let imported = 0;
+            let skipped = 0;
+            const errors = [];
+
+            for (const memory of sourceMemories.rows) {
+                try {
+                    const newId = randomUUID();
+                    const importTag = `imported_from:${sourceProject}`;
+                    const newTags = Array.isArray(memory.tags)
+                        ? [...new Set([...memory.tags, importTag])]
+                        : [importTag];
+
+                    // Merge metadata with import info
+                    const newMetadata = {
+                        ...(memory.metadata || {}),
+                        imported: {
+                            from: sourceProject,
+                            originalId: memory.id,
+                            importedAt: new Date().toISOString()
+                        }
+                    };
+
+                    // Check for duplicate content in target schema
+                    const dupCheck = await this.db.query(
+                        `SELECT id FROM memories WHERE content = $1 LIMIT 1`,
+                        [memory.content]
+                    );
+
+                    if (dupCheck.rows.length > 0) {
+                        skipped++;
+                        continue;
+                    }
+
+                    // Insert into current schema
+                    const insertQuery = `
+                        INSERT INTO memories (
+                            id, content, memory_type, importance, tags, metadata,
+                            embedding, project_path, role, created_at, updated_at
+                        ) VALUES (
+                            $1, $2, $3, $4, $5, $6,
+                            $7, $8, $9, $10, $11
+                        )
+                    `;
+
+                    await this.db.query(insertQuery, [
+                        newId,
+                        memory.content,
+                        memory.memory_type || 'semantic',
+                        memory.importance || 'medium',
+                        newTags,
+                        JSON.stringify(newMetadata),
+                        memory.embedding, // preserve original embedding vector
+                        currentProjectPath,
+                        memory.role || 'user',
+                        memory.created_at || new Date(),
+                        new Date()
+                    ]);
+
+                    imported++;
+                } catch (err) {
+                    const errMsg = err instanceof Error ? err.message : String(err);
+                    errors.push({ id: memory.id, error: errMsg });
+                    logger.warn({ memoryId: memory.id, error: errMsg }, 'Failed to import memory');
+                }
+            }
+
+            const duration = Date.now() - startTime;
+
+            logger.info({
+                imported,
+                skipped,
+                errors: errors.length,
+                duration,
+                sourceProject,
+                sourceSchema,
+                currentSchema
+            }, 'Memory import completed');
+
+            const result = {
+                imported,
+                skipped,
+                errors: errors.length,
+                total: sourceMemories.rows.length,
+                sourceProject,
+                sourceSchema,
+                targetSchema: currentSchema,
+                duration: `${duration}ms`
+            };
+
+            if (errors.length > 0 && errors.length <= 5) {
+                result.errorDetails = errors;
+            } else if (errors.length > 5) {
+                result.errorDetails = errors.slice(0, 5);
+                result.moreErrors = errors.length - 5;
+            }
+
+            return {
+                content: [{
+                    type: 'text',
+                    text: formatHumanReadable(result)
+                }]
+            };
+
+        } catch (err) {
+            const errMsg = err instanceof Error ? err.message : String(err);
+            logger.error({ error: errMsg, sourceProject }, 'Memory import failed');
+            return {
+                content: [{
+                    type: 'text',
+                    text: formatHumanReadable({
+                        error: 'Memory import failed',
+                        details: errMsg,
+                        sourceProject
+                    })
+                }]
+            };
+        }
+    }
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "specmem-hardwicksoftware",
-  "version": "3.6.1",
+  "version": "3.7.1",
   "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",