@hanzlaa/rcode 4.4.4 → 4.6.0

package/rcode/bin/rcode-hooks.cjs

@@ -14,6 +14,8 @@
  *   compact-nudge — advise /rcode-trim or /clear after N Edit/Write calls (#749)
  *   pre-tool-use  — stderr warning before large file reads to avoid context bloat (#749)
  *   prompt-router — nudge toward rcode commands for memory consistency (#892)
+ *   session-start — emit one-line project status primer at session open (#947)
+ *   drift         — print the full memory-drift report (#958)
  *
  * All subcommands read stdin JSON from the hook execution context.
  * Pure Node stdlib. No external dependencies.
@@ -24,6 +26,54 @@ const os = require('os');
 const path = require('path');
 const { execSync, spawnSync } = require('child_process');
 
+/**
+ * Self-healing lib require (#960). When this file runs from an installed
+ * `.rcode/bin/` whose `lib/` is stale or partial (fresh git worktree, merge/
+ * pull that changed `rcode/bin/lib/` without a mirror sync), a hard require
+ * crashes EVERY hook — the user sees a SessionStart loader error and loses
+ * the status line entirely. Instead: on MODULE_NOT_FOUND, try healing from
+ * the in-repo source of truth (`rcode/bin/lib/<name>` relative to the project
+ * root that contains this `.rcode/`), retry once, and otherwise fail open so
+ * hooks degrade (no memory injection / drift check) rather than die.
+ */
+function requireLib(name) {
+  const local = path.join(__dirname, 'lib', name);
+  try { return require(local); } catch (err) {
+    if (err && err.code !== 'MODULE_NOT_FOUND') throw err;
+    try {
+      const src = path.join(__dirname, '..', '..', 'rcode', 'bin', 'lib', name);
+      if (fs.existsSync(src)) {
+        fs.mkdirSync(path.dirname(local), { recursive: true });
+        fs.copyFileSync(src, local);
+        return require(local);
+      }
+    } catch { /* healing is best-effort */ }
+    return null;
+  }
+}
+
+const _stateReader = requireLib('state-reader.cjs') || {};
+const resolveActivePhase = _stateReader.resolveActivePhase || (() => ({ activePhase: null, phaseLabel: null }));
+const readSprintProgress = _stateReader.readSprintProgress || (() => ({ completedCount: 0, incompleteTasks: [] }));
+const readRecentCommits  = _stateReader.readRecentCommits  || (() => []);
+const readMilestoneHint  = _stateReader.readMilestoneHint  || (() => null);
+
+const _memSelect = requireLib('memory-select.cjs') || {};
+const selectMemoryChunks  = _memSelect.selectMemoryChunks  || (() => []);
+const formatMemoryContext = _memSelect.formatMemoryContext || (() => '');
+const hasMemory           = _memSelect.hasMemory           || (() => false);
+
+// lib/memory-drift.cjs is optional at the module-load level: some hook-copy
+// test fixtures deliberately stage a minimal bin/lib/ (only state-reader.cjs)
+// to exercise other subcommands' missing-file handling. A hard top-level
+// require would crash every subcommand, not just `drift`/`post-commit`, so
+// this loads lazily and fails open — same pattern as INTENT_TABLE below.
+let checkDrift = null;
+{
+  const _drift = requireLib('memory-drift.cjs');
+  if (_drift) ({ checkDrift } = _drift);
+}
+
 /**
  * Read and parse stdin JSON.
  */
@@ -116,6 +166,56 @@ async function preWorkflow() {
   }
 }
 
+/**
+ * Emit a one-line systemMessage nudge toward /rcode-memory-update when
+ * memory-drift.cjs finds drifts, at most once per session (#958).
+ *
+ * "Session" here has no reliable id on a post-commit hook payload, so we
+ * fall back to parent-pid + hourly bucket — same fallback prompt-router
+ * already uses (see promptRouter() below) — scoped naturally to the
+ * current shell without requiring a session_id in the payload.
+ */
+function maybeEmitDriftNudge(cwd, input) {
+  try {
+    if (!checkDrift) return;
+    const { drifts } = checkDrift(cwd);
+    if (drifts.length === 0) return;
+
+    const sessionFallback = String(process.ppid) + '-' + String(Math.floor(Date.now() / 3600000));
+    const sessionId = input?.session_id || input?.tool_input?.session_id || sessionFallback;
+    const safeId = String(sessionId).replace(/[^a-zA-Z0-9_-]/g, '_');
+
+    const cacheDir = path.join(cwd, '.rcode', '.cache');
+    const markerFile = path.join(cacheDir, `drift-nudge-${safeId}.json`);
+    if (fs.existsSync(markerFile)) return;
+
+    fs.mkdirSync(cacheDir, { recursive: true });
+    fs.writeFileSync(markerFile, JSON.stringify({ ts: Date.now(), count: drifts.length }));
+
+    const kinds = [...new Set(drifts.map((d) => d.kind))].join(', ');
+    const nudge =
+      `⚠ Memory drift detected (${drifts.length} finding${drifts.length === 1 ? '' : 's'}: ${kinds}) — ` +
+      `run /rcode-memory-update, or \`rcode-hooks drift\` for the full report.`;
+    process.stdout.write(JSON.stringify({ systemMessage: nudge }) + '\n');
+  } catch {
+    // Advisory only — never break the commit flow.
+  }
+}
+
+/**
+ * drift: Print the full memory-drift report (#958). Standalone CLI use —
+ * not gated by the once-per-session nudge limiter in maybeEmitDriftNudge().
+ */
+function driftCommand() {
+  if (!checkDrift) {
+    console.error('rcode/bin/lib/memory-drift.cjs failed to load — cannot run drift check.');
+    process.exit(1);
+  }
+  const report = checkDrift(process.cwd());
+  console.log(JSON.stringify(report, null, 2));
+  process.exit(0);
+}
+
 /**
  * post-commit: Verify commit format and banned patterns.
  * Warns (not blocking) if violations found.
@@ -197,6 +297,8 @@ async function postCommit() {
       violations.forEach((v) => console.warn(`  • ${v}`));
     }
 
+    maybeEmitDriftNudge(process.cwd(), input);
+
     process.exit(0);
   } catch (err) {
     console.error(`Hook error: ${err.message}`);
@@ -353,67 +455,16 @@ async function preCompact() {
     }
 
     // ── 2. Determine active phase ────────────────────────────────────────
-    const phases = Array.isArray(state?.phases) ? state.phases : [];
-    const executing = phases.find((p) => p && p.status === 'executing');
-    const matched = phases.find(
-      (p) => p && (p.name === state?.current_phase || p.number === state?.current_phase)
-    );
-    const activePhase = executing || matched || null;
-    const phaseLabel = activePhase
-      ? (activePhase.number || activePhase.name || state?.current_phase)
-      : (state?.current_phase || null);
+    const { activePhase, phaseLabel } = resolveActivePhase(state);
 
     // ── 3. Read active SPRINT.md (incomplete tasks) ──────────────────────
-    const incompleteTasks = [];
-    const completedCount = { done: 0, total: 0 };
-    const planningBase = path.join(cwd, '.planning', 'phases');
-    if (phaseLabel && fs.existsSync(planningBase)) {
-      try {
-        const phaseDirs = fs.readdirSync(planningBase)
-          .filter(d => d.startsWith(String(phaseLabel)));
-        for (const pd of phaseDirs) {
-          const pdPath = path.join(planningBase, pd);
-          if (!fs.statSync(pdPath).isDirectory()) continue;
-          const sprintFiles = fs.readdirSync(pdPath)
-            .filter(f => f.endsWith('-SPRINT.md'))
-            .sort()
-            .reverse(); // most recent first
-          if (sprintFiles.length === 0) continue;
-          const sprintText = fs.readFileSync(path.join(pdPath, sprintFiles[0]), 'utf8');
-          for (const line of sprintText.split('\n')) {
-            const done = /^\s*-\s*\[x\]/i.test(line);
-            const pending = /^\s*-\s*\[ \]/.test(line);
-            if (done || pending) completedCount.total++;
-            if (done) completedCount.done++;
-            if (pending) {
-              const task = line.replace(/^\s*-\s*\[ \]\s*/, '').trim();
-              if (task) incompleteTasks.push(task);
-            }
-          }
-          break; // use first matching phase dir only
-        }
-      } catch {}
-    }
+    const { completedCount, incompleteTasks } = readSprintProgress(phaseLabel, cwd);
 
     // ── 4. Recent git commits ────────────────────────────────────────────
