specmem-hardwicksoftware 3.5.99

package/claude-hooks/file-claim-enforcer.js

@@ -0,0 +1,293 @@
+#!/usr/bin/env node
+/**
+ * File Claim Enforcer Hook
+ * ========================
+ *
+ * PreToolUse hook that DENIES Read/Edit/Write operations if the agent
+ * hasn't claimed the file first via claim_task.
+ *
+ * Forces agents to use the workflow:
+ * 1. claim_task({description: "reading X", files: ["path/to/file"]})
+ * 2. THEN Read/Edit/Write the file
+ *
+ * IMPORTANT: Queries the ACTUAL team_comms database for claims,
+ * not a separate cache file. Claims are stored in task_claims table.
+ *
+ * Hook Event: PreToolUse
+ * Matcher: Read, Edit, Write
+ */
+
+const fs = require('fs');
+const path = require('path');
+
+// Use shared specmem-paths for Client (single connection) and getSchemaName
+const { getClient, getSchemaName } = require('./specmem-paths.cjs');
+
+/**
+ * Query PostgreSQL for active claims
+ * Returns array of claimed file paths
+ */
+async function loadClaimsFromDb() {
+  const projectPath = process.env.SPECMEM_PROJECT_PATH || process.cwd();
+
+  // DB connection from env (same as MCP server uses)
+  const dbConfig = {
+    host: process.env.SPECMEM_DB_HOST || 'localhost',
+    port: parseInt(process.env.SPECMEM_DB_PORT || '5432', 10),
+    database: process.env.SPECMEM_DB_NAME || 'specmem_westayunprofessional',
+    user: process.env.SPECMEM_DB_USER || 'specmem_westayunprofessional',
+    password: process.env.SPECMEM_DB_PASSWORD || 'specmem_westayunprofessional',
+  };
+
+  // Use shared Client getter from specmem-paths (for single-connection operations)
+  const Client = getClient();
+  if (!Client) {
+    // pg not available, fall back to cache
+    return loadClaimsFromCache();
+  }
+
+  const client = new Client(dbConfig);
+
+  try {
+    await client.connect();
+
+    // Get project schema name using shared function from specmem-paths
+    const schemaName = getSchemaName(projectPath);
+
+    // Set search path to project schema using parameterized identifier
+    // Note: Schema names can't use $1 params, but getSchemaName() sanitizes to [a-z0-9_]
+    // which is safe for SQL identifiers
+    await client.query(`SET search_path TO "${schemaName}", public`);
+
+    // Query active claims for this project
+    const result = await client.query(`
+      SELECT files FROM task_claims
+      WHERE status = 'active'
+      AND (project_path = $1 OR project_path = '/')
+    `, [projectPath]);
+
+    // Flatten all claimed files into a Set
+    const claimedFiles = new Set();
+    for (const row of result.rows) {
+      const files = row.files || [];
+      for (const file of files) {
+        claimedFiles.add(path.resolve(file));
+      }
+    }
+
+    await client.end();
+    return claimedFiles;
+
+  } catch (e) {
+    try { await client.end(); } catch (x) {}
+    // DB query failed, fall back to cache
+    return loadClaimsFromCache();
+  }
+}
+
+/**
+ * Get project-specific tmp directory
+ * Matches the pattern used by team-comms-enforcer.cjs for consistency
+ */
+function getProjectTmpDir() {
+  const crypto = require('crypto');
+  const projectPath = process.env.SPECMEM_PROJECT_PATH || process.cwd();
+  const projectHash = crypto.createHash('sha256').update(path.resolve(projectPath)).digest('hex').slice(0, 12);
+  return `/tmp/specmem-${projectHash}`;
+}
+
+/**
+ * Fallback: Load claims from cache file (legacy)
+ * Only used if DB query fails
+ * Uses project-specific path to match team-comms-enforcer.cjs
+ */
+function loadClaimsFromCache() {
+  const projectTmpDir = getProjectTmpDir();
+  const claimsFile = path.join(projectTmpDir, 'active-claims.json');
+
+  try {
+    if (fs.existsSync(claimsFile)) {
+      const data = fs.readFileSync(claimsFile, 'utf8');
+      const claims = JSON.parse(data);
+      const now = Date.now();
+      const validFiles = new Set();
+
+      // Claims have different structure than old cache format
+      // Format: { claimId: { sessionId, files, createdAt, ... } }
+      for (const [claimId, claim] of Object.entries(claims)) {
+        // Check if claim is still valid (30 min expiry)
+        if (claim.createdAt && (now - claim.createdAt < 30 * 60 * 1000)) {
+          const files = claim.files || [];
+          for (const file of files) {
+            validFiles.add(path.resolve(file));
+          }
+        }
+      }
+      return validFiles;
+    }
+  } catch (e) {
+    // Silent fail - DB should be primary source
+  }
+  return new Set();
+}
+
+/**
+ * Check if a file path is claimed
+ */
+function isFileClaimed(filePath, claimedFiles) {
+  const normalized = path.resolve(filePath);
+
+  // Check exact match
+  if (claimedFiles.has(normalized)) return true;
+
+  // Check if any parent directory is claimed or if file is under claimed dir
+  for (const claimedPath of claimedFiles) {
+    if (normalized.startsWith(claimedPath + '/')) return true;
+    if (claimedPath.startsWith(normalized + '/')) return true;
+  }
+
+  return false;
+}
+
+/**
+ * Files that don't need claims (system/temp files)
+ */
+function isExemptFile(filePath) {
+  const exemptPatterns = [
+    /^\/tmp\//,
+    /^\/dev\//,
+    /node_modules/,
+    /\.git\//,
+    /package-lock\.json$/,
+    /\.log$/,
+    /\.pid$/,
+    /\.lock$/,
+    /\.sock$/,
+    /\/scratchpad\//,
+  ];
+
+  return exemptPatterns.some(pattern => pattern.test(filePath));
+}
+
+/**
+ * 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);
+    });
+  });
+}
+
+/**
+ * Check if we're running as an agent (subagent from Task tool)
+ * Main  sessions should NOT be restricted
+ *
+ * IMPORTANT: Only explicit agent indicators count!
+ * Screen sessions (STY) and process trees are NOT reliable because
+ * main  also runs in screen sessions via specmem-init.
+ */
+function isAgent() {
+  // ONLY use explicit env vars set by agent spawning code
+  // These are set by deployTeamMember or Task tool when spawning agents
+  if (process.env.SPECMEM_AGENT_MODE === '1') return true;
+  if (process.env.SPECMEM_TEAM_MEMBER_ID) return true;
+  if (process.env.CLAUDE_SUBAGENT === '1') return true;
+  if (process.env.CLAUDE_AGENT_ID) return true;
+
+  // Check if this is a team member screen session (has specmem-tm- prefix)
+  // Regular  screens are claude-<project>, not specmem-tm-
+  if (process.env.STY && process.env.STY.includes('specmem-tm-')) return true;
+
+  // Check working directory for agent-specific paths
+  try {
+    const cwd = process.cwd();
+    // Only agent scratchpads, not main project
+    if (cwd.includes('/tmp/claude/') && cwd.includes('/scratchpad/')) {
+      return true;
+    }
+  } catch (e) {}
+
+  // Default: NOT an agent (main  session gets unrestricted access)
+  return false;
+}
+
+async function main() {
+  const inputData = await readStdinWithTimeout(5000);
+
+  try {
+    const hookData = JSON.parse(inputData);
+    const toolName = hookData.tool_name || '';
+    const toolInput = hookData.tool_input || {};
+
+    // Only enforce on agents, not main  session
+    if (!isAgent()) {
+      process.exit(0);
+    }
+
+    // Only enforce on Read, Edit, Write
+    if (!['Read', 'Edit', 'Write'].includes(toolName)) {
+      process.exit(0);
+    }
+
+    // Get the file path from tool input
+    const filePath = toolInput.file_path || toolInput.path || '';
+
+    if (!filePath) {
+      process.exit(0);
+    }
+
+    // Check if exempt
+    if (isExemptFile(filePath)) {
+      process.exit(0);
+    }
+
+    // Load claims from database (falls back to cache if DB unavailable)
+    const claimedFiles = await loadClaimsFromDb();
+
+    // Check if file is claimed
+    if (isFileClaimed(filePath, claimedFiles)) {
+      process.exit(0);
+    }
+
+    // File NOT claimed - DENY with helpful message
+    const shortPath = filePath.length > 40
+      ? '...' + filePath.slice(-37)
+      : filePath;
+
+    const actionType = toolName === 'Read' ? 'reading' : 'editing';
+
+    console.log(JSON.stringify({
+      hookSpecificOutput: {
+        hookEventName: 'PreToolUse',
+        permissionDecision: 'deny',
+        permissionDecisionReason: `⚠️ CLAIM REQUIRED: Before ${actionType} "${shortPath}", you must claim it first:
+mcp__specmem__claim_task({description: "${actionType} ${path.basename(filePath)}", files: ["${filePath}"]})
+
+This prevents merge conflicts with other devs. Claim it, then retry your ${toolName} operation.`
+      }
+    }));
+
+    process.exit(0);
+
+  } catch (error) {
+    // On error, allow operation (fail open)
+    process.exit(0);
+  }
+}
+
+main().catch(() => process.exit(0));

