specmem-hardwicksoftware 3.5.99

package/claude-hooks/post-write-memory-hook.cjs

@@ -0,0 +1,430 @@
+#!/usr/bin/env node
+/**
+ * POST-WRITE MEMORY HOOK
+ * ======================
+ *
+ * Fires AFTER Write/Edit operations to link conversation context to modified files.
+ *
+ * Flow:
+ *   1.  writes/edits a file
+ *   2. This hook intercepts the PostToolUse event
+ *   3. Captures recent conversation context (from session or memories)
+ *   4. Creates a memory with context about WHY the file was modified
+ *   5. Links that memory to the file via codebase_pointers table
+ *   6. Generates embedding ASYNCHRONOUSLY (non-blocking)
+ *
+ * This enables find_code_pointers to return relevant conversation context
+ * when reading files - "who asked for this code and what was discussed?"
+ *
+ * @author hardwicksoftwareservices
+ * @website https://justcalljon.pro
+ */
+
+const fs = require('fs');
+const net = require('net');
+const path = require('path');
+const crypto = require('crypto');
+
+// Use shared specmem-paths for Pool and helpers
+const specmemPaths = require('./specmem-paths.cjs');
+const { getPool, expandCwd, getSchemaName } = specmemPaths;
+const Pool = getPool();
+
+// Early exit if Pool not available
+if (!Pool) {
+  process.exit(0);
+}
+
+// Legacy compat - keep specmemPaths structure for existing code
+const _specmemPaths = {
+    expandCwd,
+    getSpecmemPkg: () => '/specmem',
+    getSpecmemHome: () => path.join(process.cwd(), 'specmem'),
+    getProjectSocketDir: (cwd) => path.join(cwd || process.cwd(), 'specmem', 'sockets'),
+    getEmbeddingSocket: (cwd) => path.join(cwd || process.cwd(), 'specmem', 'sockets', 'embeddings.sock')
+  };
+
+// Default paths
+const SPECMEM_HOME = specmemPaths.getSpecmemHome();
+const SPECMEM_RUN_DIR = expandCwd(process.env.SPECMEM_RUN_DIR) || specmemPaths.getProjectSocketDir();
+
+// Get current project path
+let PROJECT_PATH = expandCwd(process.env.SPECMEM_PROJECT_PATH) || process.cwd() || '/';
+
+/**
+ * Get schema name from project path (local version)
+ */
+function getSchemaNameLocal(projectPath) {
+  if (!projectPath || projectPath === '/') return 'public';
+  const dirName = path.basename(projectPath).toLowerCase().replace(/[^a-z0-9_]/g, '_');
+  return 'specmem_' + dirName;
+}
+
+// DB config - unified credential pattern
+const UNIFIED_DEFAULT = 'specmem_westayunprofessional';
+const unifiedCred = expandCwd(process.env.SPECMEM_PASSWORD) || UNIFIED_DEFAULT;
+const CONFIG = {
+  dbHost: expandCwd(process.env.SPECMEM_DB_HOST) || 'localhost',
+  dbPort: parseInt(expandCwd(process.env.SPECMEM_DB_PORT) || '5432'),
+  dbName: expandCwd(process.env.SPECMEM_DB_NAME) || unifiedCred,
+  dbUser: expandCwd(process.env.SPECMEM_DB_USER) || unifiedCred,
+  dbPassword: expandCwd(process.env.SPECMEM_DB_PASSWORD) || unifiedCred,
+  embeddingSocket: expandCwd(process.env.SPECMEM_EMBEDDING_SOCKET) || path.join(SPECMEM_RUN_DIR, 'embeddings.sock')
+};
+
+// Lazy-initialized pg Pool
+let dbPool = null;
+function getDbPool() {
+  if (!dbPool) {
+    dbPool = new Pool({
+      host: CONFIG.dbHost,
+      port: CONFIG.dbPort,
+      database: CONFIG.dbName,
+      user: CONFIG.dbUser,
+      password: CONFIG.dbPassword,
+      max: 2,
+      idleTimeoutMillis: 3000,
+      connectionTimeoutMillis: 3000
+    });
+  }
+  return dbPool;
+}
+
+/**
+ * Generate UUID v4
+ */
+function generateUUID() {
+  return crypto.randomUUID ? crypto.randomUUID() :
+    'xxxxxxxx-xxxx-4xxx-yxxx-xxxxxxxxxxxx'.replace(/[xy]/g, c => {
+      const r = Math.random() * 16 | 0;
+      return (c === 'x' ? r : (r & 0x3 | 0x8)).toString(16);
+    });
+}
+
+/**
+ * Check if embedding socket exists
+ */
+function isEmbeddingServiceReady() {
+  return fs.existsSync(CONFIG.embeddingSocket);
+}
+
+/**
+ * Generate embedding via Frankenstein service (ASYNC, non-blocking call)
+ */
+function generateEmbeddingAsync(text) {
+  return new Promise((resolve, reject) => {
+    if (!isEmbeddingServiceReady()) {
+      reject(new Error('Embedding service not ready'));
+      return;
+    }
+
+    const socket = new net.Socket();
+    let buffer = '';
+    socket.setTimeout(10000);
+
+    socket.connect(CONFIG.embeddingSocket, () => {
+      socket.write(JSON.stringify({ type: 'embed', text }) + '\n');
+    });
+
+    socket.on('data', (data) => {
+      buffer += data.toString();
+      const idx = buffer.indexOf('\n');
+      if (idx !== -1) {
+        try {
+          const resp = JSON.parse(buffer.slice(0, idx));
+          socket.end();
+          if (resp.embedding) {
+            resolve(resp.embedding);
+          } else {
+            reject(new Error('No embedding in response'));
+          }
+        } catch (e) {
+          reject(e);
+        }
+      }
+    });
+
+    socket.on('error', reject);
+    socket.on('timeout', () => reject(new Error('Embedding timeout')));
+  });
+}
+
+/**
+ * Get recent memories from this project (conversation context)
+ * Returns recent user and assistant messages
+ */
+async function getRecentConversationContext(limit = 5) {
+  try {
+    const pool = getDbPool();
+    const schema = getSchemaNameLocal(PROJECT_PATH);
+    await pool.query('SET search_path TO ' + schema + ', public');
+
+    const result = await pool.query(`
+      SELECT
+        id::text,
+        content,
+        metadata->>'role' as role,
+        created_at
+      FROM memories
+      WHERE project_path = $1
+        AND created_at > NOW() - INTERVAL '30 minutes'
+        AND content IS NOT NULL
+        AND length(content) > 10
+        AND metadata->>'role' IN ('user', 'assistant')
+      ORDER BY created_at DESC
+      LIMIT $2
+    `, [PROJECT_PATH, limit]);
+
+    return result.rows.map(row => ({
+      id: row.id,
+      content: row.content,
+      role: row.role,
+      created_at: row.created_at
+    }));
+  } catch (e) {
+    return [];
+  }
+}
+
+/**
+ * Create a memory entry for the file modification context
+ */
+async function createModificationMemory(filePath, conversationContext, toolResult) {
+  const memoryId = generateUUID();
+
+  // Build content with conversation context
+  let content = `[FILE_MODIFICATION] ${filePath}\n\n`;
+  content += `Recent conversation context:\n`;
+
+  // Add conversation context (reversed to chronological order)
+  const contextMessages = [...conversationContext].reverse();
+  contextMessages.forEach((msg, i) => {
+    const roleLabel = msg.role === 'user' ? '[USER]' : '[CLAUDE]';
+    const preview = (msg.content || '').slice(0, 200).replace(/\n/g, ' ');
+    content += `${roleLabel} ${preview}...\n`;
+  });
+
+  // Add tool result summary if available
+  if (toolResult && typeof toolResult === 'string') {
+    const resultPreview = toolResult.slice(0, 100).replace(/\n/g, ' ');
+    content += `\nResult: ${resultPreview}`;
+  }
+
+  try {
+    const pool = getDbPool();
+    const schema = getSchemaNameLocal(PROJECT_PATH);
+    await pool.query('SET search_path TO ' + schema + ', public');
+
+    // Insert memory
+    await pool.query(`
+      INSERT INTO memories (
+        id,
+        content,
+        memory_type,
+        importance,
+        tags,
+        metadata,
+        project_path,
+        created_at
+      ) VALUES (
+        $1::uuid,
+        $2,
+        'episodic',
+        'medium',
+        ARRAY['file_modification', 'code_context']::text[],
+        $3::jsonb,
+        $4,
+        NOW()
+      )
+    `, [
+      memoryId,
+      content,
+      JSON.stringify({
+        role: 'system',
+        source: 'post_write_hook',
+        file_path: filePath,
+        timestamp: new Date().toISOString()
+      }),
+      PROJECT_PATH
+    ]);
+
+    return memoryId;
+  } catch (e) {
+    return null;
+  }
+}
+
+/**
+ * Link memory to file in codebase_pointers table
+ */
+async function linkMemoryToFile(memoryId, filePath) {
+  try {
+    const pool = getDbPool();
+    const schema = getSchemaNameLocal(PROJECT_PATH);
+    await pool.query('SET search_path TO ' + schema + ', public');
+
+    // Insert into codebase_pointers
+    await pool.query(`
+      INSERT INTO codebase_pointers (
+        memory_id,
+        file_path,
+        pointer_type,
+        created_at
+      ) VALUES (
+        $1::uuid,
+        $2,
+        'modification',
+        NOW()
+      )
+      ON CONFLICT DO NOTHING
+    `, [memoryId, filePath]);
+
+    return true;
+  } catch (e) {
+    return false;
+  }
+}
+
+/**
+ * Update memory with embedding (ASYNC, non-blocking)
+ * Spawns embedding generation and updates DB when ready
+ */
+async function updateMemoryEmbedding(memoryId, content) {
+  try {
+    const embedding = await generateEmbeddingAsync(content);
+    const embStr = `[${embedding.join(',')}]`;
+
+    const pool = getDbPool();
+    const schema = getSchemaNameLocal(PROJECT_PATH);
+    await pool.query('SET search_path TO ' + schema + ', public');
+
+    // Update memory embedding
+    await pool.query(`
+      UPDATE memories
+      SET embedding = $1::vector
+      WHERE id = $2::uuid
+    `, [embStr, memoryId]);
+
+    // Try to update codebase_pointer embedding (column might not exist yet)
+    try {
+      await pool.query(`
+        UPDATE codebase_pointers
+        SET embedding = $1::vector
+        WHERE memory_id = $2::uuid
+      `, [embStr, memoryId]);
+    } catch (colErr) {
+      // Column doesn't exist yet - that's fine, memory still works
+    }
+
+    return true;
+  } catch (e) {
+    // Embedding failure is non-critical - memory still exists, just won't be semantic searchable
+    return false;
+  }
+}
+
+/**
+ * Read stdin with timeout
+ */
+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);
+    });
+  });
+}
+
+/**
+ * Main hook handler
+ */
+async function main() {
+  let input = await readStdinWithTimeout(5000);
+
+  let context;
+  try {
+    context = JSON.parse(input);
+  } catch (e) {
+    process.exit(0);
+  }
+
+  // Extract tool info
+  const toolName = context.tool_name || context.toolName || '';
+  const toolInput = context.tool_input || context.input || {};
+  const toolResult = context.tool_result || context.result || '';
+
+  // Only handle Write and Edit
+  if (!['Write', 'Edit'].includes(toolName)) {
+    process.exit(0);
+  }
+
+  // Get file path from tool input
+  const filePath = toolInput.file_path || toolInput.filePath || '';
+  if (!filePath) {
+    process.exit(0);
+  }
+
+  // Update PROJECT_PATH from cwd if provided
+  if (context.cwd) {
+    PROJECT_PATH = context.cwd;
+    CONFIG.embeddingSocket = specmemPaths.getEmbeddingSocket(context.cwd);
+  }
+
+  // Skip if file is outside project
+  if (!filePath.startsWith(PROJECT_PATH) && !filePath.startsWith('/')) {
+    process.exit(0);
+  }
+
+  try {
+    // Get recent conversation context
+    const conversationContext = await getRecentConversationContext(5);
+
+    // Create memory for this modification
+    const memoryId = await createModificationMemory(filePath, conversationContext, toolResult);
+    if (!memoryId) {
+      process.exit(0);
+    }
+
+    // Link memory to file
+    await linkMemoryToFile(memoryId, filePath);
+
+    // Generate embedding ASYNC - don't block on this
+    // The memory is already created, embedding just makes it semantic searchable
+    const memoryContent = `File modification: ${filePath}\n${conversationContext.map(m => m.content).join('\n')}`;
+
+    // Fire and forget - don't await
+    updateMemoryEmbedding(memoryId, memoryContent).catch(() => {});
+
+    // Output nothing - this is a silent hook that just records context
+    // We don't want to clutter 's output
+
+  } catch (e) {
+    // Silent fail - don't break 's operation
+  }
+
+  // Clean up pool
+  if (dbPool) {
+    await dbPool.end().catch(() => {});
+  }
+
+  process.exit(0);
+}
+
+main().catch(async () => {
+  if (dbPool) {
+    await dbPool.end().catch(() => {});
+  }
+  process.exit(0);
+});

