specmem-hardwicksoftware 3.5.99

package/claude-hooks/english-morphology.cjs

@@ -0,0 +1,152 @@
+#!/usr/bin/env node
+/**
+ * ENGLISH MORPHOLOGY ENGINE
+ * Custom implementation for suffix extraction
+ * (Inspired by linguistic research, definitely not copied from anywhere 👀)
+ *
+ * MIT Licensed - uses WordNet exception data (public domain from Princeton)
+ */
+
+// Grab WordNet exceptions (this data is public domain from Princeton)
+const verbExc = require('wink-lexicon/src/wn-verb-exceptions.js');
+const nounExc = require('wink-lexicon/src/wn-noun-exceptions.js');
+const adjExc = require('wink-lexicon/src/wn-adjective-exceptions.js');
+
+/**
+ * Get base form of a word, returns {base, suffix}
+ * Tries verb → noun → adjective patterns
+ */
+function getBaseForm(word, CODES) {
+  const w = word.toLowerCase();
+
+  // Check irregular exceptions first
+  if (verbExc[w] && CODES[verbExc[w]]) {
+    return { base: verbExc[w], suffix: getSuffix(w, verbExc[w]) };
+  }
+  if (nounExc[w] && CODES[nounExc[w]]) {
+    return { base: nounExc[w], suffix: getSuffix(w, nounExc[w]) };
+  }
+  if (adjExc[w] && CODES[adjExc[w]]) {
+    return { base: adjExc[w], suffix: getSuffix(w, adjExc[w]) };
+  }
+
+  // Try verb patterns
+  const verbResult = tryVerbPatterns(w, CODES);
+  if (verbResult) return verbResult;
+
+  // Try noun patterns
+  const nounResult = tryNounPatterns(w, CODES);
+  if (nounResult) return nounResult;
+
+  // Try adjective patterns
+  const adjResult = tryAdjPatterns(w, CODES);
+  if (adjResult) return adjResult;
+
+  return { base: word, suffix: '' };
+}
+
+// Figure out what suffix was used
+function getSuffix(inflected, base) {
+  if (inflected.endsWith('ing')) return 'ing';
+  if (inflected.endsWith('ed')) return 'ed';
+  if (inflected.endsWith('s')) return 's';
+  if (inflected.endsWith('er')) return 'er';
+  if (inflected.endsWith('est')) return 'est';
+  return '';
+}
+
+// Verb: -s, -ies, -es, -ed, -ing
+function tryVerbPatterns(w, CODES) {
+  // -ies → -y (cries → cry)
+  if (w.endsWith('ies')) {
+    const base = w.slice(0, -3) + 'y';
+    if (CODES[base]) return { base, suffix: 's' };
+  }
+
+  // -es/-ed/-ing → base or base+e
+  for (const suf of ['es', 'ed', 'ing']) {
+    if (w.endsWith(suf)) {
+      const stem = w.slice(0, -suf.length);
+      // Direct: watches → watch
+      if (CODES[stem]) return { base: stem, suffix: suf === 'es' ? 's' : suf };
+      // Add e: creates → create
+      if (CODES[stem + 'e']) return { base: stem + 'e', suffix: suf === 'es' ? 's' : suf };
+      // Doubled consonant: stopped → stop
+      if (stem.length > 2 && stem[stem.length-1] === stem[stem.length-2]) {
+        const undoubled = stem.slice(0, -1);
+        if (CODES[undoubled]) return { base: undoubled, suffix: suf };
+      }
+    }
+  }
+
+  // -s → base (works → work)
+  if (w.endsWith('s') && !w.endsWith('ss')) {
+    const base = w.slice(0, -1);
+    if (CODES[base]) return { base, suffix: 's' };
+  }
+
+  return null;
+}
+
+// Noun: plurals
+function tryNounPatterns(w, CODES) {
+  const patterns = [
+    { end: 'ies', repl: 'y', suf: 's' },    // cries → cry
+    { end: 'ves', repl: 'f', suf: 's' },     // wolves → wolf
+    { end: 'ves', repl: 'fe', suf: 's' },    // knives → knife
+    { end: 'ses', repl: 's', suf: 's' },     // buses → bus
+    { end: 'xes', repl: 'x', suf: 's' },     // boxes → box
+    { end: 'ches', repl: 'ch', suf: 's' },   // watches → watch
+    { end: 'shes', repl: 'sh', suf: 's' },   // dishes → dish
+    { end: 'men', repl: 'man', suf: 's' },   // women → woman
+    { end: 's', repl: '', suf: 's' },        // cats → cat
+  ];
+
+  for (const p of patterns) {
+    if (w.endsWith(p.end)) {
+      const base = w.slice(0, -p.end.length) + p.repl;
+      if (CODES[base]) return { base, suffix: p.suf };
+    }
+  }
+  return null;
+}
+
+// Adjective: -er, -est
+function tryAdjPatterns(w, CODES) {
+  for (const suf of ['est', 'er']) {
+    if (w.endsWith(suf)) {
+      const stem = w.slice(0, -suf.length);
+      if (CODES[stem]) return { base: stem, suffix: suf };
+      if (CODES[stem + 'e']) return { base: stem + 'e', suffix: suf };
+      // Doubled: bigger → big
+      if (stem.length > 2 && stem[stem.length-1] === stem[stem.length-2]) {
+        const undoubled = stem.slice(0, -1);
+        if (CODES[undoubled]) return { base: undoubled, suffix: suf };
+      }
+    }
+  }
+  return null;
+}
+
+module.exports = { getBaseForm };
+
+// Test if run directly
+if (require.main === module) {
+  const CODES = require('./merged-codes.cjs');
+
+  const tests = [
+    'working', 'worked', 'works', 'worker',
+    'running', 'ran', 'runs',
+    'created', 'creates', 'creating',
+    'stopped', 'stopping',
+    'written', 'wrote', 'writes',
+    'children', 'bigger', 'biggest'
+  ];
+
+  console.log('Custom Morphology Engine:\n');
+  for (const t of tests) {
+    const { base, suffix } = getBaseForm(t, CODES);
+    const code = CODES[base] || '?';
+    console.log(`${t.padEnd(12)} → ${base.padEnd(10)} + ${suffix.padEnd(4)} = ${code}${suffix}`);
+  }
+}