package/claude-hooks/find-collisions.cjs

@@ -0,0 +1,39 @@
+#!/usr/bin/env node
+const { CODES, PHRASES } = require('./token-compressor.cjs');
+
+// Find all collisions
+const codeToWords = {};
+
+// Check CODES
+for (const [eng, chi] of Object.entries(CODES)) {
+  if (!codeToWords[chi]) codeToWords[chi] = [];
+  codeToWords[chi].push(eng);
+}
+
+// Check PHRASES
+for (const [eng, chi] of Object.entries(PHRASES)) {
+  if (!codeToWords[chi]) codeToWords[chi] = [];
+  codeToWords[chi].push('PHRASE:' + eng);
+}
+
+// Print collisions
+console.log('=== CODE COLLISIONS ===');
+let collisionCount = 0;
+for (const [chi, words] of Object.entries(codeToWords)) {
+  // Filter to unique base words (ignore plurals/tenses of same word)
+  const bases = [...new Set(words.map(w => {
+    const clean = w.replace(/^PHRASE:/, '');
+    // Simple lemmatization
+    if (clean.endsWith('ing')) return clean.slice(0, -3);
+    if (clean.endsWith('ed')) return clean.slice(0, -2);
+    if (clean.endsWith('es')) return clean.slice(0, -2);
+    if (clean.endsWith('s') && !clean.endsWith('ss')) return clean.slice(0, -1);
+    return clean;
+  }))];
+
+  if (bases.length > 1) {
+    console.log(`${chi} → ${words.join(', ')}`);
+    collisionCount++;
+  }
+}
+console.log(`\nTotal collisions: ${collisionCount}`);