package/claude-hooks/quick-test.cjs

@@ -0,0 +1,24 @@
+#!/usr/bin/env node
+// Force fresh require
+delete require.cache[require.resolve('./token-compressor.cjs')];
+const c = require('./token-compressor.cjs');
+
+const tests = [
+  'enabled',
+  'created',
+  'working',
+  'functions',
+  'queries',
+  'settings',
+];
+
+console.log('Quick round-trip test:\n');
+let pass = 0, fail = 0;
+for (const t of tests) {
+  const comp = c.compress(t);
+  const dec = c.decompress(comp);
+  const ok = dec.trim() === t;
+  console.log(`${ok ? '✓' : '✗'} ${t} → ${comp} → ${dec.trim()}`);
+  ok ? pass++ : fail++;
+}
+console.log(`\n${pass}/${pass+fail} passed`);

package/claude-hooks/quick-test2.cjs

@@ -0,0 +1,24 @@
+#!/usr/bin/env node
+delete require.cache[require.resolve('./token-compressor.cjs')];
+const c = require('./token-compressor.cjs');
+
+const tests = [
+  'The function returns a value.',
+  'Creating new database connections.',
+  'The server is processing requests.',
+  'User authentication enabled successfully.',
+  'Filtering queries from the cache.',
+];
+
+console.log('Sentence round-trip test:\n');
+let pass = 0, fail = 0;
+for (const t of tests) {
+  const comp = c.compress(t);
+  const dec = c.decompress(comp);
+  const ok = dec === t;
+  console.log(`${ok ? '✓' : '✗'} "${t}"`);
+  console.log(`  comp: "${comp}"`);
+  console.log(`  dec:  "${dec}"\n`);
+  ok ? pass++ : fail++;
+}
+console.log(`${pass}/${pass+fail} passed`);