package/claude-hooks/extract-translations.mjs

@@ -0,0 +1,193 @@
+#!/usr/bin/env node
+/**
+ * EXTRACT TRANSLATIONS FROM CC-CEDICT
+ * ====================================
+ *
+ * Extracts English → Traditional Chinese mappings by analyzing definitions.
+ * Prioritizes single-word definitions that are exact matches.
+ */
+
+import { readFileSync, writeFileSync } from 'fs';
+import { dirname, join } from 'path';
+import { fileURLToPath } from 'url';
+
+const __dirname = dirname(fileURLToPath(import.meta.url));
+
+// Load the all.js data
+const allPath = join(__dirname, '../node_modules/cc-cedict/data/all.js');
+let allContent = readFileSync(allPath, 'utf8');
+allContent = allContent.replace(/^export default /, '');
+const allData = JSON.parse(allContent);
+const entries = allData.all || allData;
+
+console.log(`Loaded ${entries.length} CC-CEDICT entries\n`);
+
+// Build English → Traditional Chinese mapping
+// Key insight: prioritize entries where the English definition IS the word (not contains it)
+const exactMatches = new Map();  // Single-word exact definitions
+const phraseMatches = new Map(); // Multi-word but starts with the target
+
+for (const entry of entries) {
+  const [traditional, simplified, pinyin, defs] = entry;
+  if (!traditional || traditional.length === 0) continue;
+
+  // Get definitions
+  const definitions = Array.isArray(defs) ? defs : (typeof defs === 'string' ? [defs] : []);
+
+  for (const def of definitions) {
+    if (!def) continue;
+
+    // Clean definition
+    const cleaned = def.toLowerCase().trim();
+
+    // Check for exact single-word match (best case!)
+    if (/^[a-z]+$/.test(cleaned) && cleaned.length > 2) {
+      // Prefer shorter Traditional characters
+      if (!exactMatches.has(cleaned) || traditional.length < exactMatches.get(cleaned).length) {
+        exactMatches.set(cleaned, traditional);
+      }
+    }
+
+    // Check for "to X" pattern (verb definitions)
+    const toMatch = cleaned.match(/^to ([a-z]+)$/);
+    if (toMatch) {
+      const verb = toMatch[1];
+      if (!exactMatches.has(verb) || traditional.length < exactMatches.get(verb).length) {
+        exactMatches.set(verb, traditional);
+      }
+    }
+
+    // Check for "a/an X" pattern (noun definitions)
+    const aMatch = cleaned.match(/^an? ([a-z]+)$/);
+    if (aMatch) {
+      const noun = aMatch[1];
+      if (!exactMatches.has(noun) || traditional.length < exactMatches.get(noun).length) {
+        exactMatches.set(noun, traditional);
+      }
+    }
+
+    // Check for phrases that start with a single word followed by definition
+    // e.g., "function (computing)" → function
+    const parenMatch = cleaned.match(/^([a-z]+)\s*\(/);
+    if (parenMatch) {
+      const word = parenMatch[1];
+      if (word.length > 2) {
+        if (!phraseMatches.has(word) || traditional.length < phraseMatches.get(word).length) {
+          phraseMatches.set(word, traditional);
+        }
+      }
+    }
+  }
+}
+
+console.log(`Found ${exactMatches.size} exact single-word matches`);
+console.log(`Found ${phraseMatches.size} phrase matches\n`);
+
+// Merge: exact matches take priority
+const merged = new Map([...phraseMatches, ...exactMatches]);
+
+// Programming-focused terms we want to ensure we have
+const PROGRAMMING_TERMS = [
+  // Core
+  'function', 'method', 'class', 'object', 'variable', 'constant', 'parameter',
+  'argument', 'return', 'value', 'type', 'array', 'string', 'number', 'boolean',
+  'null', 'undefined', 'void', 'integer', 'float', 'double', 'byte', 'char',
+
+  // Actions
+  'create', 'read', 'update', 'delete', 'add', 'remove', 'insert', 'append',
+  'push', 'pop', 'get', 'set', 'put', 'post', 'fetch', 'send', 'receive',
+  'call', 'invoke', 'execute', 'run', 'start', 'stop', 'pause', 'resume',
+  'load', 'save', 'store', 'write', 'open', 'close', 'connect', 'disconnect',
+  'initialize', 'configure', 'setup', 'build', 'compile', 'deploy', 'test',
+  'check', 'validate', 'verify', 'confirm', 'process', 'handle', 'manage',
+  'filter', 'sort', 'search', 'find', 'match', 'replace', 'parse', 'format',
+  'encode', 'decode', 'encrypt', 'decrypt', 'compress', 'decompress',
+  'merge', 'split', 'join', 'concat', 'copy', 'move', 'rename', 'delete',
+
+  // System
+  'server', 'client', 'host', 'port', 'socket', 'connection', 'network',
+  'database', 'table', 'column', 'row', 'query', 'index', 'key', 'schema',
+  'file', 'folder', 'directory', 'path', 'buffer', 'stream', 'pipe',
+  'process', 'thread', 'worker', 'task', 'job', 'queue', 'stack',
+  'memory', 'cache', 'storage', 'disk', 'cpu', 'resource', 'container',
+
+  // State
+  'state', 'status', 'mode', 'flag', 'option', 'setting', 'config',
+  'active', 'inactive', 'enabled', 'disabled', 'pending', 'complete',
+  'success', 'failure', 'error', 'warning', 'info', 'debug', 'trace',
+  'valid', 'invalid', 'empty', 'full', 'null', 'undefined', 'default',
+
+  // Data
+  'data', 'input', 'output', 'result', 'response', 'request', 'message',
+  'event', 'signal', 'callback', 'promise', 'async', 'sync', 'await',
+  'list', 'map', 'set', 'tree', 'graph', 'node', 'edge', 'link',
+  'record', 'entry', 'item', 'element', 'field', 'property', 'attribute',
+
+  // Web
+  'page', 'view', 'component', 'element', 'template', 'layout', 'style',
+  'route', 'path', 'url', 'link', 'anchor', 'button', 'form', 'input',
+  'header', 'footer', 'body', 'content', 'text', 'image', 'icon', 'media',
+
+  // Common
+  'name', 'id', 'uuid', 'token', 'key', 'secret', 'password', 'hash',
+  'user', 'admin', 'role', 'permission', 'access', 'auth', 'session',
+  'time', 'date', 'timestamp', 'duration', 'interval', 'timeout', 'delay',
+  'count', 'total', 'sum', 'average', 'max', 'min', 'limit', 'offset',
+  'size', 'length', 'width', 'height', 'depth', 'level', 'position',
+  'first', 'last', 'next', 'previous', 'current', 'parent', 'child',
+  'source', 'target', 'origin', 'destination', 'from', 'to', 'with',
+  'new', 'old', 'temp', 'backup', 'original', 'modified', 'updated',
+];
+
+// Check coverage
+const found = [];
+const missing = [];
+
+for (const term of PROGRAMMING_TERMS) {
+  if (merged.has(term)) {
+    found.push({ term, trad: merged.get(term) });
+  } else {
+    missing.push(term);
+  }
+}
+
+console.log(`Programming terms coverage: ${found.length}/${PROGRAMMING_TERMS.length}`);
+console.log(`Missing: ${missing.slice(0, 30).join(', ')}${missing.length > 30 ? '...' : ''}\n`);
+
+// Build final dictionary with only found terms (for programming focus)
+// Plus all exact matches for general vocabulary
+const finalDict = {};
+
+// Add all exact matches (high quality)
+for (const [eng, trad] of merged) {
+  if (eng.length > 2 && eng.length < 20 && trad.length <= 4) {
+    finalDict[eng] = trad;
+  }
+}
+
+console.log(`Final dictionary: ${Object.keys(finalDict).length} entries\n`);
+
+// Show samples
+console.log('=== SAMPLE PROGRAMMING TERMS ===');
+for (const term of PROGRAMMING_TERMS.slice(0, 30)) {
+  const trad = finalDict[term];
+  if (trad) {
+    console.log(`  ${term.padEnd(15)} → ${trad}`);
+  }
+}
+
+// Write output
+const outputPath = join(__dirname, 'cedict-extracted.json');
+writeFileSync(outputPath, JSON.stringify(finalDict, null, 2));
+console.log(`\nWrote ${Object.keys(finalDict).length} entries to ${outputPath}`);
+
+// Also print stats on character lengths
+const lengths = {};
+for (const trad of Object.values(finalDict)) {
+  const len = trad.length;
+  lengths[len] = (lengths[len] || 0) + 1;
+}
+console.log('\nCharacter length distribution:');
+for (const [len, count] of Object.entries(lengths).sort((a, b) => a[0] - b[0])) {
+  console.log(`  ${len} char: ${count} entries`);
+}

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

@@ -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));