@massu/core 0.6.3 → 0.8.0

package/src/hooks/classify-failure.ts

@@ -0,0 +1,259 @@
+#!/usr/bin/env node
+// Copyright (c) 2026 Massu. All rights reserved.
+// Licensed under BSL 1.1 - see LICENSE file for details.
+
+// ============================================================
+// PostToolUse Hook: Failure Classification
+// Classifies bug fixes against known failure patterns before
+// demanding the full incident loop. Prevents rule bloat by
+// recognizing known patterns vs genuinely novel failures.
+//
+// Part of the Auto-Learning Pipeline:
+//   [Fix Detected] → [CLASSIFY] → Incident Report → Rule → Enforcement
+//
+// Classification:
+//   SCORE >= known threshold  → KNOWN   — Reference existing rules, no new deliverables
+//   SCORE >= similar threshold → SIMILAR — Check existing rules first
+//   SCORE < similar threshold  → NEW     — Full incident loop mandatory
+//
+// Triggers on: Edit|Write to code files
+// Must complete in <1000ms.
+// ============================================================
+
+import { existsSync, readFileSync, readdirSync, unlinkSync } from 'fs';
+import { tmpdir } from 'os';
+import { join, basename } from 'path';
+import { getProjectRoot, getConfig } from '../config.ts';
+import { getMemoryDb, scoreFailureClasses } from '../memory-db.ts';
+
+interface HookInput {
+  session_id: string;
+  tool_name: string;
+  tool_input: {
+    file_path?: string;
+    old_string?: string;
+    new_string?: string;
+    content?: string;
+  };
+}
+
+// Bug fix detection heuristics
+const BUG_FIX_INDICATORS = [
+  /\b(catch|error|throw|fail|fix|bug|broken|missing|crash|wrong|typo|incorrect)\b/i,
+];
+
+const CODE_EXTENSIONS = /\.(ts|tsx|js|jsx|py|swift|rs|go|rb|sh)$/;
+
+function getDedupeMarkerPath(sessionId: string, filePath: string): string {
+  // One reminder per file per calendar day
+  const day = new Date().toISOString().slice(0, 10);
+  const hash = simpleHash(filePath);
+  return join(tmpdir(), `massu-classify-${day}-${sessionId.slice(0, 8)}-${hash}`);
+}
+
+function simpleHash(str: string): string {
+  let h = 0;
+  for (let i = 0; i < str.length; i++) {
+    h = ((h << 5) - h + str.charCodeAt(i)) | 0;
+  }
+  return Math.abs(h).toString(36);
+}
+
+function readFailureContextFiles(): string {
+  const dir = tmpdir();
+  let context = '';
+  try {
+    const files = readdirSync(dir).filter(f => f.startsWith('massu-failure-context-'));
+    for (const file of files) {
+      try {
+        context += ' ' + readFileSync(join(dir, file), 'utf-8');
+      } catch { /* ignore */ }
+    }
+  } catch { /* ignore */ }
+  return context.trim();
+}
+
+function cleanupFailureContextFiles(): void {
+  const dir = tmpdir();
+  try {
+    const files = readdirSync(dir).filter(f => f.startsWith('massu-failure-context-'));
+    for (const file of files) {
+      try { unlinkSync(join(dir, file)); } catch { /* ignore */ }
+    }
+  } catch { /* ignore */ }
+}
+
+async function main(): Promise<void> {
+  try {
+    const input = await readStdin();
+    const hookInput = JSON.parse(input) as HookInput;
+    const filePath = hookInput.tool_input?.file_path;
+
+    if (!filePath) {
+      process.exit(0);
+      return;
+    }
+
+    const config = getConfig();
+
+    // Check if feature is enabled
+    if (config.autoLearning?.enabled === false ||
+        config.autoLearning?.failureClassification?.enabled === false) {
+      process.exit(0);
+      return;
+    }
+
+    // Only check code files
+    if (!CODE_EXTENSIONS.test(filePath)) {
+      process.exit(0);
+      return;
+    }
+
+    // Skip incident/memory/doc files (those are pipeline output)
+    const root = getProjectRoot();
+    const incidentDir = config.autoLearning?.incidentDir ?? 'docs/incidents';
+    const memoryDir = config.autoLearning?.memoryDir ?? 'memory';
+    const relPath = filePath.startsWith(root + '/') ? filePath.slice(root.length + 1) : filePath;
+    if (relPath.startsWith(incidentDir) || relPath.includes(memoryDir) || relPath.includes('MEMORY.md')) {
+      process.exit(0);
+      return;
+    }
+
+    // Detect if this edit looks like a bug fix
+    const oldString = hookInput.tool_input?.old_string ?? '';
+    const newString = hookInput.tool_input?.new_string ?? '';
+    const content = hookInput.tool_input?.content ?? '';
+    const matchText = `${oldString} ${newString} ${content}`;
+
+    let isBugFix = false;
+
+    // Check for failure context markers (from UserPromptSubmit)
+    const promptContext = readFailureContextFiles();
+    if (promptContext) {
+      isBugFix = true;
+    }
+
+    // Check for bug fix indicators in the edit text
+    if (!isBugFix) {
+      for (const pattern of BUG_FIX_INDICATORS) {
+        if (pattern.test(matchText)) {
+          isBugFix = true;
+          break;
+        }
+      }
+    }
+
+    // Check for column/key name changes (common fix pattern)
+    if (!isBugFix && oldString && newString) {
+      const oldKeys = oldString.match(/[a-z_]+:/g)?.sort().join(',');
+      const newKeys = newString.match(/[a-z_]+:/g)?.sort().join(',');
+      if (oldKeys && newKeys && oldKeys !== newKeys) {
+        isBugFix = true;
+      }
+    }
+
+    if (!isBugFix) {
+      process.exit(0);
+      return;
+    }
+
+    // De-duplicate: skip if already reminded for this file today
+    const dedupeMarker = getDedupeMarkerPath(hookInput.session_id, filePath);
+    if (existsSync(dedupeMarker)) {
+      process.exit(0);
+      return;
+    }
+
+    // Mark that we've classified this file
+    try {
+      require('fs').writeFileSync(dedupeMarker, '1');
+    } catch { /* ignore */ }
+
+    // Score against failure taxonomy in database
+    const db = getMemoryDb();
+    try {
+      const scoringConfig = config.autoLearning?.failureClassification?.scoring;
+      const thresholds = config.autoLearning?.failureClassification?.thresholds ?? { known: 5, similar: 3 };
+      const bestMatch = scoreFailureClasses(db, matchText, filePath, promptContext, scoringConfig);
+
+      if (!bestMatch || bestMatch.score === 0) {
+        // No taxonomy entries yet, or no match — full enforcement
+        outputNewPattern(basename(filePath), bestMatch);
+      } else if (bestMatch.score >= thresholds.known) {
+        outputKnownPattern(bestMatch);
+      } else if (bestMatch.score >= thresholds.similar) {
+        outputSimilarPattern(bestMatch);
+      } else {
+        outputNewPattern(basename(filePath), bestMatch);
+      }
+    } finally {
+      db.close();
+    }
+
+    // Clean up consumed context files to prevent cross-bug contamination
+    cleanupFailureContextFiles();
+  } catch {
+    // Best-effort: never block Claude Code
+  }
+  process.exit(0);
+}
+
+function outputKnownPattern(match: FailureClassMatch): void {
+  const lines: string[] = [];
+  lines.push('');
+  lines.push(`[KNOWN PATTERN] ${match.name} (score: ${match.score}, ${match.incidentCount} prior incident(s))`);
+  if (match.knownMessage) {
+    lines.push(`  ${match.knownMessage}`);
+  }
+  if (match.rules.length > 0) {
+    lines.push(`  Covered by: ${match.rules.join(', ')}`);
+  }
+  lines.push('  No new rules needed. Reference existing incident if logging.');
+  console.log(lines.join('\n'));
+}
+
+function outputSimilarPattern(match: FailureClassMatch): void {
+  const lines: string[] = [];
+  lines.push('');
+  lines.push(`[POSSIBLE MATCH] Resembles ${match.name} (score: ${match.score})`);
+  if (match.rules.length > 0) {
+    lines.push(`  Check if existing rules cover this case: ${match.rules.join(', ')}`);
+  }
+  lines.push('  If genuinely new: create incident + prevention rule + enforcement.');
+  console.log(lines.join('\n'));
+}
+
+function outputNewPattern(fileName: string, match: FailureClassMatch | null): void {
+  const lines: string[] = [];
+  lines.push('');
+  if (match && match.score > 0) {
+    lines.push(`[NEW PATTERN] No known failure class matches this fix in ${fileName} (best: ${match.name}, score: ${match.score}).`);
+  } else {
+    lines.push(`[NEW PATTERN] Bug fix detected in ${fileName} — no failure classes in taxonomy yet.`);
+  }
+  lines.push('  Full incident loop required:');
+  lines.push('    1. INCIDENT REPORT');
+  lines.push('    2. PREVENTION RULE (if new failure pattern)');
+  lines.push('    3. ENFORCEMENT (hook or static check)');
+  console.log(lines.join('\n'));
+}
+
+interface FailureClassMatch {
+  name: string;
+  score: number;
+  incidentCount: number;
+  rules: string[];
+  knownMessage: string;
+}
+
+function readStdin(): Promise<string> {
+  return new Promise((resolve) => {
+    let data = '';
+    process.stdin.setEncoding('utf-8');
+    process.stdin.on('data', (chunk: string) => { data += chunk; });
+    process.stdin.on('end', () => resolve(data));
+    setTimeout(() => resolve(data), 3000);
+  });
+}
+
+main();