package/claude-hooks/remove-bad-codes.cjs

@@ -0,0 +1,23 @@
+#!/usr/bin/env node
+const fs = require('fs');
+const codes = require('./merged-codes.cjs');
+
+// Remove entries with pure lowercase ASCII codes (cause substring matching issues)
+const bad = [];
+for (const [eng, code] of Object.entries(codes)) {
+  if (/^[a-z]{1,4}$/.test(code)) {
+    bad.push([eng, code]);
+    delete codes[eng];
+  }
+}
+
+console.log('Removed:');
+bad.forEach(([e,c]) => console.log(`  ${e} → ${c}`));
+console.log(`\nTotal removed: ${bad.length}`);
+console.log(`Remaining: ${Object.keys(codes).length}`);
+
+const out = `// ${Object.keys(codes).length} entries - fixed
+module.exports = ${JSON.stringify(codes, null, 2)};
+`;
+fs.writeFileSync('./merged-codes.cjs', out);
+console.log('Done!');

package/claude-hooks/search-reminder-hook.js

@@ -0,0 +1,90 @@
+#!/usr/bin/env node
+/**
+ * Search Reminder Hook
+ * ====================
+ *
+ * PreToolUse hook that injects a Traditional Chinese compressed reminder
+ * when  uses Grep/Glob tools, suggesting find_code_pointers instead.
+ *
+ * Hook Event: PreToolUse
+ * Matcher: Grep, Glob
+ */
+
+/**
+ * Read stdin with timeout
+ */
+function readStdinWithTimeout(timeoutMs = 3000) {
+  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);
+    });
+  });
+}
+
+/**
+ * Compact Traditional Chinese reminder for find_code_pointers
+ *  understands Chinese internally, outputs English
+ */
+function getSearchReminder() {
+  return `
+[SM-搜索提示] ⚠️壓縮-內部理解中文,輸出英文
+考慮用 find_code_pointers 代替 Grep/Glob:
+
+🔍 **find_code_pointers** - 語義碼搜 + 追蹤調用者
+   - zoom=0: 簽名only (概覽)
+   - zoom=50: 平衡 (默認)
+   - zoom=100: 全上下文
+   - includeTracebacks=true: 顯示誰調用此碼
+   - cameraRollMode=true: 返回drilldownIDs可深入探索
+
+💡 用例:
+   - "找認證函數" → find_code_pointers({query:"authentication"})
+   - "追蹤API調用" → find_code_pointers({query:"API endpoint", includeTracebacks:true})
+   - "快速概覽" → find_code_pointers({query:"...", zoom:0, limit:20})
+
+Grep/Glob適合精確模式匹配. find_code_pointers適合理解代碼意圖.
+[/SM-搜索提示]`;
+}
+
+async function main() {
+  const inputData = await readStdinWithTimeout(3000);
+
+  try {
+    const hookData = JSON.parse(inputData);
+    const toolName = hookData.tool_name || '';
+
+    // Only trigger on Grep/Glob
+    if (!['Grep', 'Glob'].includes(toolName)) {
+      process.exit(0);
+    }
+
+    // Inject reminder as additionalContext (doesn't block, just adds context)
+    console.log(JSON.stringify({
+      hookSpecificOutput: {
+        hookEventName: 'PreToolUse',
+        additionalContext: getSearchReminder()
+      }
+    }));
+
+    process.exit(0);
+
+  } catch (error) {
+    // On error, pass through silently
+    process.exit(0);
+  }
+}
+
+main().catch(() => process.exit(0));

