@hanzlaa/rcode 4.3.2 → 4.4.0

package/rcode/bin/rcode-hooks.cjs

@@ -10,7 +10,10 @@
  *   pre-compact — refresh HANDOFF.json before context compaction (#743)
  *   stop-verify — syntax-check files changed during the response (#744)
  *   cost-track  — append per-response token usage to cost.jsonl (#745)
+ *   stop        — unified Stop hook: hedging-language detection (#744) + token logging (#745)
  *   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)
  *
  * All subcommands read stdin JSON from the hook execution context.
  * Pure Node stdlib. No external dependencies.
@@ -19,6 +22,7 @@
 const fs = require('fs');
 const os = require('os');
 const path = require('path');
+const { execSync, spawnSync } = require('child_process');
 
 /**
  * Read and parse stdin JSON.
@@ -337,8 +341,6 @@ async function bashGuard() {
  */
 async function preCompact() {
   try {
-    const path = require('path');
-    const { execSync } = require('child_process');
     await readInputJson(); // drain the PreCompact event payload
 
     const cwd = process.cwd();
@@ -518,8 +520,6 @@ async function preCompact() {
  */
 async function stopVerify() {
   try {
-    const path = require('path');
-    const { spawnSync } = require('child_process');
     const input = await readInputJson();
 
     let changed =
@@ -623,13 +623,211 @@ 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'
+  )
+);
+
+/**
+ * Inline flat-YAML parser — mirrors parseSimpleYaml in rcode-tools.cjs:91.
+ * Supports `key: value` lines only; strips `#` comments; unquotes.
+ * Kept inline so this file stays standalone (no cross-file require).
+ */
+function parseSimpleYamlInline(text) {
+  const out = {};
+  for (const raw of text.split('\n')) {
+    const line = raw.replace(/#.*$/, '').trim();
+    if (!line) continue;
+    const colonAt = line.indexOf(':');
+    if (colonAt === -1) continue;
+    const key = line.slice(0, colonAt).trim();
+    let val = line.slice(colonAt + 1).trim();
+    if (val.startsWith('"') && val.endsWith('"')) val = val.slice(1, -1);
+    if (val.startsWith("'") && val.endsWith("'")) val = val.slice(1, -1);
+    out[key] = val;
+  }
+  return out;
+}
+
+/**
+ * Read prompt_nudge from .rcode/config.yaml.
+ * Returns 'every' | 'once-per-intent' | 'when-stale' | 'off'.
+ * Defaults to 'every' when key is absent, file is missing, or value is unknown.
+ */
+function readPromptNudgeToggle(cwd) {
+  const VALID = new Set(['every', 'once-per-intent', 'when-stale', 'off']);
+  try {
+    const cfgPath = path.join(cwd, '.rcode', 'config.yaml');
+    const text = fs.readFileSync(cfgPath, 'utf8');
+    const parsed = parseSimpleYamlInline(text);
+    const val = (parsed.prompt_nudge || '').trim().toLowerCase();
+    return VALID.has(val) ? val : 'every';
+  } catch {
+    return 'every';
+  }
+}
+
+/**
+ * Returns true when state.json is older than the last commit, or absent in a .planning/ project.
+ * Fail-open: returns true on any I/O error so the nudge fires rather than silently skips.
+ */
+function isStateStaleFallbackTrue(cwd) {
+  try {
+    const statePath = path.join(cwd, '.rcode', 'state.json');
+    const planningDir = path.join(cwd, '.planning');
+    const hasPlanning = fs.existsSync(planningDir);
+
+    if (!fs.existsSync(statePath)) {
+      // No state.json at all — if there IS a .planning/ dir, that means we're
+      // in a project that should have state but doesn't: treat as stale.
+      return hasPlanning;
+    }
+
+    // state.json exists — check its mtime vs last commit timestamp.
+    const stateMtime = fs.statSync(statePath).mtimeMs;
+    let lastCommitTs = null;
+    try {
+      const tsStr = execSync('git log -1 --format=%ct 2>/dev/null', {
+        cwd, encoding: 'utf8', timeout: 2000,
+      }).trim();
+      if (tsStr) lastCommitTs = parseInt(tsStr, 10) * 1000;
+    } catch { /* git unavailable or no commits */ }
+
+    if (lastCommitTs === null) return false; // can't determine, don't nag
+    return stateMtime < lastCommitTs;
+  } catch {
+    return true; // fail open: treat as stale
+  }
+}
+
+/**
+ * prompt-router: Nudge toward rcode commands for memory consistency (#892).
+ * Reads stdin synchronously (NOT async — rejects bad JSON). Keyword-matches INTENT_TABLE,
+ * emits additionalContext advisory. Gated by prompt_nudge config. Always exits 0.
+ */
+function promptRouter() {
+  try {
+    // Read stdin synchronously — mirrors cli/rcode-slash-router.cjs readStdin().
+    let raw = '';
+    try {
+      raw = fs.readFileSync(0, 'utf8');
+    } catch {
+      process.exit(0);
+    }
+
+    if (!raw.trim()) process.exit(0);
+
+    let data;
+    try {
+      data = JSON.parse(raw);
+    } catch {
+      process.exit(0);
+    }
+
+    // Multi-spelling prompt field fallback — mirrors rcode-slash-router.cjs.
+    const prompt =
+      data.prompt ??
+      data.user_prompt ??
+      data.userPrompt ??
+      data.message ??
+      data.input ??
+      '';
+
+    if (typeof prompt !== 'string' || !prompt.trim()) process.exit(0);
+
+    const trimmed = prompt.trimStart();
+
+    // Skip prompts that already start with /rcode- — slash router handles those.
+    if (/^\/rcode-/.test(trimmed)) process.exit(0);
+
+    const hookEventName =
+      data.hook_event_name || data.hookEventName || 'UserPromptSubmit';
+    const cwd = process.cwd();
+
+    // ── Config toggle ────────────────────────────────────────────────────
+    const nudgeMode = readPromptNudgeToggle(cwd);
+    if (nudgeMode === 'off') process.exit(0);
+
+    // ── when-stale: check if state is stale ──────────────────────────────
+    if (nudgeMode === 'when-stale' && !isStateStaleFallbackTrue(cwd)) {
+      process.exit(0);
+    }
+
+    // ── Keyword match (first-match-wins, case-insensitive) ───────────────
+    const lower = prompt.toLowerCase();
+    let matched = null;
+    for (const entry of INTENT_TABLE) {
+      for (const kw of entry.keywords) {
+        if (lower.includes(kw.toLowerCase())) {
+          matched = entry;
+          break;
+        }
+      }
+      if (matched) break;
+    }
+
+    if (!matched) process.exit(0);
+
+    // ── once-per-intent dedupe ───────────────────────────────────────────
+    if (nudgeMode === 'once-per-intent') {
+      // Fallback key: parent PID + hourly bucket — scopes naturally to the
+      // current shell session without requiring session_id in the payload.
+      // Without this, every session shares 'default' and a dedupe file from
+      // session A silences nudges in session B permanently.
+      const sessionFallback =
+        String(process.ppid) + '-' + String(Math.floor(Date.now() / 3600000));
+      const sessionId =
+        data.session_id || data.tool_input?.session_id || sessionFallback;
+      const dedupeFile = path.join(
+        os.tmpdir(),
+        'rcode-prompt-nudge-' + sessionId + '.json'
+      );
+      try {
+        let seen = [];
+        try {
+          seen = JSON.parse(fs.readFileSync(dedupeFile, 'utf8'));
+          if (!Array.isArray(seen)) seen = [];
+        } catch { /* first run or missing file */ }
+
+        if (seen.includes(matched.intent)) process.exit(0);
+
+        seen.push(matched.intent);
+        try { fs.writeFileSync(dedupeFile, JSON.stringify(seen)); } catch {}
+      } catch {
+        // dedupe file unreadable/locked → fire anyway (fail open)
+      }
+    }
+
+    // ── Emit advisory ────────────────────────────────────────────────────
+    // #907 RC2: lead with the directive ("use X"), not a soft "consider" — a
+    // 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.
+    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. ` +
+      `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 = {
+      hookSpecificOutput: {
+        hookEventName,
+        additionalContext: advisory,
+      },
+    };
+    process.stdout.write(JSON.stringify(payload));
+  } catch {
+    // Fail open — never break the host CLI's prompt.
+  }
+  process.exit(0);
+}
+
 /**
  * compact-nudge: Advise /rcode-trim or /clear after N Edit/Write calls (#749).
- *
- * Triggered by the PreToolUse:Edit|Write hook. Maintains a per-session call
- * counter in a temp file and, once the count crosses RCODE_NUDGE_THRESHOLD
- * (default 50), prints an advisory to reclaim context budget. Purely
- * advisory — always exits 0, never blocks a tool call.
+ * Maintains a per-session counter; warns at RCODE_NUDGE_THRESHOLD (default 50). Advisory only.
  */
 async function compactNudge() {
   try {
@@ -667,6 +865,84 @@ async function compactNudge() {
   }
 }
 
+/** Returns true when a Read/Bash targets known large planning files (RESEARCH/SUMMARY/ROADMAP). */
+function shouldNudgeCompact(toolName, toolInput) {
+  if (toolName !== 'Read' && toolName !== 'Bash') return false;
+  const target = toolInput?.file_path || toolInput?.command || '';
+  return /RESEARCH\.md|SUMMARY\.md|ROADMAP\.md/.test(target);
+}
+
+/**
+ * pre-tool-use: Strategic compact nudge before large file reads (#749).
+ *
+ * Triggered by the PreToolUse hook (Read + Bash tool names). Checks whether
+ * the tool call targets a known large planning file and, if so, writes an
+ * advisory line to stderr so the executor sees it without being interrupted.
+ * Always exits 0 — never blocks the tool call.
+ */
+async function preToolUse() {
+  try {
+    const input = await readInputJson();
+    const toolName = input.tool_name || input.toolName || '';
+    const toolInput = input.tool_input || input.toolInput || {};
+
+    if (shouldNudgeCompact(toolName, toolInput)) {
+      process.stderr.write(
+        '[rcode] Context nearing limit — consider /compact before the next large file read\n'
+      );
+    }
+
+    process.exit(0);
+  } catch {
+    // Advisory hook must never break the session.
+    process.exit(0);
+  }
+}
+
+/**
+ * stop: Stop hook — hedging-language detection (#744) + token/cost logging (#745).
+ * Warns when response text suggests incomplete execution ("I'll implement this", etc.).
+ * Appends per-response token usage to ~/.rcode/logs/token-usage.jsonl.
+ * Rates: $3/M input, $15/M output (Sonnet 4.x approximation).
+ * Never blocks.
+ */
+async function stopHandler() {
+  try {
+    const input = await readInputJson();
+    const responseText = input?.response || '';
+    const HEDGING_PATTERNS = [
+      /I'll\s+implement\s+this/i,
+      /I\s+would\s+add/i,
+      /you\s+could\s+add/i,
+      /TODO:/,
+    ];
+    const incomplete = HEDGING_PATTERNS.some((re) => re.test(responseText));
+    if (incomplete) {
+      process.stderr.write(
+        '[rcode] Stop hook: response contains hedging language — verify implementation is complete\n'
+      );
+    }
+    const usage = input?.usage;
+    if (usage && typeof usage === 'object') {
+      const logDir = path.join(os.homedir(), '.rcode', 'logs');
+      fs.mkdirSync(logDir, { recursive: true });
+      const entry = JSON.stringify({
+        ts: new Date().toISOString(),
+        input: usage.input_tokens || 0,
+        output: usage.output_tokens || 0,
+        cost_usd:
+          ((usage.input_tokens || 0) * 3) / 1e6 +
+          ((usage.output_tokens || 0) * 15) / 1e6,
+      });
+      fs.appendFileSync(path.join(logDir, 'token-usage.jsonl'), entry + '\n');
+    }
+    process.exit(0);
+  } catch (err) {
+    console.error(`Hook error: ${err.message}`);
+    process.exit(1);
+  }
+}
+
 /**
  * Main entry point.
  */
@@ -695,17 +971,30 @@ async function main() {
     case 'cost-track':
       await costTrack();
       break;
+    case 'stop':
+      await stopHandler();
+      break;
     case 'compact-nudge':
       await compactNudge();
       break;
+    case 'pre-tool-use':
+      await preToolUse();
+      break;
+    case 'prompt-router':
+      promptRouter(); // synchronous — exits inside; never falls through to async path
+      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|compact-nudge');
+      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');
       process.exit(1);
   }
 }
 
-main().catch((err) => {
-  console.error(`Fatal error: ${err.message}`);
-  process.exit(1);
-});
+if (require.main === module) {
+  main().catch((err) => {
+    console.error(`Fatal error: ${err.message}`);
+    process.exit(1);
+  });
+}
+
+module.exports = { INTENT_TABLE };