package/claude-hooks/fix-abbreviations.cjs

@@ -0,0 +1,60 @@
+#!/usr/bin/env node
+/**
+ * FIX ABBREVIATIONS
+ * Removes problematic entries where the code is NOT Chinese
+ * These cause substring matching issues during decompression
+ */
+
+const fs = require('fs');
+const path = require('path');
+
+const codesPath = path.join(__dirname, 'merged-codes.cjs');
+const codes = require(codesPath);
+
+console.log(`Loaded ${Object.keys(codes).length} codes\n`);
+
+// Find and remove problematic entries
+const problematic = [];
+const fixed = {};
+
+for (const [eng, code] of Object.entries(codes)) {
+  // Check if code contains ANY Chinese characters
+  const hasChinese = /[\u4e00-\u9fff\u3400-\u4dbf\u20000-\u2a6df]/.test(code);
+
+  // Keep if it has Chinese OR is a proper abbreviation (all caps, like API, HTTP, REST)
+  const isProperAbbrev = /^[A-Z]+$/.test(code) && ['API', 'HTTP', 'HTTPS', 'REST', 'URL', 'ID', 'PR', 'MR', 'SM', 'DD', 'GC', 'E2E'].includes(code);
+
+  // Keep entries with Chinese or proper abbreviations
+  // Remove entries like "ins", "cos", "P", "PK" that can match inside words
+  if (hasChinese || isProperAbbrev) {
+    fixed[eng] = code;
+  } else {
+    // Check if it's a short lowercase code that could match inside words
+    if (code.length <= 4 && /^[a-z]+$/.test(code)) {
+      problematic.push([eng, code]);
+    } else if (code === 'PK' || code === 'P') {
+      problematic.push([eng, code]);
+    } else {
+      // Keep other codes (like circled numbers ①②③)
+      fixed[eng] = code;
+    }
+  }
+}
+
+console.log('Removed problematic entries:');
+for (const [eng, code] of problematic) {
+  console.log(`  ${eng} → "${code}"`);
+}
+
+console.log(`\nRemoved: ${problematic.length}`);
+console.log(`Remaining: ${Object.keys(fixed).length}`);
+
+// Write fixed codes
+const jsContent = `// AUTO-GENERATED FROM CC-CEDICT + CURATED CODES
+// ${Object.keys(fixed).length} entries (fixed abbreviation collisions)
+// Generated: ${new Date().toISOString()}
+module.exports = ${JSON.stringify(fixed, null, 2)};
+`;
+
+fs.writeFileSync(codesPath, jsContent);
+console.log(`\nWrote fixed codes to ${codesPath}`);

