@pcircle/memesh 4.5.0 → 4.6.0

package/scripts/hooks/post-commit.js

@@ -1,13 +1,19 @@
 #!/usr/bin/env node
 
 import { execFileSync } from 'child_process';
-import { captureEntity, getProjectName, openHookDb } from './_shared.js';
+import { AUTO_CAPTURE_TAG, captureEntity, getProjectName, isAutoCaptureEnabled, openHookDb, recordHookRun, truncateTitle } from './_shared.js';
 
 let input = '';
 process.stdin.setEncoding('utf8');
 process.stdin.on('data', (chunk) => { input += chunk; });
 process.stdin.on('end', () => {
   try {
+    // Opt-out check (env > config > default-on). This hook skipped it for
+    // years while its two siblings honoured it — with capture disabled it
+    // kept writing commit entities AND stamping the heartbeat, which made
+    // doctor's "capture is off, hook silence is expected" message false.
+    if (!isAutoCaptureEnabled(process.env)) return exit0();
+
     const data = JSON.parse(input);
 
     // tool_name absent is a schema-flip signal (Claude Code has done
@@ -50,6 +56,20 @@ process.stdin.on('end', () => {
     const commitMatch = toolOutput.match(/\[[\w/.-]+(?: \([\w -]+\))? ([a-f0-9]{7,})\] (.+)/);
     if (!commitMatch) return exit0();
 
+    // The OUTPUT looking like a commit is not evidence that a commit happened.
+    // This hook stopped at the regex above, so any Bash output containing a
+    // commit-shaped line produced a permanent memory. Measured: a payload whose
+    // command was `cat docs/release-notes.md` wrote entity `commit-9f3c2a1`
+    // for a hash `git cat-file -t` rejects as "Not a valid object name".
+    // Reading a changelog, tailing a build log, or quoting a commit line was
+    // enough — and the fake then surfaced through session-start and
+    // pre-edit-recall as if it had happened.
+    const issuedCommand = typeof data.tool_input?.command === 'string' ? data.tool_input.command : '';
+    if (!/\bgit\b[^|;&]*\bcommit\b/.test(issuedCommand)) {
+      try { process.stderr.write(`[memesh post-commit] output looks like a commit but the command was not a git commit; skipping ${commitMatch[1]}\n`); } catch {}
+      return exit0();
+    }
+
     const branchMatch = commitMatch[0].match(/^\[([^\s]+)\s/);
     const branch = branchMatch ? branchMatch[1] : 'unknown';
 
@@ -66,17 +86,28 @@ process.stdin.on('end', () => {
       try { process.stderr.write(`[memesh post-commit] data.cwd absent — cannot resolve project / repo; skipping commit ${commitHash}\n`); } catch {}
       return exit0();
     }
+    // And the commit has to actually be in THIS repository.
+    //
+    // `cat-file -e <hash>^{commit}` answers exactly one question — does this
+    // resolve to a commit object here — in milliseconds, before anything is
+    // written. Deliberately separate from the `git show` below, whose failure
+    // (git absent, timeout on a huge diff) says nothing about the commit and
+    // must NOT veto.
+    try {
+      execFileSync('git', ['-C', data.cwd, 'cat-file', '-e', `${commitHash}^{commit}`], {
+        timeout: 5000,
+        stdio: ['ignore', 'ignore', 'pipe'],
+      });
+    } catch {
+      try { process.stderr.write(`[memesh post-commit] ${commitHash} is not a commit in ${data.cwd}; nothing written\n`); } catch {}
+      return exit0();
+    }
+
     const projectName = getProjectName(data.cwd);
 
     // Open DB via shared helper — applies SCHEMA_SQL + status migration.
     // Pass fts:true so the FTS5 entity-search index is also available.
-    // Returns null when the better-sqlite3 native module is unavailable
-    // (e.g. plugin-marketplace cache install with no node_modules); in
-    // that case silently skip — a sibling registered hook copy with
-    // proper deps still records the commit.
-    const handle = openHookDb(process.env, { fts: true });
-    if (!handle) return;
-    const { db } = handle;
+    const { db } = openHookDb(process.env, { fts: true });
     try {
       const entityName = `commit-${commitHash}`;
 
@@ -103,12 +134,26 @@ process.stdin.on('end', () => {
       }
 
       // Shared write dance — upsert entity + observations + tags AND reindex FTS.
-      captureEntity(db, {
+      //
+      // `source:auto-capture` is the provenance marker every capture hook
+      // writes (session-summary, pre-compact and the extractor already did;
+      // this one did not). `memesh doctor` counts it to answer "is the
+      // auto-capture loop alive" — a question it used to answer from entity
+      // TYPE, which a hand-typed `memesh learn` satisfied all by itself.
+      // The commit subject IS the title — git authors already wrote a
+      // one-line human summary; nothing to synthesize.
+      const written = captureEntity(db, {
         name: entityName,
         type: 'commit',
         observations,
-        tags: [`project:${projectName}`],
+        tags: [AUTO_CAPTURE_TAG, `project:${projectName}`],
+        title: truncateTitle(commitMsg),
       });
+
+      // Heartbeat AFTER capture, so the stamp certifies "the capture loop
+      // completed", not "a database handle existed". A throw above skips it,
+      // and so does a null return (the write did not land).
+      if (written) recordHookRun(db, 'post-commit');
     } finally {
       db.close();
     }

package/scripts/hooks/pre-compact.js

@@ -2,7 +2,7 @@
 
 import { basename } from 'path';
 import { existsSync, readFileSync } from 'fs';
-import { captureEntity, getProjectName, isAutoCaptureEnabled, openHookDb } from './_shared.js';
+import { AUTO_CAPTURE_TAG, captureEntity, getProjectName, isAutoCaptureEnabled, openHookDb, recordHookRun, truncateTitle } from './_shared.js';
 
 // Timeout guard: always exit within 10 seconds
 const TIMEOUT_MS = 10000;
@@ -95,17 +95,24 @@ process.stdin.on('end', () => {
 
     // Build observation content
     const obsLines = [`Compaction reason: ${reason}`, `Tool calls: ${toolCallCount}`];
+
+    // No free-form human text exists for a pre-compact save (unlike a commit
+    // subject) — same date+project+verb heuristic as session-summary.js.
+    // This hook was the one missed by the original design (it hand-rolls the
+    // same captureEntity dance as its two siblings but was overlooked as a
+    // "write hook" until a code audit found it), so its entities were the
+    // clearest case of a raw machine key (`pre-compact-<sessionId>`) with a
+    // terse observation ("Compaction reason: manual") standing in as the
+    // display label.
+    const titleDate = new Date().toISOString().slice(0, 10);
+    const title = truncateTitle(`${titleDate} ${projectName}: ${reason} compaction (${toolCallCount} tool calls)`);
     if (editedFiles.size > 0) {
       obsLines.push(`Files edited: ${Array.from(editedFiles).join(', ')}`);
     }
 
     // Open DB via shared helper — applies SCHEMA_SQL + status migration.
     // FTS5 needed for the entity-search index updates below.
-    // Returns null on plugin-marketplace cache installs without node_modules;
-    // silently skip in that case (sibling registered copy handles it).
-    const handle = openHookDb(process.env, { fts: true });
-    if (!handle) return;
-    const { db } = handle;
+    const { db } = openHookDb(process.env, { fts: true });
     let written = null;
     try {
       // Shared write dance — upsert entity + observations + tags AND reindex FTS
@@ -114,8 +121,16 @@ process.stdin.on('end', () => {
         name: entityName,
         type: 'session-summary',
         observations: obsLines,
-        tags: ['source:auto-capture', 'urgency:pre-compact', `project:${projectName}`],
+        tags: [AUTO_CAPTURE_TAG, 'urgency:pre-compact', `project:${projectName}`],
+        title,
       });
+
+      // Heartbeat AFTER capture, so the stamp certifies "the capture loop
+      // completed", not "a database handle existed". A throw above skips it,
+      // and so does a null return — captureEntity's null means the write did
+      // not land, and this very hook tells the user "could not save" below;
+      // stamping would say "alive" to doctor about the same failed run.
+      if (written) recordHookRun(db, 'pre-compact');
     } finally {
       db.close();
     }

package/scripts/hooks/pre-edit-recall.js

@@ -13,10 +13,10 @@ import {
   getMemeshDirFromDbPath,
   getProjectName,
   isTrustedForAutoContext,
-  tryRequireBetterSqlite,
   writePrivateJson,
   hookMatchExpression,
 } from './_shared.js';
+import { MemeshDatabase } from './_generated/sqlite.js';
 
 const dbPath = getDbPath();
 const memeshDir = getMemeshDirFromDbPath();
@@ -43,9 +43,6 @@ process.stdin.on('end', () => {
       return pass();
     }
 
-    // Get project name from cwd for project-scoped filtering
-    const projectName = getProjectName(data.cwd);
-
     // Throttle: skip if we already recalled for this file
     const fileKey = filePath.toLowerCase();
     let seenFiles = [];
@@ -64,13 +61,14 @@ process.stdin.on('end', () => {
 
     if (!existsSync(dbPath)) return pass();
 
-    // tryRequireBetterSqlite() returns null on plugin-marketplace cache
-    // installs that ship without node_modules; pass-through silently in
-    // that case so a sibling registered hook copy can still inject
-    // recall context.
-    const Database = tryRequireBetterSqlite();
-    if (!Database) return pass();
-    const db = new Database(dbPath, { readonly: true });
+    // Get project name from cwd for project-scoped filtering.
+    // After the throttle/db checks: this spawns 1-2 git subprocesses, and the
+    // throttled path (every repeat edit of the same file) must not pay for it.
+    const projectName = getProjectName(data.cwd);
+
+    // `readOnly`, not `readonly`: node:sqlite ignores the lowercase spelling
+    // and hands back a WRITABLE handle. This hook only reads.
+    const db = new MemeshDatabase(dbPath, { readOnly: true });
     try {
 
       // Check if entities table exists