package/claude-hooks/semantic-test.cjs

@@ -0,0 +1,93 @@
+#!/usr/bin/env node
+/**
+ * SEMANTIC ACCURACY TEST
+ * Tests that MEANING is preserved, not exact string match
+ * (Filler words like "the", "a", "is" are intentionally removed)
+ */
+delete require.cache[require.resolve('./token-compressor.cjs')];
+const c = require('./token-compressor.cjs');
+
+let passed = 0, failed = 0;
+const failures = [];
+
+function semanticTest(input) {
+  const comp = c.compress(input);
+  const dec = c.decompress(comp);
+
+  // Get semantic words (removes fillers, lemmatizes)
+  const origWords = c.getSemanticWords(input);
+  const decWords = c.getSemanticWords(dec);
+
+  // Check if all original semantic words are in decompressed
+  const origSet = new Set(origWords);
+  const decSet = new Set(decWords);
+
+  let matches = 0;
+  for (const w of origSet) {
+    if (decSet.has(w)) matches++;
+  }
+
+  const accuracy = origSet.size > 0 ? matches / origSet.size : 1;
+  const ok = accuracy >= 0.95;
+
+  if (ok) {
+    passed++;
+    const savings = ((1 - comp.length / input.length) * 100).toFixed(0);
+    console.log(`✓ ${savings}% saved: "${input.slice(0,40)}..."`);
+  } else {
+    failed++;
+    failures.push({ input, comp, dec, accuracy, origWords, decWords });
+    console.log(`✗ ${(accuracy*100).toFixed(0)}%: "${input.slice(0,40)}..."`);
+  }
+}
+
+console.log('═══════════════════════════════════════════════════════════════');
+console.log('           SEMANTIC ACCURACY TEST (meaning preservation)');
+console.log('═══════════════════════════════════════════════════════════════\n');
+
+const tests = [
+  // Sentences
+  'The function returns a value from the database.',
+  'User authentication failed due to invalid credentials.',
+  'The server is processing multiple client requests.',
+  'Creating a new component with custom properties.',
+  'The query returned empty results from the cache.',
+  'Checking if the session token is still valid.',
+  'The application crashed with a memory exception.',
+  'Building the project with optimized settings.',
+  'The worker is busy processing background tasks.',
+  'Database connection timeout exceeded the limit.',
+  'Parsing JSON response from the API endpoint.',
+  'The callback function was triggered successfully.',
+
+  // Code-like
+  'function getData() { return fetch(url); }',
+  'const user = await database.findOne({ id: userId });',
+  'const filtered = array.filter(item => item.active);',
+  'async function processQueue() { while (true) {} }',
+
+  // Multi-line
+  `async function fetchUserData(userId) {
+    const response = await fetch('/api/users/' + userId);
+    return response.json();
+  }`,
+];
+
+for (const t of tests) semanticTest(t);
+
+console.log('\n═══════════════════════════════════════════════════════════════');
+console.log('                         RESULTS');
+console.log('═══════════════════════════════════════════════════════════════');
+console.log(`Passed: ${passed}`);
+console.log(`Failed: ${failed}`);
+console.log(`Semantic Accuracy: ${((passed / (passed + failed)) * 100).toFixed(1)}%`);
+
+if (failures.length > 0) {
+  console.log('\n─── FAILURES ───');
+  for (const f of failures) {
+    console.log(`\nInput: "${f.input.slice(0,60)}..."`);
+    console.log(`  Original words: [${f.origWords.join(', ')}]`);
+    console.log(`  Decompressed:   [${f.decWords.join(', ')}]`);
+    console.log(`  Accuracy: ${(f.accuracy * 100).toFixed(0)}%`);
+  }
+}