specmem-hardwicksoftware 3.5.99

package/claude-hooks/specmem-paths.cjs

@@ -0,0 +1,213 @@
+/**
+ * SPECMEM PATHS - Shared path resolution for hooks
+ *
+ * This module dynamically finds the global SpecMem installation,
+ * allowing hooks to work regardless of where SpecMem is installed.
+ */
+
+const { execSync } = require('child_process');
+const path = require('path');
+const fs = require('fs');
+const os = require('os');
+
+/**
+ * Find the global SpecMem package location dynamically
+ * OPTIMIZED: Check fast paths FIRST before slow npm root -g (~115ms)
+ */
+function findGlobalSpecmemPkg() {
+  // 1. Check if we're running from within the package itself
+  const hookDir = __dirname;
+  const possiblePkgRoot = path.dirname(hookDir);
+
+  if (fs.existsSync(path.join(possiblePkgRoot, 'package.json'))) {
+    try {
+      const pkg = JSON.parse(fs.readFileSync(path.join(possiblePkgRoot, 'package.json'), 'utf8'));
+      if (pkg.name === 'specmem-hardwicksoftware') {
+        return possiblePkgRoot;
+      }
+    } catch (e) {}
+  }
+
+  // 2. Check common global locations FIRST (instant fs.existsSync - ~0ms)
+  const commonPaths = [
+    '/usr/lib/node_modules/specmem-hardwicksoftware',
+    '/usr/local/lib/node_modules/specmem-hardwicksoftware',
+    path.join(os.homedir(), '.npm-global/lib/node_modules/specmem-hardwicksoftware'),
+    path.join(os.homedir(), 'node_modules/specmem-hardwicksoftware'),
+    '/specmem'  // Docker/dev fallback
+  ];
+
+  for (const p of commonPaths) {
+    if (fs.existsSync(p)) return p;
+  }
+
+  // 3. Check file-based cache for npm root -g result (avoids 115ms spawn per hook call)
+  const cacheFile = path.join(os.tmpdir(), 'specmem-npm-root-cache.txt');
+  try {
+    if (fs.existsSync(cacheFile)) {
+      const stat = fs.statSync(cacheFile);
+      const ageMs = Date.now() - stat.mtimeMs;
+      // Cache valid for 1 hour
+      if (ageMs < 3600000) {
+        const cachedRoot = fs.readFileSync(cacheFile, 'utf8').trim();
+        const globalPkg = path.join(cachedRoot, 'specmem-hardwicksoftware');
+        if (fs.existsSync(globalPkg)) {
+          return globalPkg;
+        }
+      }
+    }
+  } catch (e) {}
+
+  // 4. SLOW PATH: npm root -g (~115ms) - only if all else fails
+  try {
+    const globalRoot = execSync('npm root -g', { encoding: 'utf8', timeout: 5000 }).trim();
+    // Cache the result for future calls
+    try { fs.writeFileSync(cacheFile, globalRoot); } catch (e) {}
+    const globalPkg = path.join(globalRoot, 'specmem-hardwicksoftware');
+    if (fs.existsSync(globalPkg)) {
+      return globalPkg;
+    }
+  } catch (e) {}
+
+  // 5. Ultimate fallback
+  return process.cwd();
+}
+
+/**
+ * Expand ${cwd} placeholders in env vars
+ * Handles: null, undefined, non-string values, ${cwd}, and $cwd patterns
+ */
+function expandCwd(val, cwd) {
+  if (!val) return val;
+  // Handle non-string values (numbers, objects, etc.)
+  if (typeof val !== 'string') return val;
+  const cwdPath = cwd || process.cwd();
+  return val.replace(/\$\{cwd\}/g, cwdPath).replace(/\$cwd/g, cwdPath);
+}
+
+// Cache the package path
+let _cachedPkgPath = null;
+
+function getSpecmemPkg() {
+  if (!_cachedPkgPath) {
+    _cachedPkgPath = process.env.SPECMEM_PKG
+      ? expandCwd(process.env.SPECMEM_PKG)
+      : findGlobalSpecmemPkg();
+  }
+  return _cachedPkgPath;
+}
+
+function getSpecmemHome() {
+  return process.env.SPECMEM_HOME
+    ? expandCwd(process.env.SPECMEM_HOME)
+    : path.join(os.homedir(), '.specmem');
+}
+
+function getProjectSocketDir(projectPath) {
+  return path.join(projectPath || process.cwd(), 'specmem', 'sockets');
+}
+
+function getEmbeddingSocket(projectPath) {
+  return path.join(getProjectSocketDir(projectPath), 'embeddings.sock');
+}
+
+/**
+ * Load pg classes from specmem package - hooks need these but pg isn't in ~/.claude/hooks/
+ * Provides both Pool (for connection pooling) and Client (for single connections)
+ */
+let Pool = null;
+let Client = null;
+let pgModule = null;
+
+function loadPgModule() {
+  if (pgModule) return pgModule;
+  const pkgPath = getSpecmemPkg();
+
+  // Try loading from specmem package node_modules
+  try {
+    pgModule = require(path.join(pkgPath, 'node_modules/pg'));
+    return pgModule;
+  } catch {}
+
+  // Try global pg
+  try {
+    pgModule = require('pg');
+    return pgModule;
+  } catch {}
+
+  return null;
+}
+
+/**
+ * Get pg.Pool class for connection pooling
+ * Usage: const pool = new Pool(config); pool.query(...);
+ */
+function getPool() {
+  if (Pool) return Pool;
+  const pg = loadPgModule();
+  if (pg) {
+    Pool = pg.Pool;
+  }
+  return Pool;
+}
+
+/**
+ * Get pg.Client class for single connections
+ * Usage: const client = new Client(config); await client.connect(); await client.query(...); await client.end();
+ */
+function getClient() {
+  if (Client) return Client;
+  const pg = loadPgModule();
+  if (pg) {
+    Client = pg.Client;
+  }
+  return Client;
+}
+
+/**
+ * Read stdin with timeout (CRIT-07 fix - prevents hook hangs)
+ */
+function readStdinWithTimeout(timeoutMs = 5000) {
+  return new Promise((resolve) => {
+    let input = '';
+    const timer = setTimeout(() => {
+      process.stdin.destroy();
+      resolve(input);
+    }, timeoutMs);
+
+    process.stdin.setEncoding('utf8');
+    process.stdin.on('data', (chunk) => { input += chunk; });
+    process.stdin.on('end', () => {
+      clearTimeout(timer);
+      resolve(input);
+    });
+    process.stdin.on('error', () => {
+      clearTimeout(timer);
+      resolve(input);
+    });
+  });
+}
+
+/**
+ * Get project schema name from path
+ */
+function getSchemaName(projectPath) {
+  if (!projectPath || projectPath === '/') return 'public';
+  const dirName = path.basename(projectPath).toLowerCase().replace(/[^a-z0-9_]/g, '_');
+  return 'specmem_' + dirName;
+}
+
+module.exports = {
+  findGlobalSpecmemPkg,
+  expandCwd,
+  getSpecmemPkg,
+  getSpecmemHome,
+  getProjectSocketDir,
+  getEmbeddingSocket,
+  getPool,
+  getClient,
+  getSchemaName,
+  readStdinWithTimeout,
+  SPECMEM_PKG: getSpecmemPkg(),
+  SPECMEM_HOME: getSpecmemHome()
+};

