@massu/core 1.10.8 → 1.12.0

package/src/hooks/auto-learning-pipeline.ts

@@ -1,228 +0,0 @@
-#!/usr/bin/env node
-// Copyright (c) 2026 Massu. All rights reserved.
-// Licensed under BSL 1.1 - see LICENSE file for details.
-
-// ============================================================
-// Stop Hook: Auto-Learning Pipeline Enforcer
-// At session end, checks if bug fixes were applied without
-// completing the full incident → rule → enforcement pipeline.
-// Outputs mandatory instructions for Claude to follow.
-//
-// Part of the Auto-Learning Pipeline:
-//   Fix Detected → [SESSION END CHECK] → Pipeline Instructions
-//
-// This is the FORCING FUNCTION that ensures no fix goes
-// undocumented. Claude cannot end the session without completing
-// the pipeline steps.
-// ============================================================
-
-import { execFileSync } from 'child_process';
-import { existsSync, readFileSync, unlinkSync, readdirSync, statSync } from 'fs';
-import { tmpdir } from 'os';
-import { join } from 'path';
-import { getProjectRoot, getConfig } from '../config.ts';
-
-// P-H002 (plan-stage-c-high-batch): bound git-diff reads so monorepos with
-// 10MB+ working trees don't trigger Stop-hook timeout. Short-stat first,
-// only read full diff body when estimated bytes <= cap. execFileSync argv
-// form is defense-in-depth (P-001 pattern).
-const MAX_FULL_DIFF_BYTES = 2 * 1024 * 1024; // 2MB; ~25k lines at 80 bytes/line
-
-interface HookInput {
-  session_id: string;
-  transcript_path: string;
-  cwd: string;
-}
-
-interface FixSignal {
-  file: string;
-  signals: string[];
-  timestamp: string;
-}
-
-function getSessionFlagPath(sessionId: string): string {
-  return join(tmpdir(), 'massu-auto-learning', `fixes-${sessionId.slice(0, 12)}.jsonl`);
-}
-
-async function main(): Promise<void> {
-  try {
-    const input = await readStdin();
-    const hookInput = JSON.parse(input) as HookInput;
-    const config = getConfig();
-
-    // Check if auto-learning is enabled
-    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';
-    const autoLearn = config.autoLearning;
-
-    // Source 1: Session fix flags from fix-detector
-    const flagPath = getSessionFlagPath(hookInput.session_id);
-    let sessionFixes: FixSignal[] = [];
-    if (existsSync(flagPath)) {
-      try {
-        sessionFixes = readFileSync(flagPath, 'utf-8')
-          .split('\n')
-          .filter(Boolean)
-          .map(line => JSON.parse(line) as FixSignal);
-      } catch { /* ignore parse errors */ }
-    }
-
-    // Source 2: Scan uncommitted git diff for fix patterns (language-agnostic).
-    // Two-stage: (1) name-only to confirm any changes, (2) shortstat to estimate
-    // bytes, (3) full diff body ONLY if estimate <= MAX_FULL_DIFF_BYTES.
-    let uncommittedFix = false;
-    try {
-      const nameOnly = execFileSync('git', ['diff', '--name-only'], {
-        cwd: root,
-        timeout: 3000,
-        encoding: 'utf-8',
-        maxBuffer: 1024 * 1024,
-      });
-      if (nameOnly.trim()) {
-        const shortstat = execFileSync('git', ['diff', '--shortstat'], {
-          cwd: root,
-          timeout: 2000,
-          encoding: 'utf-8',
-          maxBuffer: 64 * 1024,
-        });
-        const insertions = parseInt(shortstat.match(/(\d+) insertion/)?.[1] ?? '0', 10);
-        const deletions = parseInt(shortstat.match(/(\d+) deletion/)?.[1] ?? '0', 10);
-        const estimatedBytes = (insertions + deletions) * 80; // ~80 bytes/line avg
-        if (estimatedBytes <= MAX_FULL_DIFF_BYTES) {
-          const fullDiff = execFileSync('git', ['diff'], {
-            cwd: root,
-            timeout: 5000,
-            encoding: 'utf-8',
-            maxBuffer: MAX_FULL_DIFF_BYTES,
-          });
-          const fixPatterns = (fullDiff.match(/^\+.*(try|except|catch|guard|throw|raise|assert|validate|if.*null|if.*nil|if.*None|if.*undefined)/gm) || []).length;
-          const removedBroken = (fullDiff.match(/^-.*(bug|broken|crash|wrong|incorrect|typo|fail|error|miss|stale)/gm) || []).length;
-          if (fixPatterns > 3 || removedBroken > 1) {
-            uncommittedFix = true;
-          }
-        }
-        // else: diff exceeds cap — skip pattern scan rather than risk timeout.
-        // The fix-detector hook fires on per-Edit/Write and already populates
-        // sessionFixes for the realistic case; full-diff fallback is a safety
-        // net that we can correctly skip for huge trees.
-      }
-    } catch { /* git not available or no changes or buffer overflow */ }
-
-    if (sessionFixes.length === 0 && !uncommittedFix) {
-      // Clean up flag file
-      cleanup(flagPath);
-      process.exit(0);
-      return;
-    }
-
-    // Build pipeline instructions
-    const lines: string[] = [];
-    lines.push('');
-    lines.push('============================================================================');
-    lines.push(' MASSU AUTO-LEARNING PIPELINE — ACTION REQUIRED BEFORE SESSION END');
-    lines.push('============================================================================');
-
-    if (sessionFixes.length > 0) {
-      lines.push('');
-      lines.push(`  ${sessionFixes.length} bug fix(es) detected during this session:`);
-      lines.push('');
-      // Deduplicate by file
-      const byFile = new Map<string, string[]>();
-      for (const fix of sessionFixes) {
-        const existing = byFile.get(fix.file) ?? [];
-        existing.push(...fix.signals);
-        byFile.set(fix.file, [...new Set(existing)]);
-      }
-      for (const [file, signals] of byFile) {
-        lines.push(`    - ${file} (${signals.join(', ')})`);
-      }
-    }
-
-    if (uncommittedFix) {
-      lines.push('');
-      lines.push('  Additional uncommitted fix patterns detected in git diff.');
-    }
-
-    lines.push('');
-    lines.push('  Complete these steps before this session ends:');
-    lines.push('');
-
-    if (autoLearn?.pipeline?.requireIncidentReport !== false) {
-      lines.push('  STEP 1: INCIDENT REPORT');
-      lines.push(`    For each distinct bug fixed, create: ${incidentDir}/YYYY-MM-DD-<slug>.md`);
-      lines.push('    Include: Date, Severity, Symptoms, Root Cause, Fix, Files Changed, Prevention Rules');
-      lines.push('');
-    }
-
-    if (autoLearn?.pipeline?.requirePreventionRule !== false) {
-      lines.push('  STEP 2: PREVENTION RULE');
-      lines.push(`    For each incident, create: ${memoryDir}/feedback_<rule_name>.md`);
-      lines.push('    Include frontmatter (name, description, type: feedback) + Why + How to apply');
-      lines.push(`    Update ${config.autoLearning?.memoryIndexFile ?? 'MEMORY.md'} index`);
-      lines.push('');
-    }
-
-    if (autoLearn?.pipeline?.requireEnforcement !== false) {
-      lines.push('  STEP 3: ENFORCEMENT PLACEMENT');
-      lines.push('    For each new rule, determine enforcement layer(s):');
-      lines.push('    a) If statically detectable → add to pattern-feedback hook');
-      lines.push('    b) If about editing certain files → add to blast-radius hook');
-      lines.push('    c) If about dangerous commands → add to dangerous-command hook');
-      lines.push('    d) If critical → add to pre-commit hook');
-      lines.push('    e) If needs runtime monitoring → create monitoring producer');
-      lines.push('');
-    }
-
-    lines.push('  STEP 4: VERIFY');
-    lines.push('    Test any new enforcement hooks to confirm they detect violations.');
-    lines.push('');
-    lines.push('============================================================================');
-    lines.push('');
-
-    console.log(lines.join('\n'));
-
-    // Clean up flag file
-    cleanup(flagPath);
-  } catch {
-    // Best-effort: never block Claude Code
-  }
-  process.exit(0);
-}
-
-function cleanup(flagPath: string): void {
-  try {
-    if (existsSync(flagPath)) unlinkSync(flagPath);
-    // Clean up old flag files (>24h)
-    const dir = join(tmpdir(), 'massu-auto-learning');
-    if (existsSync(dir)) {
-      const now = Date.now();
-      for (const file of readdirSync(dir)) {
-        const fullPath = join(dir, file);
-        try {
-          const stat = statSync(fullPath);
-          if (now - stat.mtimeMs > 86400000) {
-            unlinkSync(fullPath);
-          }
-        } catch { /* ignore */ }
-      }
-    }
-  } catch { /* best effort */ }
-}
-
-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), 5000);
-  });
-}
-
-main();