package/src/hooks/fix-detector.ts

@@ -0,0 +1,186 @@
+#!/usr/bin/env node
+// Copyright (c) 2026 Massu. All rights reserved.
+// Licensed under BSL 1.1 - see LICENSE file for details.
+
+// ============================================================
+// PostToolUse Hook: Fix Detector
+// Detects when a bug fix is being applied during a session by
+// analyzing git diffs of edited files. Sets session-level state
+// so the auto-learning pipeline can trigger at session end.
+//
+// Part of the Auto-Learning Pipeline:
+//   [Fix Detected] → Incident Report → Rule → Enforcement
+//
+// Must complete in <1000ms.
+// ============================================================
+
+import { execSync } from 'child_process';
+import { existsSync, appendFileSync, mkdirSync } from 'fs';
+import { tmpdir } from 'os';
+import { join } from 'path';
+import { getProjectRoot, getConfig } from '../config.ts';
+
+interface HookInput {
+  session_id: string;
+  tool_name: string;
+  tool_input: { file_path?: string };
+}
+
+interface FixSignal {
+  file: string;
+  signals: string[];
+  timestamp: string;
+}
+
+// Fix detection heuristics — each returns true if the pattern matches
+const FIX_HEURISTICS: Array<{ name: string; test: (diff: string) => boolean }> = [
+  {
+    name: 'removed_broken_code',
+    test: (diff) => /^-.*\b(bug|broken|wrong|incorrect|typo|crash|error|fail|miss|stale)\b/m.test(diff),
+  },
+  {
+    name: 'added_error_handling',
+    test: (diff) => {
+      const added = (diff.match(/^\+.*(try|except|catch|guard|if.*nil|if.*None|validate|assert|raise|throw)/gm) || []).length;
+      return added > 2;
+    },
+  },
+  {
+    name: 'method_name_correction',
+    test: (diff) => {
+      const removed = diff.match(/^-.*\.([a-z_]+)\(/m);
+      const added = diff.match(/^\+.*\.([a-z_]+)\(/m);
+      return !!(removed && added && removed[1] !== added[1]);
+    },
+  },
+  {
+    name: 'auth_fix',
+    test: (diff) => /^\+.*(token|auth|header|X-Service|Bearer|credential)/im.test(diff),
+  },
+  {
+    name: 'nil_handling_fix',
+    test: (diff) => /^\+.*(= nil|= None|\.isNil|is None|!= nil|is not None|guard let|if let|optional)/m.test(diff) && /^-/m.test(diff),
+  },
+  {
+    name: 'concurrency_fix',
+    test: (diff) => /^\+.*(timeout|semaphore|lock|mutex|throttle|rate.limit|max_conn)/im.test(diff),
+  },
+  {
+    name: 'async_pattern_fix',
+    test: (diff) => /^\+.*(@MainActor|async with|asyncio\.timeout|\.await)/.test(diff) && /^-/m.test(diff),
+  },
+  {
+    name: 'added_missing_import',
+    test: (diff) => /^\+.*(import|from.*import|require)/.test(diff) && !/^-.*(import|from.*import|require)/m.test(diff),
+  },
+];
+
+function getSessionFlagPath(sessionId: string): string {
+  const dir = join(tmpdir(), 'massu-auto-learning');
+  if (!existsSync(dir)) {
+    mkdirSync(dir, { recursive: true });
+  }
+  return join(dir, `fixes-${sessionId.slice(0, 12)}.jsonl`);
+}
+
+async function main(): Promise<void> {
+  try {
+    const input = await readStdin();
+    const hookInput = JSON.parse(input) as HookInput;
+    const filePath = hookInput.tool_input?.file_path;
+
+    if (!filePath || !existsSync(filePath)) {
+      process.exit(0);
+      return;
+    }
+
+    // Only check code files
+    if (!/\.(py|swift|ts|tsx|js|jsx|rs|go|rb|sh)$/.test(filePath)) {
+      process.exit(0);
+      return;
+    }
+
+    // Skip incident/memory/doc files (those ARE pipeline output)
+    const config = getConfig();
+    const incidentDir = config.autoLearning?.incidentDir ?? 'docs/incidents';
+    const memoryDir = config.autoLearning?.memoryDir ?? 'memory';
+    if (filePath.includes(incidentDir) || filePath.includes(memoryDir) || filePath.includes('MEMORY.md')) {
+      process.exit(0);
+      return;
+    }
+
+    // Check if auto-learning is enabled
+    if (config.autoLearning?.enabled === false || config.autoLearning?.fixDetection?.enabled === false) {
+      process.exit(0);
+      return;
+    }
+
+    // Get git diff for this file
+    const root = getProjectRoot();
+    let diff = '';
+    try {
+      diff = execSync(`git diff -- "${filePath}"`, { cwd: root, timeout: 3000, encoding: 'utf-8' });
+      if (!diff) {
+        diff = execSync(`git diff HEAD -- "${filePath}"`, { cwd: root, timeout: 3000, encoding: 'utf-8' });
+      }
+    } catch {
+      process.exit(0);
+      return;
+    }
+
+    if (!diff) {
+      process.exit(0);
+      return;
+    }
+
+    // Run fix detection heuristics
+    const enabledSignals = new Set(config.autoLearning?.fixDetection?.signals ?? FIX_HEURISTICS.map(h => h.name));
+    const detected: string[] = [];
+    for (const heuristic of FIX_HEURISTICS) {
+      if (enabledSignals.has(heuristic.name) && heuristic.test(diff)) {
+        detected.push(heuristic.name);
+      }
+    }
+
+    if (detected.length === 0) {
+      process.exit(0);
+      return;
+    }
+
+    // Record the fix detection
+    const signal: FixSignal = {
+      file: filePath,
+      signals: detected,
+      timestamp: new Date().toISOString(),
+    };
+
+    const flagPath = getSessionFlagPath(hookInput.session_id);
+    appendFileSync(flagPath, JSON.stringify(signal) + '\n');
+
+    // Count total fixes this session
+    const lines = require('fs').readFileSync(flagPath, 'utf-8').split('\n').filter(Boolean);
+    if (lines.length === 1) {
+      // First fix detected — output advisory
+      console.log(
+        `[Massu Auto-Learning] Bug fix detected in ${filePath} (signals: ${detected.join(', ')}). ` +
+        `The auto-learning pipeline will prompt you at session end to create an incident report, ` +
+        `derive a prevention rule, and add enforcement.`
+      );
+    }
+  } catch {
+    // Best-effort: never block Claude Code
+  }
+  process.exit(0);
+}
+
+function readStdin(): Promise<string> {
+  return new Promise((resolve) => {
+    let data = '';
+    process.stdin.setEncoding('utf-8');
+    process.stdin.on('data', (chunk: string) => { data += chunk; });
+    process.stdin.on('end', () => resolve(data));
+    setTimeout(() => resolve(data), 3000);
+  });
+}
+
+main();

package/src/hooks/incident-pipeline.ts

@@ -0,0 +1,190 @@
+#!/usr/bin/env node
+// Copyright (c) 2026 Massu. All rights reserved.
+// Licensed under BSL 1.1 - see LICENSE file for details.
+
+// ============================================================
+// PostToolUse Hook: Incident-to-Rule Pipeline
+// When a new incident report is written, automatically triggers
+// the next step: deriving a prevention rule.
+//
+// Part of the Auto-Learning Pipeline:
+//   Fix Detected → [Incident Report] → RULE DERIVATION → Enforcement
+//
+// Triggers on: Write to docs/incidents/*.md (configurable)
+// Must complete in <500ms.
+// ============================================================
+
+import { existsSync, readFileSync, readdirSync } from 'fs';
+import { basename, dirname, resolve } from 'path';
+import { getProjectRoot, getConfig } from '../config.ts';
+import { getMemoryDb, scoreFailureClasses, appendIncidentToFailureClass, addFailureClass } from '../memory-db.ts';
+
+interface HookInput {
+  session_id: string;
+  tool_name: string;
+  tool_input: { file_path?: string; content?: string };
+}
+
+async function main(): Promise<void> {
+  try {
+    const input = await readStdin();
+    const hookInput = JSON.parse(input) as HookInput;
+    const filePath = hookInput.tool_input?.file_path;
+
+    if (!filePath) {
+      process.exit(0);
+      return;
+    }
+
+    const config = getConfig();
+    if (config.autoLearning?.enabled === false) {
+      process.exit(0);
+      return;
+    }
+
+    const root = getProjectRoot();
+    const incidentDir = config.autoLearning?.incidentDir ?? 'docs/incidents';
+    const memoryDir = config.autoLearning?.memoryDir ?? 'memory';
+    // Only trigger on incident report files
+    const relPath = filePath.startsWith(root + '/') ? filePath.slice(root.length + 1) : filePath;
+    if (!relPath.startsWith(incidentDir) || !relPath.endsWith('.md')) {
+      process.exit(0);
+      return;
+    }
+
+    if (!existsSync(filePath)) {
+      process.exit(0);
+      return;
+    }
+
+    // Extract title from the incident report
+    const content = readFileSync(filePath, 'utf-8');
+    const titleMatch = content.match(/^#\s+(.+)/m);
+    const title = titleMatch?.[1] ?? basename(filePath, '.md');
+
+    // Check if a corresponding rule already exists
+    const slug = basename(filePath, '.md')
+      .replace(/^\d{4}-\d{2}-\d{2}-?/, '')
+      .toLowerCase();
+
+    const memoryDirAbs = resolve(root, memoryDir);
+    let hasExistingRule = false;
+    if (existsSync(memoryDirAbs)) {
+      const ruleFiles = readdirSync(memoryDirAbs).filter(f => f.startsWith('feedback_'));
+      for (const ruleFile of ruleFiles) {
+        if (ruleFile.toLowerCase().includes(slug.slice(0, 20))) {
+          hasExistingRule = true;
+          break;
+        }
+      }
+    }
+
+    if (hasExistingRule) {
+      // Rule already exists — no action needed
+      process.exit(0);
+      return;
+    }
+
+    // Check if incident has prevention rules section
+    const hasPrevention = /## Prevention Rules|## Prevention|## Rules/i.test(content);
+
+    if (config.autoLearning?.pipeline?.requirePreventionRule === false) {
+      process.exit(0);
+      return;
+    }
+
+    // Output rule derivation instructions
+    const lines: string[] = [];
+    lines.push('');
+    lines.push('============================================================================');
+    lines.push(' AUTO-LEARNING: Incident Report Created — Rule Derivation Required');
+    lines.push('============================================================================');
+    lines.push('');
+    lines.push(`  Incident: ${title}`);
+    lines.push(`  File: ${filePath}`);
+    lines.push('');
+
+    if (!hasPrevention) {
+      lines.push('  No "## Prevention Rules" section found in the incident report.');
+      lines.push('  Add one first, then proceed with rule derivation.');
+      lines.push('');
+    }
+
+    lines.push('  DERIVE A PREVENTION RULE:');
+    lines.push(`    a) Read the incident root cause and prevention rules`);
+    lines.push(`    b) Create: ${memoryDir}/feedback_<rule_name>.md`);
+    lines.push('       Template:');
+    lines.push('       ---');
+    lines.push('       name: <Rule Name>');
+    lines.push('       description: <one-line description>');
+    lines.push('       type: feedback');
+    lines.push('       ---');
+    lines.push('       <Rule statement>');
+    lines.push('       **Why:** <Root cause from incident>');
+    lines.push('       **How to apply:** <Concrete steps>');
+    lines.push('');
+    lines.push(`    c) Add one-line entry to ${config.autoLearning?.memoryIndexFile ?? 'MEMORY.md'}`);
+    lines.push('');
+    lines.push('  This step is MANDATORY per the auto-learning pipeline.');
+    lines.push('============================================================================');
+    lines.push('');
+
+    console.log(lines.join('\n'));
+
+    // ============================================================
+    // Taxonomy Update: Score incident against failure classes
+    // If KNOWN match → append incident to existing class
+    // If NEW → create stub entry with needs_review=true
+    // ============================================================
+    try {
+      const taxonomyConfig = config.autoLearning?.failureClassification;
+      if (taxonomyConfig?.enabled !== false) {
+        const db = getMemoryDb();
+        try {
+          const thresholds = taxonomyConfig?.thresholds ?? { known: 5, similar: 3 };
+          const scoringWeights = taxonomyConfig?.scoring;
+
+          // Extract incident number from filename (e.g., "incident-042.md" → "42")
+          const incidentNumMatch = basename(filePath, '.md').match(/(\d+)/);
+          const incidentId = incidentNumMatch ? incidentNumMatch[1] : basename(filePath, '.md');
+
+          // Score incident content against taxonomy
+          const bestMatch = scoreFailureClasses(db, content, filePath, title, scoringWeights);
+
+          if (bestMatch && bestMatch.score >= thresholds.similar) {
+            // Known or similar — append incident to existing class
+            appendIncidentToFailureClass(db, bestMatch.name, incidentId);
+          } else {
+            // New pattern — create stub entry for review
+            const stubName = `auto_${slug.replace(/[^a-z0-9_]/g, '_').slice(0, 50)}`;
+            addFailureClass(db, {
+              name: stubName,
+              description: `Auto-created from incident ${incidentId}: ${title.slice(0, 100)}`,
+              incidents: [incidentId],
+              needsReview: true,
+            });
+          }
+        } finally {
+          db.close();
+        }
+      }
+    } catch {
+      // Best-effort: taxonomy update failure must not block the pipeline
+    }
+  } catch {
+    // Best-effort: never block Claude Code
+  }
+  process.exit(0);
+}
+
+function readStdin(): Promise<string> {
+  return new Promise((resolve) => {
+    let data = '';
+    process.stdin.setEncoding('utf-8');
+    process.stdin.on('data', (chunk: string) => { data += chunk; });
+    process.stdin.on('end', () => resolve(data));
+    setTimeout(() => resolve(data), 3000);
+  });
+}
+
+main();