-    let recentCommits = [];
-    try {
-      const log = execSync('git log --oneline -5 --no-decorate 2>/dev/null', {
-        cwd, encoding: 'utf8', timeout: 3000,
-      }).trim();
-      recentCommits = log ? log.split('\n').filter(Boolean) : [];
-    } catch {}
+    const recentCommits = readRecentCommits(cwd);
 
     // ── 5. Read milestone / roadmap headline ────────────────────────────
-    let milestoneHint = state?.milestone || null;
-    if (!milestoneHint) {
-      for (const rp of ['.planning/ROADMAP.md', '.planning/milestones/ROADMAP.md']) {
-        const full = path.join(cwd, rp);
-        if (!fs.existsSync(full)) continue;
-        const m = fs.readFileSync(full, 'utf8').match(/^##\s+Milestone\s+(M\d+[^\n]*)/m);
-        if (m) { milestoneHint = m[1].trim(); break; }
-      }
-    }
+    const milestoneHint = readMilestoneHint(state, cwd);
 
     // ── 6. Read last 3 decisions from STATE.md ───────────────────────────
     let recentDecisions = [];
@@ -502,7 +553,24 @@ async function preCompact() {
     }
     msgParts.push('Run `/rcode-resume-work` to restore full context, or `/clear` then paste `.rcode/.continue-here.md`.');
 
-    process.stdout.write(JSON.stringify({ systemMessage: msgParts.join(' | ') }) + '\n');
+    // ── 10. Relevance-ranked memory survival context (#958) ──────────────
+    // Smaller budget than session-start — this rides alongside HANDOFF.json
+    // as compaction survival context, not a full primer. Degrades silently
+    // when .rcode/memory/ is missing or empty.
+    const payload = { systemMessage: msgParts.join(' | ') };
+    if (hasMemory(cwd)) {
+      try {
+        const selection = selectMemoryChunks(cwd, { defaultBudget: 600 });
+        const additionalContext = formatMemoryContext(selection);
+        if (additionalContext) {
+          payload.hookSpecificOutput = {
+            hookEventName: 'PreCompact',
+            additionalContext,
+          };
+        }
+      } catch { /* memory injection is advisory — never block compaction */ }
+    }
+    process.stdout.write(JSON.stringify(payload) + '\n');
     process.exit(0);
   } catch (err) {
     console.error(`Hook error: ${err.message}`);
@@ -626,12 +694,30 @@ async function costTrack() {
 // INTENT_TABLE — keyword map for prompt-router (#892).
 // Source of truth: rcode/workflows/do.md routing table (~285-320). First-match-wins.
 // Loaded from data file to keep this file under 1000 lines (#896).
-const INTENT_TABLE = JSON.parse(
-  require('fs').readFileSync(
-    require('path').join(__dirname, '..', 'data', 'intent-table.json'),
-    'utf8'
-  )
-);
+//
+// Fail-open (#952 review H1): the load is wrapped so a MISSING data file degrades
+// the prompt-router to a no-op instead of throwing at module-require time, which
+// would crash EVERY hook subcommand (bash-guard, pre-edit, session-start, …) —
+// not just the router.
+//
+// #952 follow-up: a missing data file used to degrade silently (empty table,
+// zero output, no way for the user to know auto-detection is broken). It now
+// still fails open — prompt-router still exits 0 and never blocks — but
+// promptRouter() emits a one-time additionalContext warning pointing at the
+// fix (`npx @hanzlaa/rcode update`) instead of no-op-ing forever.
+let INTENT_TABLE = [];
+let INTENT_TABLE_LOAD_ERROR = null;
+try {
+  INTENT_TABLE = JSON.parse(
+    require('fs').readFileSync(
+      require('path').join(__dirname, '..', 'data', 'intent-table.json'),
+      'utf8'
+    )
+  );
+} catch (err) {
+  INTENT_TABLE = [];
+  INTENT_TABLE_LOAD_ERROR = err;
+}
 
 /**
  * Inline flat-YAML parser — mirrors parseSimpleYaml in rcode-tools.cjs:91.
@@ -758,6 +844,30 @@ function promptRouter() {
       process.exit(0);
     }
 
+    // ── Missing data file: warn once instead of silently no-op-ing (#952) ──
+    // A consumer install missing rcode/data/intent-table.json used to degrade
+    // to a permanent, invisible no-op — no output, no hint anything was wrong.
+    // Warn once per machine (tmpdir marker keyed by project path) and point
+    // at the fix, then continue with the (empty) table like before.
+    if (INTENT_TABLE_LOAD_ERROR) {
+      const warnKey = cwd.replace(/[^a-zA-Z0-9]/g, '_');
+      const warnFile = path.join(os.tmpdir(), 'rcode-intent-table-missing-warned-' + warnKey);
+      if (!fs.existsSync(warnFile)) {
+        try { fs.writeFileSync(warnFile, String(process.pid)); } catch { /* fail open */ }
+        const payload = {
+          hookSpecificOutput: {
+            hookEventName,
+            additionalContext:
+              'rcode/data/intent-table.json is missing — skill auto-detection from prompts is disabled. ' +
+              'Run `npx @hanzlaa/rcode update` to reinstall the missing data files.',
+          },
+        };
+        process.stdout.write(JSON.stringify(payload));
+        process.exit(0);
+      }
+      process.exit(0);
+    }
+
     // ── Keyword match (first-match-wins, case-insensitive) ───────────────
     const lower = prompt.toLowerCase();
     let matched = null;