package/claude-hooks/fix-collisions.cjs

@@ -0,0 +1,60 @@
+#!/usr/bin/env node
+/**
+ * FIX COLLISIONS - Ensure unique reverse mappings
+ * Each Chinese code should map to exactly ONE English word
+ */
+
+const fs = require('fs');
+const codes = require('./merged-codes.cjs');
+
+// Find all collisions
+const chiToEng = {};
+for (const [eng, chi] of Object.entries(codes)) {
+  if (!chiToEng[chi]) chiToEng[chi] = [];
+  chiToEng[chi].push(eng);
+}
+
+// Find collisions (same Chinese → multiple English)
+const collisions = Object.entries(chiToEng)
+  .filter(([chi, engs]) => engs.length > 1);
+
+console.log('Found', collisions.length, 'collisions');
+console.log('Examples:');
+collisions.slice(0, 10).forEach(([chi, engs]) => {
+  console.log(' ', chi, '→', engs.join(', '));
+});
+
+// Fix collisions by appending index suffix
+const fixed = { ...codes };
+let fixCount = 0;
+
+for (const [chi, engs] of collisions) {
+  // Keep first word as-is, modify others
+  for (let i = 1; i < engs.length; i++) {
+    const eng = engs[i];
+    // Append a unique suffix (use number character)
+    const numChars = ['①','②','③','④','⑤','⑥','⑦','⑧','⑨','⑩'];
+    fixed[eng] = chi + (numChars[i-1] || i);
+    fixCount++;
+  }
+}
+
+console.log('\nFixed', fixCount, 'collisions');
+
+// Verify no more collisions
+const verify = {};
+for (const [eng, chi] of Object.entries(fixed)) {
+  if (!verify[chi]) verify[chi] = [];
+  verify[chi].push(eng);
+}
+const remaining = Object.values(verify).filter(v => v.length > 1).length;
+console.log('Remaining collisions:', remaining);
+
+// Write fixed codes
+const output = `// AUTO-GENERATED - ${Object.keys(fixed).length} entries, 0 collisions
+// Generated: ${new Date().toISOString()}
+module.exports = ${JSON.stringify(fixed, null, 2)};
+`;
+
+fs.writeFileSync('./merged-codes.cjs', output);
+console.log('\nWrote fixed codes to merged-codes.cjs');

package/claude-hooks/fix-decompressor.cjs

