@massu/core 1.9.3 → 1.10.0

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

@@ -16,12 +16,18 @@
 // the pipeline steps.
 // ============================================================
 
-import { execSync } from 'child_process';
+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;
@@ -67,19 +73,46 @@ async function main(): Promise<void> {
       } catch { /* ignore parse errors */ }
     }
 
-    // Source 2: Scan uncommitted git diff for fix patterns (language-agnostic)
+    // 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 diff = execSync('git diff --name-only', { cwd: root, timeout: 3000, encoding: 'utf-8' });
-      if (diff.trim()) {
-        const fullDiff = execSync('git diff', { cwd: root, timeout: 5000, encoding: 'utf-8' });
-        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;
+      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 */ }
+    } catch { /* git not available or no changes or buffer overflow */ }
 
     if (sessionFixes.length === 0 && !uncommittedFix) {
       // Clean up flag file

package/src/hooks/fix-detector.ts

@@ -14,7 +14,7 @@
 // Must complete in <1000ms.
 // ============================================================
 
-import { execSync } from 'child_process';
+import { execFileSync } from 'child_process';
 import { existsSync, appendFileSync, mkdirSync, readFileSync } from 'fs';
 import { tmpdir } from 'os';
 import { join } from 'path';
@@ -119,9 +119,9 @@ async function main(): Promise<void> {
     const root = getProjectRoot();
     let diff = '';
     try {
-      diff = execSync(`git diff -- "${filePath}"`, { cwd: root, timeout: 3000, encoding: 'utf-8' });
+      diff = execFileSync('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' });
+        diff = execFileSync('git', ['diff', 'HEAD', '--', filePath], { cwd: root, timeout: 3000, encoding: 'utf-8' });
       }
     } catch {
       process.exit(0);

package/src/hooks/post-tool-use.ts

@@ -11,7 +11,7 @@
 import { getMemoryDb, addObservation, createSession, deduplicateFailedAttempt, addSummary } from '../memory-db.ts';
 import { classifyRealTimeToolCall, detectPlanProgress } from '../observation-extractor.ts';
 import { logAuditEntry } from '../audit-trail.ts';
-import { trackModification } from '../regression-detector.ts';
+import { trackModification, recordTestResult } from '../regression-detector.ts';
 import { validateFile, storeValidationResult } from '../validation-engine.ts';
 import { scoreFileSecurity, storeSecurityScore } from '../security-scorer.ts';
 import { readFileSync, existsSync } from 'fs';
@@ -131,6 +131,42 @@ async function main(): Promise<void> {
         // Best-effort: never block post-tool-use
       }
 
+      // P-H029 (plan-stage-c-high-batch): wire recordTestResult() into the
+      // post-tool-use hook so `feature_health` dashboard reflects real test
+      // deltas. Pre-fix: `trackModification` fired but `recordTestResult` was
+      // unit-tested yet never called; dashboard showed tests_passing=0 for
+      // every feature.
+      //
+      // Strategy: when a Bash tool call runs a test runner AND the output
+      // includes parseable pass/fail counts, call recordTestResult for every
+      // feature with `modifications_since_test > 0`. This resets their counter
+      // and updates pass/fail tallies based on the run.
+      try {
+        if (tool_name === 'Bash') {
+          const command = (tool_input.command as string) ?? '';
+          if (isTestRunnerCommand(command)) {
+            const counts = parseTestRunOutput(tool_response ?? '');
+            if (counts) {
+              const modifiedFeatures = db
+                .prepare(
+                  'SELECT feature_key FROM feature_health WHERE modifications_since_test > 0',
+                )
+                .all() as Array<{ feature_key: string }>;
+              for (const row of modifiedFeatures) {
+                recordTestResult(db, row.feature_key, counts.passing, counts.failing);
+              }
+              // Also record a session-level aggregate so the dashboard has at
+              // least one row even when no features were modified.
+              if (modifiedFeatures.length === 0) {
+                recordTestResult(db, '_session_test_run', counts.passing, counts.failing);
+              }
+            }
+          }
+        }
+      } catch (_testResultErr) {
+        // Best-effort: never block post-tool-use
+      }
+
       // MEMORY.md integrity check on write
       try {
         if (tool_name === 'Edit' || tool_name === 'Write') {
@@ -217,6 +253,60 @@ function updatePlanProgress(db: import('better-sqlite3').Database, sessionId: st
   }
 }
 
+/**
+ * P-H029: Detect test-runner commands. Conservative match — only commands that
+ * START with a recognized test runner so a build script invoking `npm run test`
+ * is included but a script that merely mentions "test" in a filename is not.
+ */
+function isTestRunnerCommand(command: string): boolean {
+  const trimmed = command.trim().toLowerCase();
+  // Strip leading `cd <dir> && ` or `(cd <dir> && ...)` prefix so we match
+  // the actual test command.
+  const stripped = trimmed
+    .replace(/^cd\s+\S+\s*(&&|;)\s*/, '')
+    .replace(/^\(\s*cd\s+\S+\s*(&&|;)\s*/, '');
+  const testRunnerPrefixes = [
+    'npm test', 'npm run test', 'npx vitest', 'npx jest', 'vitest', 'jest',
+    'pnpm test', 'pnpm run test', 'yarn test', 'pytest', 'go test', 'cargo test',
+  ];
+  return testRunnerPrefixes.some((prefix) => stripped.startsWith(prefix));
+}
+
+/**
+ * P-H029: Parse test-run output for pass/fail counts. Supports vitest
+ * (`Tests  N passed (N)`, `Tests  X failed | Y passed (Z)`), jest
+ * (`Tests: X failed, Y passed, Z total`), and pytest (`X passed, Y failed`).
+ * Returns null if no parseable summary line found.
+ */
+function parseTestRunOutput(output: string): { passing: number; failing: number } | null {
+  // vitest: " Tests  439 passed (439)" or " Tests  3 failed | 436 passed (439)"
+  const vitestSplit = output.match(/Tests?\s+(?:(\d+)\s+failed\s+\|\s+)?(\d+)\s+passed/);
+  if (vitestSplit) {
+    return {
+      passing: parseInt(vitestSplit[2], 10),
+      failing: vitestSplit[1] ? parseInt(vitestSplit[1], 10) : 0,
+    };
+  }
+  // jest: "Tests:       1 failed, 5 passed, 6 total"
+  const jest = output.match(/Tests?:\s+(?:(\d+)\s+failed,\s+)?(\d+)\s+passed/);
+  if (jest) {
+    return {
+      passing: parseInt(jest[2], 10),
+      failing: jest[1] ? parseInt(jest[1], 10) : 0,
+    };
+  }
+  // pytest: "5 passed, 2 failed in 1.23s" or "5 passed in 1.23s"
+  const pytestPassed = output.match(/(\d+)\s+passed/);
+  const pytestFailed = output.match(/(\d+)\s+failed/);
+  if (pytestPassed) {
+    return {
+      passing: parseInt(pytestPassed[1], 10),
+      failing: pytestFailed ? parseInt(pytestFailed[1], 10) : 0,
+    };
+  }
+  return null;
+}
+
 function readStdin(): Promise<string> {
   return new Promise((resolve) => {
     let data = '';

package/src/lib/hook-registry.ts

@@ -0,0 +1,43 @@
+/**
+ * Single source of truth for the canonical Massu hook set.
+ *
+ * P-H001 (plan-stage-c-high-batch): doctor / installer / build:hooks all
+ * consume from here. The drift-guard `hook-registry-parity.test.ts` asserts:
+ *
+ *   1. REGISTERED_HOOKS matches `src/hooks/*.ts` filenames (the build SoT).
+ *   2. REGISTERED_HOOKS matches the hook names referenced in
+ *      `buildHooksConfig()` (the installer SoT).
+ *   3. REGISTERED_HOOKS matches `dist/hooks/*.js` after `npm run build:hooks`
+ *      (the runtime SoT, when build artifacts are available).
+ *
+ * Adding a new hook requires touching THREE places: src/hooks/X.ts,
+ * REGISTERED_HOOKS, and buildHooksConfig() — the parity tests enforce this.
+ */
+export const REGISTERED_HOOKS = [
+  'auto-learning-pipeline',
+  'classify-failure',
+  'cost-tracker',
+  'fix-detector',
+  'incident-pipeline',
+  'intent-suggester',
+  'post-edit-context',
+  'post-tool-use',
+  'pre-compact',
+  'pre-delete-check',
+  'quality-event',
+  'rule-enforcement-pipeline',
+  'security-gate',
+  'session-end',
+  'session-start',
+  'user-prompt',
+] as const;
+
+export type RegisteredHook = (typeof REGISTERED_HOOKS)[number];
+
+export function getExpectedHookFiles(): readonly string[] {
+  return REGISTERED_HOOKS.map((name) => `${name}.js`);
+}
+
+export function getRegisteredHookCount(): number {
+  return REGISTERED_HOOKS.length;
+}

package/src/lib/memory-path.ts

@@ -0,0 +1,49 @@
+// Copyright (c) 2026 Massu. All rights reserved.
+// Licensed under BSL 1.1 - see LICENSE file for details.
+
+/**
+ * Memory directory name encoding — canonical helpers.
+ *
+ * Single source of truth for translating a project's absolute filesystem
+ * root into the directory name used under `~/.claude/projects/<encoded-root>/memory/`.
+ *
+ * Closes the P-004 install-path drift class: the writer in `commands/init.ts`
+ * historically prepended an EXTRA leading `-` while the reader in
+ * `config.ts:getResolvedPaths()` and the backfill code path used the
+ * canonical single-dash form. Result: 100% of `massu init` runs orphaned
+ * `MEMORY.md` in a directory the reader could never find.
+ *
+ * Both encoding and decoding live here so the round-trip property is testable.
+ *
+ * Encoding rule:
+ *   Replace every `/` in the absolute project root with `-`.
+ *   An absolute path always starts with `/`, so the result always starts with
+ *   `-` exactly once. NEVER prepend an additional `-`.
+ *
+ * Decoding rule:
+ *   Replace every `-` in the directory name with `/`. This is the canonical
+ *   inverse used by Claude Code's session-state plumbing. Note: project roots
+ *   that contain literal `-` characters cannot be unambiguously round-tripped
+ *   through this encoding — the same trade-off Claude Code's own resolver makes.
+ */
+
+/**
+ * Encode an absolute project root into the directory name used under
+ * `~/.claude/projects/<dir>/memory/`.
+ *
+ * @param projectRoot Absolute filesystem path (must start with `/`).
+ * @returns Canonical encoded directory name (always begins with `-`).
+ */
+export function encodeMemoryDirName(projectRoot: string): string {
+  return projectRoot.replace(/\//g, '-');
+}
+
+/**
+ * Decode a memory-directory name back to its slash-separated form.
+ *
+ * @param dirname The directory name as it appears under `~/.claude/projects/`.
+ * @returns A slash-separated path (begins with `/`).
+ */
+export function decodeMemoryDirName(dirname: string): string {
+  return dirname.replace(/-/g, '/');
+}

package/src/security/registry-pubkey.generated.ts

@@ -1,4 +1,4 @@
-// AUTO-GENERATED by scripts/bundle-pubkey.mjs at 2026-05-16T02:54:04.271Z.
+// AUTO-GENERATED by scripts/bundle-pubkey.mjs at 2026-05-17T04:53:58.787Z.
 // Source pem: packages/core/security/registry-pubkey.pem
 // RAW-bytes sha256: 3b6226d036c472e533110d11a7d0cd2773ce1d7d4f1003517d5bd69c5418ed4c
 // DO NOT EDIT — regenerate via `node scripts/bundle-pubkey.mjs` or

package/src/tool-db-needs.ts

@@ -70,8 +70,14 @@ export const TOOL_DB_NEEDS = {
   impact: ['codegraph', 'data'],
   domains: ['codegraph', 'data'],
 
-  // `trpc_map` reads only Data DB (tRPC index lives there); no CodeGraph access.
-  trpc_map: ['data'],
+  // P-H009 (plan-stage-c-high-batch): `trpc_map` queries Data DB tables
+  // populated by `ensureIndexes(d, codegraphDb)` — without CodeGraph the
+  // index never builds and the flagship code-intel tool silently returns
+  // "0 procedures" on fresh installs. Declaring `codegraph` here makes the
+  // dispatcher open the CodeGraph DB so `buildTrpcIndex` can run; the
+  // handler also surfaces an actionable hint when no procedures + no
+  // codegraph (covered by `trpc-map-empty-codegraph-hint.test.ts`).
+  trpc_map: ['codegraph', 'data'],
 
   // `schema` reads filesystem (Prisma schema files); no DB access at all.
   schema: [],

package/src/tools.ts

@@ -858,13 +858,29 @@ function handleTrpcMap(args: Record<string, unknown>, dataDb: Database.Database)
     const coupled = dataDb.prepare('SELECT COUNT(*) as count FROM massu_trpc_procedures WHERE has_ui_caller = 1').get() as { count: number };
     const uncoupled = total.count - coupled.count;
 
-    lines.push('## tRPC Procedure Summary');
-    lines.push(`- Total procedures: ${total.count}`);
-    lines.push(`- With UI callers: ${coupled.count}`);
-    lines.push(`- Without UI callers: ${uncoupled}`);
-    lines.push('');
-    lines.push('Use { router: "name" } to see details for a specific router.');
-    lines.push('Use { uncoupled: true } to see all procedures without UI callers.');
+    // P-H009 (plan-stage-c-high-batch): when the index is empty, return an
+    // actionable remedy hint instead of bare "0" — previously fresh installs
+    // saw "Total procedures: 0" and assumed the flagship tool was broken.
+    if (total.count === 0) {
+      lines.push('## tRPC Index Empty');
+      lines.push('');
+      lines.push('No tRPC procedures indexed yet. Either this repo has no tRPC');
+      lines.push('routers, or the CodeGraph index has not been built. To rebuild:');
+      lines.push('');
+      lines.push('  npx massu sync');
+      lines.push('');
+      lines.push('If `massu sync` completes successfully but `trpc_map` still');
+      lines.push('returns 0, the repo likely has no tRPC procedures (this is');
+      lines.push('expected for non-tRPC stacks — try `schema` or `domains` tools).');
+    } else {
+      lines.push('## tRPC Procedure Summary');
+      lines.push(`- Total procedures: ${total.count}`);
+      lines.push(`- With UI callers: ${coupled.count}`);
+      lines.push(`- Without UI callers: ${uncoupled}`);
+      lines.push('');
+      lines.push('Use { router: "name" } to see details for a specific router.');
+      lines.push('Use { uncoupled: true } to see all procedures without UI callers.');
+    }
   }
 
   return text(lines.join('\n'));