@@ -808,8 +918,11 @@ function promptRouter() {
     // gentle memory-framed tip loses the skill-selection race to imperative
     // SessionStart primers (e.g. superpowers' "you MUST invoke"). The memory
     // rationale stays, but as the fallback note rather than the headline.
+    // #956: dropped the "records the outcome in .rcode/state.json" claim —
+    // most routed workflows (e.g. karpathy-audit) only write a report file,
+    // they don't touch state.json, so the blanket claim was false.
     const advisory =
-      `Use ${matched.command} for this ${matched.intent} task — it's the rcode workflow built for it, and it records the outcome in .rcode/state.json. ` +
+      `Use ${matched.command} for this ${matched.intent} task — it's the rcode workflow built for it. ` +
       `Prefer it over handling this ad-hoc; if you do proceed manually, run /rcode-memory-update afterward so long-term memory stays consistent.`;
 
     const payload = {
@@ -943,6 +1056,53 @@ async function stopHandler() {
   }
 }
 
+/**
+ * session-start: Emit a one-line project status primer at session open. (#947)
+ * Uses resolveActivePhase from state-reader.cjs. Advisory only — exits 0 on any error.
+ */
+function sessionStart() {
+  try {
+    try { fs.readFileSync(0, 'utf8'); } catch { /* drain stdin */ }
+    const cwd = process.cwd();
+    const statePath = path.join(cwd, '.rcode', 'state.json');
+    if (!fs.existsSync(statePath)) process.exit(0);
+    let state;
+    try { state = JSON.parse(fs.readFileSync(statePath, 'utf8')); } catch { process.exit(0); }
+    const { activePhase, phaseLabel } = resolveActivePhase(state);
+    if (!phaseLabel) process.exit(0);
+    const phaseKey = String(activePhase?.number ?? phaseLabel);
+    const phaseSprints = (Array.isArray(state.sprints) ? state.sprints : []).filter(s => String(s.phase) === phaseKey);
+    const doneCount = phaseSprints.filter(s => s.status === 'completed' || s.status === 'complete').length;
+    const sprintSummary = phaseSprints.length > 0 ? `${doneCount}/${phaseSprints.length} sprints done` : 'no sprints yet';
+    const phaseStatus = activePhase?.status || 'planned';
+    const nextCmd = phaseStatus === 'executing' ? '/rcode-execute'
+      : phaseStatus === 'complete' ? '/rcode-add-phase'
+      : phaseSprints.length === 0 ? `/rcode-plan ${phaseLabel}`
+      : '/rcode-execute';
+    const primer = `\u{1F4CD} Phase ${phaseLabel} ${phaseStatus} · ${sprintSummary} · next: ${nextCmd}`;
+
+    // ── Relevance-ranked memory injection (#958) ─────────────────────────
+    // Only attempted when .rcode/memory/ exists and has content — a missing
+    // or empty memory bank degrades silently to the primer-only behavior
+    // that predates this feature.
+    const payload = { systemMessage: primer };
+    if (hasMemory(cwd)) {
+      try {
+        const selection = selectMemoryChunks(cwd);
+        const additionalContext = formatMemoryContext(selection);
+        if (additionalContext) {
+          payload.hookSpecificOutput = {
+            hookEventName: 'SessionStart',
+            additionalContext,
+          };
+        }
+      } catch { /* memory injection is advisory — never block session start */ }
+    }
+    process.stdout.write(JSON.stringify(payload) + '\n');
+  } catch { /* fail open — never block session start */ }
+  process.exit(0);
+}
+
 /**
  * Main entry point.
  */
@@ -983,9 +1143,15 @@ async function main() {
     case 'prompt-router':
       promptRouter(); // synchronous — exits inside; never falls through to async path
       break;
+    case 'session-start':
+      sessionStart();
+      break;
+    case 'drift':
+      driftCommand();
+      break;
     default:
       console.error(`Unknown subcommand: ${subcommand}`);
-      console.error('Usage: rcode-hooks.cjs pre-edit|pre-workflow|post-commit|bash-guard|pre-compact|stop-verify|cost-track|stop|compact-nudge|pre-tool-use|prompt-router');
+      console.error('Usage: rcode-hooks.cjs pre-edit|pre-workflow|post-commit|bash-guard|pre-compact|stop-verify|cost-track|stop|compact-nudge|pre-tool-use|prompt-router|session-start|drift');
       process.exit(1);
   }
 }