specmem-hardwicksoftware 3.7.0 → 3.7.2

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');
 // ============================================================================
@@ -72,10 +117,10 @@ const SOURCE_COMMANDS_DIR = path.join(SPECMEM_ROOT, 'commands');
 const HOOK_ENV = {
     SPECMEM_HOME: path.join(HOME_DIR, '.specmem'), // Dynamic path using os.homedir()
     SPECMEM_PKG: SPECMEM_ROOT, // Use detected package root
-    // Per-project socket paths - ${cwd} is expanded at runtime by  Code
+    // Per-project socket paths - ${PWD} is expanded at MCP server startup
     SPECMEM_RUN_DIR: '${cwd}/specmem/sockets',
     SPECMEM_EMBEDDING_SOCKET: '${cwd}/specmem/sockets/embeddings.sock',
-    SPECMEM_PROJECT_PATH: '${cwd}', // Dynamically set by  Code
+    SPECMEM_PROJECT_PATH: '${PWD}', // Dynamically set by  Code
     SPECMEM_SEARCH_LIMIT: '5',
     SPECMEM_THRESHOLD: '0.30',
     SPECMEM_MAX_CONTENT: '200'
@@ -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 !== '${PWD}' && 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, {});
@@ -191,17 +236,16 @@ function configureMcpServer() {
         config.mcpServers = {};
     }
     // Build the SpecMem MCP server config
-    // CRITICAL: ${cwd} is expanded by  Code at runtime to current working directory
-    // NOTE: ${PWD} resolves at MCP server startup, ${cwd} resolves per-invocation
+    // CRITICAL: ${PWD} is expanded at MCP server startup to current working directory
     const specmemConfig = {
         command: 'node',
         args: ['--max-old-space-size=250', BOOTSTRAP_PATH],
         env: {
-            // Core paths - ${cwd} gives us project isolation (dynamic per-directory)
+            // Core paths - ${PWD} gives us project isolation (dynamic per-directory)
             HOME: HOME_DIR,
-            SPECMEM_PROJECT_PATH: '${cwd}',
-            SPECMEM_WATCHER_ROOT_PATH: '${cwd}',
-            SPECMEM_CODEBASE_PATH: '${cwd}',
+            SPECMEM_PROJECT_PATH: '${PWD}',
+            SPECMEM_WATCHER_ROOT_PATH: '${PWD}',
+            SPECMEM_CODEBASE_PATH: '${PWD}',
             // Database (use environment values or defaults)
             SPECMEM_DB_HOST: process.env.SPECMEM_DB_HOST || 'localhost',
             SPECMEM_DB_PORT: process.env.SPECMEM_DB_PORT || '5432',
@@ -265,8 +309,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 +320,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
+                if (!specmem.env.SPECMEM_PROJECT_PATH || specmem.env.SPECMEM_PROJECT_PATH === '${PWD}' || specmem.env.SPECMEM_PROJECT_PATH === '${PWD}') {
+                    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: '${PWD}',
+                    SPECMEM_WATCHER_ROOT_PATH: '${PWD}',
+                    SPECMEM_CODEBASE_PATH: '${PWD}',
+                    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/package.json

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