@@ -0,0 +1,79 @@
+#!/usr/bin/env node
+/**
+ * Test and debug decompressor suffix handling
+ */
+const fs = require('fs');
+
+// Test cases
+const tests = [
+  ['啟用ed', 'enabled'],      // enable + ed (base ends in e)
+  ['創ed', 'created'],        // create + ed
+  ['工ing', 'working'],       // work + ing
+  ['濾ed', 'filtered'],       // filter + ed
+  ['返s', 'returns'],         // return + s
+  ['函s', 'functions'],       // function + s
+];
+
+console.log('Testing suffix patterns:\n');
+
+// The problem: when CODES has "enable" → "啟用"
+// And we compress "enabled" → "啟用ed"
+// Then decompress "啟用ed" should → "enabled" not "enableed"
+
+// Solution: When replacing ChineseCode+suffix, check if English base
+// already ends with the first char of suffix
+
+const SUFFIXES = ['tion', 'ment', 'ing', 'ed', 'er', 'est', 'es', 's', 'ly'];
+
+function smartJoin(base, suffix) {
+  // Handle cases where base ends with letter that suffix starts with
+  // enable + ed → enabled (not enableed)
+  // create + ed → created (not createed)
+  if (suffix.startsWith('e') && base.endsWith('e')) {
+    return base + suffix.slice(1);
+  }
+  // For -ing, if base ends in 'e', it was likely dropped
+  // But we stored it as base form, so: write + ing = writing (not writeing)
+  // Actually the morphology engine handles this - it stores 'write' as base
+  // So 寫ing should become writing... but 寫 maps to 'write'
+  // write + ing = writeing? No, the original was 'writing'
+
+  // Actually the issue is:
+  // - Original: "enabled"
+  // - Morphology finds: base="enable", suffix="ed"
+  // - Compress: 啟用ed
+  // - Decompress: 啟用 → "enable", then + "ed" = "enableed" WRONG!
+
+  // The fix: if base ends in 'e' and suffix is 'ed' or 'es' or 'er',
+  // don't add the 'e' from suffix
+  if (base.endsWith('e') && (suffix === 'ed' || suffix === 'es' || suffix === 'er' || suffix === 'est')) {
+    return base + suffix.slice(1); // enabled, creates, writer, latest
+  }
+
+  return base + suffix;
+}
+
+for (const [input, expected] of tests) {
+  // Simulate what the decompressor does
+  // Assume Chinese code maps to English base
+  const chineseCode = input.replace(/[a-z]+$/, '');
+  const suffix = input.match(/[a-z]+$/)?.[0] || '';
+
+  // Mock base lookup
+  const baseMap = {
+    '啟用': 'enable',
+    '創': 'create',
+    '工': 'work',
+    '濾': 'filter',
+    '返': 'return',
+    '函': 'function',
+  };
+
+  const base = baseMap[chineseCode] || '???';
+  const result = smartJoin(base, suffix);
+  const ok = result === expected;
+
+  console.log(`${ok ? '✓' : '✗'} ${input} → ${base} + ${suffix} = ${result} (expected: ${expected})`);
+}
+
+console.log('\n--- smartJoin function ready for integration ---');

package/claude-hooks/fix-suffixes.cjs

@@ -0,0 +1,66 @@
+#!/usr/bin/env node
+/**
+ * FIX SUFFIX HANDLING
+ *
+ * Instead of losing suffixes, KEEP THEM:
+ * working → 工ing (not just 工)
+ * worked → 工ed
+ * worker → 工er
+ * works → 工s
+ */
+
+const fs = require('fs');
+
+// Read current token-compressor.cjs
+let code = fs.readFileSync('./token-compressor.cjs', 'utf8');
+
+// Find the compression section and update it
+// Look for where we do: return CODES[baseLower]; // Compress to base form ONLY
+
+const oldPattern = `if (CODES.hasOwnProperty(baseLower)) {
+      return CODES[baseLower]; // Compress to base form ONLY - no suffix!
+    }`;
+
+const newPattern = `if (CODES.hasOwnProperty(baseLower)) {
+      // KEEP THE ENGLISH SUFFIX! e.g., working → 工ing
+      return CODES[baseLower] + suffix;
+    }`;
+
+if (code.includes(oldPattern)) {
+  code = code.replace(oldPattern, newPattern);
+  console.log('✅ Fixed compression to keep suffixes');
+} else {
+  console.log('❌ Could not find compression pattern to fix');
+  console.log('Searching for similar...');
+
+  // Try alternative pattern
+  const alt = /return CODES\[baseLower\];.*no suffix/;
+  if (alt.test(code)) {
+    code = code.replace(
+      /return CODES\[baseLower\];.*no suffix.*/,
+      'return CODES[baseLower] + suffix; // KEEP English suffix!'
+    );
+    console.log('✅ Fixed with alternative pattern');
+  }
+}
+
+// Also need to update decompression to handle Chinese+suffix
+// Find decompress function and update
+
+const oldDecomp = `// Single pass through ALL codes, sorted by length (longest first)`;
+const hasDecompSection = code.includes(oldDecomp);
+console.log('Has decomp section:', hasDecompSection);
+
+fs.writeFileSync('./token-compressor.cjs', code);
+console.log('Wrote updated token-compressor.cjs');
+
+// Test it
+console.log('\nTesting...');
+delete require.cache[require.resolve('./token-compressor.cjs')];
+const c = require('./token-compressor.cjs');
+
+const tests = ['working', 'worked', 'worker', 'works', 'creating', 'created'];
+for (const t of tests) {
+  const comp = c.compress('The ' + t);
+  console.log(t, '→', comp);
+}