package/claude-hooks/specmem-precompact.js

@@ -0,0 +1,183 @@
+#!/usr/bin/env node
+/**
+ * SPECMEM PRE-COMPACTION HOOK
+ * ===========================
+ *
+ * Fires before context compaction to:
+ *   1. Save critical context to SpecMem
+ *   2. Warn when at 5% till compaction
+ *   3. Preserve key decisions and code state
+ *
+ * @author hardwicksoftwareservices
+ * @website https://justcalljon.pro
+ */
+
+const fs = require('fs');
+const path = require('path');
+const os = require('os');
+const { execSync } = require('child_process');
+
+// Shared path resolution
+const specmemPaths = require('./specmem-paths.cjs');
+
+// Token compressor for output
+const { compressHookOutput } = require('./token-compressor.cjs');
+
+// Context deduplication - clear cache on compaction (session boundary)
+let contextDedup;
+try {
+  contextDedup = require('./context-dedup.cjs');
+} catch (e) {
+  contextDedup = { clearCache: () => {} };
+}
+
+
+
+
+// Config - all paths are project-relative by default
+const SPECMEM_HOME = specmemPaths.getSpecmemHome();
+const SPECMEM_PKG = specmemPaths.getSpecmemPkg();
+const RUN_DIR = specmemPaths.expandCwd(process.env.SPECMEM_RUN_DIR) || specmemPaths.getProjectSocketDir();
+
+// TASK #23 FIX: Use unified credential pattern with SPECMEM_PASSWORD fallback
+const UNIFIED_DEFAULT = 'specmem_westayunprofessional';
+const unifiedCred = specmemPaths.expandCwd(process.env.SPECMEM_PASSWORD) || UNIFIED_DEFAULT;
+
+// DB config - unified credential pattern
+const DB = {
+  host: specmemPaths.expandCwd(process.env.SPECMEM_DB_HOST) || 'localhost',
+  port: specmemPaths.expandCwd(process.env.SPECMEM_DB_PORT) || '5432',
+  name: specmemPaths.expandCwd(process.env.SPECMEM_DB_NAME) || unifiedCred,
+  user: specmemPaths.expandCwd(process.env.SPECMEM_DB_USER) || unifiedCred,
+  pass: specmemPaths.expandCwd(process.env.SPECMEM_DB_PASSWORD) || unifiedCred
+};
+
+/**
+ * Save a critical memory
+ */
+function saveCriticalMemory(content, tags = []) {
+  const escapedContent = content.replace(/'/g, "''").replace(/\n/g, '\\n');
+  const tagsArray = `{${tags.map(t => `"${t}"`).join(',')}}`;
+
+  const sql = `
+    INSERT INTO memories (content, memory_type, importance, tags, metadata)
+    VALUES ('${escapedContent}', 'episodic', 'critical', '${tagsArray}',
+            '{"source": "precompact_hook", "timestamp": "${new Date().toISOString()}"}'::jsonb)
+    RETURNING id
+  `;
+
+  try {
+    execSync(
+      `PGPASSWORD='${DB.pass}' psql -h ${DB.host} -p ${DB.port} -U ${DB.user} -d ${DB.name} -t -A -c "${sql.replace(/"/g, '\\"')}"`,
+      { encoding: 'utf8', timeout: 5000, stdio: ['pipe', 'pipe', 'pipe'] }
+    );
+    return true;
+  } catch (e) {
+    return false;
+  }
+}
+
+/**
+ * Main hook handler
+ */
+/**
+ * Read stdin with timeout to prevent indefinite hangs
+ * CRIT-07 FIX: All hooks must use this instead of raw for-await
+ */
+function readStdinWithTimeout(timeoutMs = 5000) {
+  return new Promise((resolve) => {
+    let input = '';
+    const timer = setTimeout(() => {
+      process.stdin.destroy();
+      resolve(input);
+    }, timeoutMs);
+
+    process.stdin.setEncoding('utf8');
+    process.stdin.on('data', (chunk) => { input += chunk; });
+    process.stdin.on('end', () => {
+      clearTimeout(timer);
+      resolve(input);
+    });
+    process.stdin.on('error', () => {
+      clearTimeout(timer);
+      resolve(input);
+    });
+  });
+}
+
+async function main() {
+  // CRIT-07 FIX: Read input with timeout instead of indefinite for-await
+  let input = await readStdinWithTimeout(5000);
+
+  // Parse hook input
+  let messageCount = 0;
+  let tokenCount = 0;
+  let compactionTarget = 0;
+  let projectPath = process.cwd();
+
+  try {
+    const data = JSON.parse(input);
+    messageCount = data.messageCount || 0;
+    tokenCount = data.tokenCount || 0;
+    compactionTarget = data.compactionTarget || 0;
+    projectPath = data.workingDirectory || data.cwd || process.cwd();
+  } catch (e) {
+    // Use defaults
+  }
+
+  // COMPACTION = SESSION BOUNDARY - clear context injection cache
+  // This ensures pre-tool-use hooks can inject fresh context after compaction
+  contextDedup.clearCache(projectPath);
+
+  // Calculate percentage remaining
+  const percentRemaining = compactionTarget > 0
+    ? Math.round((1 - tokenCount / compactionTarget) * 100)
+    : 100;
+
+  // Build output
+  let output = '';
+
+  // Warning at 5% or less
+  if (percentRemaining <= 5) {
+    output += `\n⚠️ COMPACTION IMMINENT (${percentRemaining}% context remaining)\n`;
+    output += `Messages: ${messageCount} | Tokens: ${tokenCount}/${compactionTarget}\n`;
+    output += `Critical context will be saved to SpecMem.\n\n`;
+
+    // Save compaction event
+    const summary = `Pre-compaction state: ${messageCount} messages, ${tokenCount} tokens, project: ${projectPath}`;
+    saveCriticalMemory(summary, ['compaction', 'system', path.basename(projectPath)]);
+  } else if (percentRemaining <= 15) {
+    output += `\n📊 Context usage: ${100 - percentRemaining}% (${tokenCount}/${compactionTarget} tokens)\n`;
+    output += `Consider using /specmem-remember to save important context.\n\n`;
+  }
+
+  // If we have actual content to preserve, save it
+  // The hook receives conversation summary in some cases
+  if (input.length > 500) {
+    // Save truncated version of current context
+    const contextSummary = input.slice(0, 2000);
+    saveCriticalMemory(
+      `Context before compaction:\n${contextSummary}`,
+      ['precompact', 'context', path.basename(projectPath)]
+    );
+  }
+
+  // Output warning/status with compression
+  if (output) {
+    // Compress but skip warning header since this IS a warning
+    const compressed = compressHookOutput(output, {
+      threshold: 0.70,
+      minLength: 30,
+      includeWarning: true  // Still remind  to respond in English
+    });
+    console.log(compressed);
+  }
+
+  process.exit(0);
+}
+
+main().catch((e) => {
+  // LOW-44 FIX: Log errors before exit
+  console.error('[specmem-precompact] Unhandled error:', e.message || e);
+  process.exit(0);
+});

package/claude-hooks/specmem-session-init.sh

@@ -0,0 +1,33 @@
+#!/bin/bash
+# SpecMem Session Init Hook
+# Enables MCP tool access for Task-spawned subagents (team members)
+#
+# This hook runs on SessionStart and writes the magic env var to CLAUDE_ENV_FILE
+# so that all Task-spawned agents get access to SpecMem MCP tools.
+#
+# Works in standalone mode (no PM2 required) - SpecMem runs as stdio MCP server
+
+# Determine SPECMEM_HOME - use env var if set, otherwise detect from script location
+SCRIPT_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
+SPECMEM_HOME_DETECTED="${SPECMEM_HOME:-$(dirname "$SCRIPT_DIR")}"
+
+if [ -n "$CLAUDE_ENV_FILE" ]; then
+  # Enable MCP tools for subagents (the secret sauce!)
+  echo 'export CLAUDE_CODE_ALLOW_MCP_TOOLS_FOR_SUBAGENTS=1' >> "$CLAUDE_ENV_FILE"
+
+  # Set SPECMEM_HOME for hooks - use detected path if not already set
+  if [ -z "$SPECMEM_HOME" ]; then
+    echo "export SPECMEM_HOME='${SPECMEM_HOME_DETECTED}'" >> "$CLAUDE_ENV_FILE"
+  else
+    echo "export SPECMEM_HOME='${SPECMEM_HOME}'" >> "$CLAUDE_ENV_FILE"
+  fi
+
+  # Set SPECMEM_RUN_DIR for hook state files (project-scoped)
+  echo "export SPECMEM_RUN_DIR='${SPECMEM_HOME_DETECTED}/run'" >> "$CLAUDE_ENV_FILE"
+
+  # Ensure run directory exists for state files
+  mkdir -p "${SPECMEM_HOME_DETECTED}/run" 2>/dev/null || true
+  mkdir -p "${SPECMEM_HOME_DETECTED}/logs" 2>/dev/null || true
+fi
+
+exit 0