package/src/hooks/classify-failure.ts

@@ -1,259 +0,0 @@
-#!/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, writeFileSync } 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 {
-      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/cost-tracker.ts

@@ -1,66 +0,0 @@
-#!/usr/bin/env node
-// Copyright (c) 2026 Massu. All rights reserved.
-// Licensed under BSL 1.1 - see LICENSE file for details.
-
-// ============================================================
-// PostToolUse Hook: Cost Tracker
-// Estimates token usage from tool input/output sizes and
-// records cost events for per-session cost intelligence.
-// Must complete in <500ms.
-// ============================================================
-
-import { getMemoryDb } from '../memory-db.ts';
-
-interface HookInput {
-  session_id: string;
-  transcript_path: string;
-  cwd: string;
-  hook_event_name: string;
-  tool_name: string;
-  tool_input: Record<string, unknown>;
-  tool_response: string;
-}
-
-// Approximate: 4 characters per token (industry rule of thumb)
-const CHARS_PER_TOKEN = 4;
-
-function estimateTokens(text: string): number {
-  return Math.ceil(text.length / CHARS_PER_TOKEN);
-}
-
-async function main(): Promise<void> {
-  try {
-    const input = await readStdin();
-    const hookInput = JSON.parse(input) as HookInput;
-    const { session_id, tool_name, tool_input, tool_response } = hookInput;
-
-    const inputStr = JSON.stringify(tool_input);
-    const estimatedInputTokens = estimateTokens(inputStr);
-    const estimatedOutputTokens = estimateTokens(tool_response ?? '');
-
-    const db = getMemoryDb();
-    try {
-      db.prepare(`
-        INSERT INTO tool_cost_events (session_id, tool_name, estimated_input_tokens, estimated_output_tokens, model)
-        VALUES (?, ?, ?, ?, ?)
-      `).run(session_id, tool_name, estimatedInputTokens, estimatedOutputTokens, '');
-    } finally {
-      db.close();
-    }
-  } catch (_e) {
-    // 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();