specmem-hardwicksoftware 3.5.99

package/claude-hooks/context-yeeter.cjs

@@ -0,0 +1,244 @@
+#!/usr/bin/env node
+/**
+ * Context Yeeter - yooo we trimming context AND compressing it
+ *
+ * Adapted from concepts, rewritten with our sauce:
+ * - Strips bloated MCP tool schemas
+ * - Trims old messages
+ * - Compresses everything with Chinese tokens
+ * - Yeets old thinking blocks
+ *
+ * Hook Event: PostToolUse (cleans up after tool results)
+ *
+ * @author hardwicksoftwareservices - nah bruh we aint copying, we innovating
+ */
+
+const fs = require('fs');
+const path = require('path');
+const os = require('os');
+
+// load our goated compressor
+let compressor = null;
+const COMPRESSOR_PATH = path.join(os.homedir(), '.claude', 'hooks', 'token-compressor.cjs');
+
+function getCompressor() {
+  if (compressor) return compressor;
+  try {
+    if (fs.existsSync(COMPRESSOR_PATH)) {
+      compressor = require(COMPRESSOR_PATH);
+    }
+  } catch (e) {}
+  return compressor;
+}
+
+// config - tweak these for your vibe
+const CONFIG = {
+  enabled: true,
+  // yeet mcp tool schemas after this many chars
+  maxToolSchemaChars: 500,
+  // trim tool results to this size
+  maxToolResultChars: 800,
+  // keep this many recent messages untouched
+  keepRecentMessages: 15,
+  // yeet thinking blocks older than N messages
+  yeetOldThinking: true,
+  // compress with chinese tokens
+  useChineseCompression: true,
+  // patterns to always preserve (regex strings)
+  neverYeet: [
+    'error',
+    'Error',
+    'ERROR',
+    'exception',
+    'failed',
+    'FAILED'
+  ]
+};
+
+const STATS_PATH = path.join(os.tmpdir(), 'specmem-context-yeeter-stats.json');
+
+function loadStats() {
+  try {
+    if (fs.existsSync(STATS_PATH)) {
+      return JSON.parse(fs.readFileSync(STATS_PATH, 'utf8'));
+    }
+  } catch (e) {}
+  return {
+    totalYeeted: 0,
+    toolResultsTrimmed: 0,
+    thinkingBlocksYeeted: 0,
+    charsCompressed: 0,
+    charsSaved: 0,
+    callCount: 0
+  };
+}
+
+function saveStats(stats) {
+  try {
+    fs.writeFileSync(STATS_PATH, JSON.stringify(stats));
+  } catch (e) {}
+}
+
+// check if content has important stuff we shouldnt yeet
+function hasImportantStuff(text) {
+  if (!text) return false;
+  for (const pattern of CONFIG.neverYeet) {
+    if (text.includes(pattern)) return true;
+  }
+  return false;
+}
+
+// trim a tool result - keep start and end, yeet the middle
+function trimToolResult(text, maxChars) {
+  if (!text || text.length <= maxChars) return text;
+  if (hasImportantStuff(text)) return text; // dont trim errors
+
+  const keepEach = Math.floor(maxChars / 2) - 10;
+  const start = text.slice(0, keepEach);
+  const end = text.slice(-keepEach);
+  const yeeted = text.length - (keepEach * 2);
+
+  return start + '\n...[' + yeeted + ' chars yeeted]...\n' + end;
+}
+
+// compress text with our chinese token magic
+function squish(text) {
+  const comp = getCompressor();
+  if (!comp || !comp.compress || !CONFIG.useChineseCompression) {
+    return { result: text, saved: 0 };
+  }
+
+  try {
+    const compressed = comp.compress(text);
+    const saved = text.length - compressed.length;
+    return { result: compressed, saved: Math.max(0, saved) };
+  } catch (e) {
+    return { result: text, saved: 0 };
+  }
+}
+
+// process tool output - trim + compress
+function processToolOutput(content, stats) {
+  if (!content || typeof content !== 'string') return content;
+
+  const original = content.length;
+
+  // step 1: trim if too long
+  let processed = trimToolResult(content, CONFIG.maxToolResultChars);
+  if (processed.length < original) {
+    stats.toolResultsTrimmed++;
+  }
+
+  // step 2: compress with chinese
+  const { result, saved } = squish(processed);
+  stats.charsCompressed += processed.length;
+  stats.charsSaved += saved;
+
+  return result;
+}
+
+// yeet old thinking blocks from message history
+function yeetOldThinking(messages, keepRecent, stats) {
+  if (!Array.isArray(messages)) return messages;
+  if (messages.length <= keepRecent) return messages;
+
+  const oldMessages = messages.slice(0, -keepRecent);
+  const recentMessages = messages.slice(-keepRecent);
+
+  // process old messages - yeet thinking, compress content
+  const processed = oldMessages.map(msg => {
+    if (!msg || !msg.content) return msg;
+
+    // if its an array of content blocks
+    if (Array.isArray(msg.content)) {
+      const filtered = msg.content.filter(block => {
+        // yeet thinking blocks
+        if (block.type === 'thinking') {
+          stats.thinkingBlocksYeeted++;
+          return false;
+        }
+        return true;
+      });
+
+      // compress text blocks
+      const compressed = filtered.map(block => {
+        if (block.type === 'text' && block.text) {
+          const { result, saved } = squish(block.text);
+          stats.charsSaved += saved;
+          return { ...block, text: result };
+        }
+        return block;
+      });
+
+      return { ...msg, content: compressed };
+    }
+
+    // if its just a string
+    if (typeof msg.content === 'string') {
+      const { result, saved } = squish(msg.content);
+      stats.charsSaved += saved;
+      return { ...msg, content: result };
+    }
+
+    return msg;
+  });
+
+  return [...processed, ...recentMessages];
+}
+
+async function main() {
+  const input = await new Promise((resolve) => {
+    let data = '';
+    process.stdin.on('data', chunk => data += chunk);
+    process.stdin.on('end', () => {
+      try {
+        resolve(JSON.parse(data));
+      } catch (e) {
+        resolve({});
+      }
+    });
+  });
+
+  if (!CONFIG.enabled) {
+    console.log(JSON.stringify({ decision: 'approve' }));
+    return;
+  }
+
+  const stats = loadStats();
+  stats.callCount++;
+
+  // get tool output if available
+  const toolOutput = input.tool_output || input.result;
+
+  if (toolOutput && typeof toolOutput === 'string') {
+    const processed = processToolOutput(toolOutput, stats);
+    stats.totalYeeted += (toolOutput.length - processed.length);
+  }
+
+  saveStats(stats);
+
+  // every 100 calls, flex our savings
+  if (stats.callCount % 100 === 0 && stats.charsSaved > 1000) {
+    const pct = Math.round(stats.charsSaved / (stats.charsCompressed || 1) * 100);
+    console.log(JSON.stringify({
+      decision: 'approve',
+      message: '[SPECMEM] Context yeeted: ' + stats.charsSaved + ' chars saved (' + pct + '%), ' +
+               stats.thinkingBlocksYeeted + ' thinking blocks removed'
+    }));
+    return;
+  }
+
+  console.log(JSON.stringify({ decision: 'approve' }));
+}
+
+// exports for other hooks
+module.exports = {
+  trimToolResult,
+  squish,
+  yeetOldThinking,
+  CONFIG
+};
+
+main().catch(err => {
+  console.log(JSON.stringify({ decision: 'approve' }));
+});

package/claude-hooks/debug-suffix.cjs

@@ -0,0 +1,15 @@
+const c = require('./token-compressor.cjs');
+
+// Check if work is in CODES
+console.log('work in CODES:', 'work' in c.CODES);
+console.log('work →', c.CODES['work']);
+console.log('create in CODES:', 'create' in c.CODES);
+console.log('create →', c.CODES['create']);
+
+// Test extractSuffix if exported
+if (c.extractSuffix) {
+  console.log('\nextractSuffix tests:');
+  console.log('working →', c.extractSuffix('working'));
+  console.log('worked →', c.extractSuffix('worked'));
+  console.log('creating →', c.extractSuffix('creating'));
+}

package/claude-hooks/debug2.cjs

@@ -0,0 +1,7 @@
+const c = require('./token-compressor.cjs');
+const tests = ['queries', 'settings', 'query', 'setting'];
+for (const t of tests) {
+  const comp = c.compress('The ' + t);
+  const decomp = c.decompress(comp);
+  console.log(`${t} → ${comp} → ${decomp}`);
+}

package/claude-hooks/drilldown-enforcer.js

@@ -0,0 +1,242 @@
+#!/usr/bin/env node
+/**
+ * DRILLDOWN ENFORCER HOOK
+ * =======================
+ *
+ * Enforces the drilldown workflow after SpecMem searches.
+ *
+ * Problem:  uses find_memory/find_code_pointers, gets results with _drill
+ * instructions, then ignores them and uses Read/Glob/Grep directly.
+ *
+ * Solution: This hook tracks when SpecMem searches return results and reminds
+ *  to drill down before using other search tools.
+ *
+ * State is persisted to $SPECMEM_RUN_DIR/specmem-drilldown-state.json
+ * (defaults to ./run/specmem-drilldown-state.json if env not set)
+ *
+ * Works in standalone mode (no PM2 required)
+ *
+ * Hook Event: PreToolUse
+ */
+
+const fs = require('fs');
+const path = require('path');
+
+// Helper to expand ${cwd} in env vars ( Code doesn't expand them!)
+function expandCwd(val) {
+  if (!val) return val;
+  return val.replace(/\$\{cwd\}/g, process.cwd()).replace(/\$cwd/g, process.cwd());
+}
+
+
+
+// Project-relative paths - use process.cwd() as base for per-project isolation
+const SPECMEM_HOME = expandCwd(process.env.SPECMEM_HOME) || path.join(process.cwd(), 'specmem');
+const SPECMEM_PKG = expandCwd(process.env.SPECMEM_PKG) || path.join(process.cwd(), 'specmem');
+// Per-project sockets: default to {cwd}/specmem/sockets/ (NOT SPECMEM_HOME/run!)
+const SPECMEM_RUN_DIR = expandCwd(process.env.SPECMEM_RUN_DIR) || path.join(process.cwd(), 'specmem/sockets');
+
+// Use project-scoped paths for state and logging
+const STATE_FILE = path.join(SPECMEM_RUN_DIR, 'specmem-drilldown-state.json');
+const LOG_FILE = path.join(SPECMEM_HOME, 'logs', 'drilldown-enforcer.log');
+
+// Tools that trigger enforcement reminder
+const SEARCH_TOOLS = ['Read', 'Glob', 'Grep', 'Bash'];
+
+// SpecMem tools that should clear the enforcement
+const SPECMEM_DRILLDOWN_TOOLS = [
+  'mcp__specmem__get_memory',  // This is the drilldown action
+];
+
+// SpecMem tools that SET enforcement (when they return results)
+const SPECMEM_SEARCH_TOOLS = [
+  'mcp__specmem__find_memory',
+  'mcp__specmem__find_code_pointers',
+  'mcp__specmem__smart_search',
+];
+
+function log(message) {
+  try {
+    const timestamp = new Date().toISOString();
+    const logDir = path.dirname(LOG_FILE);
+    if (!fs.existsSync(logDir)) {
+      fs.mkdirSync(logDir, { recursive: true });
+    }
+    fs.appendFileSync(LOG_FILE, `${timestamp} - ${message}\n`);
+  } catch (e) {
+    // Silent fail
+  }
+}
+
+function getState() {
+  try {
+    if (fs.existsSync(STATE_FILE)) {
+      const content = fs.readFileSync(STATE_FILE, 'utf-8');
+      return JSON.parse(content);
+    }
+  } catch (e) {
+    // LOW-40 FIX: Delete corrupted state file instead of silently failing
+    try {
+      fs.unlinkSync(STATE_FILE);
+      log(`Deleted corrupted state file: ${e.message}`);
+    } catch (e2) { /* ignore */ }
+  }
+  return {
+    hasPendingDrilldown: false,
+    lastSearchTool: null,
+    lastSearchQuery: null,
+    resultCount: 0,
+    drillInstructions: [],
+    timestamp: null
+  };
+}
+
+function saveState(state) {
+  try {
+    // Ensure run directory exists for state file
+    const stateDir = path.dirname(STATE_FILE);
+    if (!fs.existsSync(stateDir)) {
+      fs.mkdirSync(stateDir, { recursive: true });
+    }
+    fs.writeFileSync(STATE_FILE, JSON.stringify(state, null, 2));
+  } catch (e) {
+    log(`Failed to save state: ${e.message}`);
+  }
+}
+
+function clearState() {
+  saveState({
+    hasPendingDrilldown: false,
+    lastSearchTool: null,
+    lastSearchQuery: null,
+    resultCount: 0,
+    drillInstructions: [],
+    timestamp: null
+  });
+}
+
+/**
+ * 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 inputData = await readStdinWithTimeout(5000);
+
+  try {
+    const hookData = JSON.parse(inputData);
+    const toolName = hookData.tool_name || '';
+    const toolInput = hookData.tool_input || {};
+
+    const state = getState();
+
+    // Check if this is a drilldown action (clears enforcement)
+    if (SPECMEM_DRILLDOWN_TOOLS.includes(toolName)) {
+      log(`Drilldown detected via ${toolName} - clearing enforcement`);
+      clearState();
+      process.exit(0);
+    }
+
+    // Check if this is a search tool that should trigger reminder
+    if (SEARCH_TOOLS.includes(toolName) && state.hasPendingDrilldown) {
+      // Check if state is recent (within 10 minutes)
+      const stateAge = Date.now() - new Date(state.timestamp).getTime();
+      if (stateAge < 10 * 60 * 1000) {
+        log(`Intercepted ${toolName} - pending drilldown from ${state.lastSearchTool}`);
+
+        // Generate reminder message
+        const reminder = generateDrilldownReminder(state, toolName, toolInput);
+
+        // Output the reminder as context injection
+        const output = {
+          hookSpecificOutput: {
+            hookEventName: 'PreToolUse',
+            permissionDecision: 'allow',
+            permissionDecisionReason: 'Drilldown reminder injected',
+            additionalContext: reminder
+          }
+        };
+
+        console.log(JSON.stringify(output));
+        process.exit(0);
+      } else {
+        // State too old, clear it
+        clearState();
+      }
+    }
+
+    // Allow tool to proceed
+    process.exit(0);
+
+  } catch (error) {
+    log(`Error: ${error.message}`);
+    process.exit(0);
+  }
+}
+
+function generateDrilldownReminder(state, attemptedTool, toolInput) {
+  const instructions = state.drillInstructions.slice(0, 3);
+
+  let reminder = `
+⚠️ DRILLDOWN REMINDER ⚠️
+
+You just searched SpecMem with "${state.lastSearchTool}" and got ${state.resultCount} results.
+Now you're trying to use "${attemptedTool}" directly.
+
+STOP! Use the _drill instructions from your search results first:
+${instructions.map((inst, i) => `  ${i + 1}. ${inst}`).join('\n')}
+
+If the first result doesn't have what you need, ITERATE - drill into result #2, #3, etc.
+Only use ${attemptedTool} if you've drilled down and still need more info.
+
+To drill down on a memory, use: get_memory({id: "MEMORY_ID_FROM_RESULTS"})
+`;
+
+  return reminder;
+}
+
+// Also export a function to SET the drilldown state (called by PostToolUse or external)
+// This would be called after find_memory/find_code_pointers returns results
+function setDrilldownPending(searchTool, query, resultCount, drillInstructions) {
+  saveState({
+    hasPendingDrilldown: true,
+    lastSearchTool: searchTool,
+    lastSearchQuery: query,
+    resultCount: resultCount,
+    drillInstructions: drillInstructions,
+    timestamp: new Date().toISOString()
+  });
+  log(`Set drilldown pending: ${searchTool} returned ${resultCount} results`);
+}
+
+// Run main
+main().catch(err => {
+  // LOW-44 FIX: Log errors to both file AND stderr
+  log(`Fatal: ${err.message}`);
+  console.error('[drilldown-enforcer] Fatal:', err.message || err);
+  process.exit(0);
+});
+
+// Export for external use
+module.exports = { setDrilldownPending, clearState, getState };

package/claude-hooks/english-morphology-standalone.cjs

@@ -0,0 +1,149 @@
+#!/usr/bin/env node
+/**
+ * ENGLISH MORPHOLOGY ENGINE - STANDALONE VERSION
+ * Handles suffix extraction without external dependencies
+ * Falls back to pattern-based analysis
+ */
+
+// Common irregular verb forms (embedded, no external deps)
+const IRREGULAR_VERBS = {
+  'ran': 'run', 'written': 'write', 'wrote': 'write',
+  'built': 'build', 'sent': 'send', 'found': 'find',
+  'made': 'make', 'said': 'say', 'gone': 'go', 'went': 'go',
+  'done': 'do', 'had': 'have', 'been': 'be', 'was': 'be', 'were': 'be',
+  'got': 'get', 'taken': 'take', 'took': 'take',
+  'seen': 'see', 'saw': 'see', 'known': 'know', 'knew': 'know',
+  'thought': 'think', 'brought': 'bring', 'bought': 'buy',
+  'caught': 'catch', 'taught': 'teach', 'fought': 'fight',
+  'held': 'hold', 'told': 'tell', 'sold': 'sell',
+  'left': 'leave', 'kept': 'keep', 'slept': 'sleep',
+  'felt': 'feel', 'met': 'meet', 'led': 'lead',
+  'read': 'read', 'set': 'set', 'put': 'put', 'cut': 'cut',
+  'begun': 'begin', 'began': 'begin', 'broken': 'break', 'broke': 'break',
+  'chosen': 'choose', 'chose': 'choose', 'driven': 'drive', 'drove': 'drive',
+  'eaten': 'eat', 'ate': 'eat', 'fallen': 'fall', 'fell': 'fall',
+  'given': 'give', 'gave': 'give', 'grown': 'grow', 'grew': 'grow',
+  'hidden': 'hide', 'hid': 'hide', 'ridden': 'ride', 'rode': 'ride',
+  'risen': 'rise', 'rose': 'rise', 'spoken': 'speak', 'spoke': 'speak',
+  'stolen': 'steal', 'stole': 'steal', 'thrown': 'throw', 'threw': 'throw',
+  'worn': 'wear', 'wore': 'wear', 'woken': 'wake', 'woke': 'wake',
+};
+
+// Common irregular nouns
+const IRREGULAR_NOUNS = {
+  'children': 'child', 'men': 'man', 'women': 'woman',
+  'teeth': 'tooth', 'feet': 'foot', 'mice': 'mouse',
+  'geese': 'goose', 'people': 'person', 'dice': 'die',
+  'indices': 'index', 'vertices': 'vertex', 'matrices': 'matrix',
+  'analyses': 'analysis', 'theses': 'thesis', 'crises': 'crisis',
+  'phenomena': 'phenomenon', 'criteria': 'criterion', 'data': 'datum',
+};
+
+function getSuffix(inflected, base) {
+  if (inflected.endsWith('ing')) return 'ing';
+  if (inflected.endsWith('ed')) return 'ed';
+  if (inflected.endsWith('es')) return 'es';
+  if (inflected.endsWith('s')) return 's';
+  if (inflected.endsWith('er')) return 'er';
+  if (inflected.endsWith('est')) return 'est';
+  return '';
+}
+
+function getBaseForm(word, CODES) {
+  const w = word.toLowerCase();
+
+  // Check irregular forms first
+  if (IRREGULAR_VERBS[w] && CODES[IRREGULAR_VERBS[w]]) {
+    return { base: IRREGULAR_VERBS[w], suffix: getSuffix(w, IRREGULAR_VERBS[w]) };
+  }
+  if (IRREGULAR_NOUNS[w] && CODES[IRREGULAR_NOUNS[w]]) {
+    return { base: IRREGULAR_NOUNS[w], suffix: 's' };
+  }
+
+  // Try verb patterns: -ing, -ed, -es, -s
+  // -ies → -y (cries → cry)
+  if (w.endsWith('ies') && w.length > 4) {
+    const base = w.slice(0, -3) + 'y';
+    if (CODES[base]) return { base, suffix: 's' };
+  }
+
+  // -ing removal
+  if (w.endsWith('ing') && w.length > 5) {
+    const stem = w.slice(0, -3);
+    // Doubled consonant (running → run)
+    if (stem.length > 2 && stem[stem.length-1] === stem[stem.length-2]) {
+      const base = stem.slice(0, -1);
+      if (CODES[base]) return { base, suffix: 'ing' };
+    }
+    // Direct (working → work)
+    if (CODES[stem]) return { base: stem, suffix: 'ing' };
+    // Add e (creating → create)
+    if (CODES[stem + 'e']) return { base: stem + 'e', suffix: 'ing' };
+  }
+
+  // -ed removal
+  if (w.endsWith('ed') && w.length > 4) {
+    const stem = w.slice(0, -2);
+    // Doubled consonant (stopped → stop)
+    if (stem.length > 2 && stem[stem.length-1] === stem[stem.length-2]) {
+      const base = stem.slice(0, -1);
+      if (CODES[base]) return { base, suffix: 'ed' };
+    }
+    // Direct (worked → work)
+    if (CODES[stem]) return { base: stem, suffix: 'ed' };
+    // Remove 'd' only (created → create)
+    if (CODES[w.slice(0, -1)]) return { base: w.slice(0, -1), suffix: 'ed' };
+  }
+
+  // -es removal (watches → watch, processes → process)
+  if (w.endsWith('es') && w.length > 4) {
+    // -ches, -shes, -xes, -sses, -zes
+    if (w.endsWith('ches') || w.endsWith('shes') || w.endsWith('xes') || w.endsWith('sses') || w.endsWith('zes')) {
+      const base = w.slice(0, -2);
+      if (CODES[base]) return { base, suffix: 's' };
+    }
+    // -ves → -f or -fe (wolves → wolf, knives → knife)
+    if (w.endsWith('ves')) {
+      const baseF = w.slice(0, -3) + 'f';
+      const baseFe = w.slice(0, -3) + 'fe';
+      if (CODES[baseF]) return { base: baseF, suffix: 's' };
+      if (CODES[baseFe]) return { base: baseFe, suffix: 's' };
+    }
+    // Plain -es → -e (creates → create)
+    const base = w.slice(0, -1);
+    if (CODES[base]) return { base, suffix: 's' };
+  }
+
+  // -s removal (works → work)
+  if (w.endsWith('s') && !w.endsWith('ss') && w.length > 3) {
+    const base = w.slice(0, -1);
+    if (CODES[base]) return { base, suffix: 's' };
+  }
+
+  // -er removal (bigger → big, worker → work)
+  if (w.endsWith('er') && w.length > 4) {
+    const stem = w.slice(0, -2);
+    // Doubled consonant (bigger → big)
+    if (stem.length > 2 && stem[stem.length-1] === stem[stem.length-2]) {
+      const base = stem.slice(0, -1);
+      if (CODES[base]) return { base, suffix: 'er' };
+    }
+    if (CODES[stem]) return { base: stem, suffix: 'er' };
+    if (CODES[stem + 'e']) return { base: stem + 'e', suffix: 'er' };
+  }
+
+  // -est removal (biggest → big)
+  if (w.endsWith('est') && w.length > 5) {
+    const stem = w.slice(0, -3);
+    if (stem.length > 2 && stem[stem.length-1] === stem[stem.length-2]) {
+      const base = stem.slice(0, -1);
+      if (CODES[base]) return { base, suffix: 'est' };
+    }
+    if (CODES[stem]) return { base: stem, suffix: 'est' };
+    if (CODES[stem + 'e']) return { base: stem + 'e', suffix: 'est' };
+  }
+
+  return { base: word, suffix: '' };
+}
+
+module.exports = { getBaseForm };