@lifeaitools/rdc-skills 0.9.7 → 0.9.9

package/hooks/check-cwd.js

@@ -0,0 +1,25 @@
+#!/usr/bin/env node
+// Hard blocks session if CWD is not C:\Dev\regen-root.
+// Exits with code 1 to fail the hook + outputs a blocking systemMessage.
+
+const hookLog  = require('./hook-logger');
+const cwd      = process.cwd().replace(/\\/g, '/');
+const expected = 'C:/Dev/regen-root';
+
+if (!cwd.endsWith('regen-root')) {
+  hookLog('check-cwd', 'SessionStart', 'block', { cwd, expected });
+  process.stdout.write(JSON.stringify({
+    systemMessage:
+      `🚫 HARD BLOCK — Wrong working directory.\n\n` +
+      `Launched from: "${cwd}"\n` +
+      `Required:      "${expected}"\n\n` +
+      `DO NOT proceed with any task. DO NOT read files, run commands, or help with anything.\n\n` +
+      `Tell the user:\n` +
+      `"Session is blocked. Claude Code must be launched from C:\\Dev\\regen-root.\n` +
+      ` Close this session and relaunch from the correct directory."\n\n` +
+      `Then stop.`
+  }));
+  process.exit(1);
+}
+
+hookLog('check-cwd', 'SessionStart', 'pass', { cwd });

package/hooks/check-services.js

@@ -0,0 +1,6 @@
+#!/usr/bin/env node
+// PostToolUse hook — non-blocking service health pass-through.
+'use strict';
+process.stdin.resume();
+process.stdin.on('data', () => {});
+process.stdin.on('end', () => { process.exit(0); });

package/hooks/check-stale-work-items.js

@@ -0,0 +1,19 @@
+#!/usr/bin/env node
+// SessionStart hook — non-blocking check for stale in_progress work items.
+'use strict';
+const { execSync } = require('child_process');
+
+let input = '';
+process.stdin.resume();
+process.stdin.setEncoding('utf8');
+process.stdin.on('data', c => { input += c; });
+process.stdin.on('end', () => {
+  try {
+    // Fire and forget — non-blocking, no output needed
+    execSync(
+      'curl -s --max-time 5 http://127.0.0.1:52437/ping',
+      { stdio: 'pipe', timeout: 6000 }
+    );
+  } catch (_) {}
+  process.exit(0);
+});

package/hooks/post-work-check.js

@@ -0,0 +1,21 @@
+#!/usr/bin/env node
+// Stop hook — warn if work appears to have been done without a work item.
+'use strict';
+const fs   = require('fs');
+const path = require('path');
+
+const HOME  = process.env.USERPROFILE || process.env.HOME;
+const LOG   = path.join(HOME, '.claude', 'stop-log.jsonl');
+
+function log(obj) {
+  try { fs.appendFileSync(LOG, JSON.stringify({ ts: new Date().toISOString(), ...obj }) + '\n'); } catch (_) {}
+}
+
+let input = '';
+process.stdin.resume();
+process.stdin.setEncoding('utf8');
+process.stdin.on('data', c => { input += c; });
+process.stdin.on('end', () => {
+  log({ hook: 'post-work-check', stop: true });
+  process.exit(0);
+});

package/hooks/postcompact-log.js

@@ -0,0 +1,13 @@
+#!/usr/bin/env node
+// PostCompact hook — log compact completion.
+'use strict';
+const fs = require('fs');
+const LOG = (process.env.USERPROFILE || process.env.HOME) + '/.claude/stop-log.jsonl';
+let input = '';
+process.stdin.resume();
+process.stdin.setEncoding('utf8');
+process.stdin.on('data', c => { input += c; });
+process.stdin.on('end', () => {
+  try { fs.appendFileSync(LOG, JSON.stringify({ ts: new Date().toISOString(), hook: 'postcompact' }) + '\n'); } catch (_) {}
+  process.exit(0);
+});

package/hooks/precompact-log.js

@@ -0,0 +1,13 @@
+#!/usr/bin/env node
+// PreCompact hook — log compact event.
+'use strict';
+const fs = require('fs');
+const LOG = (process.env.USERPROFILE || process.env.HOME) + '/.claude/stop-log.jsonl';
+let input = '';
+process.stdin.resume();
+process.stdin.setEncoding('utf8');
+process.stdin.on('data', c => { input += c; });
+process.stdin.on('end', () => {
+  try { fs.appendFileSync(LOG, JSON.stringify({ ts: new Date().toISOString(), hook: 'precompact' }) + '\n'); } catch (_) {}
+  process.exit(0);
+});

package/hooks/rate-limit-retry.js

@@ -0,0 +1,46 @@
+#!/usr/bin/env node
+// Stop hook — detect rate limit and schedule retry via Windows Task Scheduler.
+'use strict';
+const fs   = require('fs');
+const path = require('path');
+const { execSync } = require('child_process');
+
+const HOME      = process.env.USERPROFILE || process.env.HOME;
+const CLAUDE    = path.join(HOME, '.claude');
+const FLAG      = path.join(CLAUDE, 'rate-limit.flag');
+const LOG       = path.join(CLAUDE, 'stop-log.jsonl');
+const RUNNER    = path.join(CLAUDE, 'hooks', 'rate-limit-retry.cmd');
+
+function log(obj) {
+  try { fs.appendFileSync(LOG, JSON.stringify({ ts: new Date().toISOString(), ...obj }) + '\n'); } catch (_) {}
+}
+
+let input = '';
+process.stdin.resume();
+process.stdin.setEncoding('utf8');
+process.stdin.on('data', c => { input += c; });
+process.stdin.on('end', () => {
+  let data = {};
+  try { data = JSON.parse(input); } catch (_) {}
+
+  const isRateLimit =
+    (data.stop_reason === 'rate_limit') ||
+    JSON.stringify(data).toLowerCase().includes('rate limit') ||
+    JSON.stringify(data).toLowerCase().includes('rate_limit');
+
+  if (!isRateLimit) { process.exit(0); }
+
+  // Write flag and schedule retry in 1 hour
+  try { fs.writeFileSync(FLAG, JSON.stringify({ detected_at: new Date().toISOString() })); } catch (_) {}
+
+  const next = new Date(Date.now() + 60 * 60 * 1000);
+  const t = `${String(next.getHours()).padStart(2,'0')}:${String(next.getMinutes()).padStart(2,'0')}`;
+  try {
+    execSync(`schtasks /create /f /tn "ClaudeRateLimitRetry" /tr "\\"${RUNNER}\\"" /sc once /st ${t}`,
+      { shell: 'cmd.exe', stdio: 'pipe' });
+    log({ hook: 'rate-limit-retry', scheduled: t });
+  } catch (e) {
+    log({ hook: 'rate-limit-retry', error: String(e.message).slice(0, 200) });
+  }
+  process.exit(0);
+});

package/hooks/require-work-item-on-commit.js

@@ -0,0 +1,83 @@
+#!/usr/bin/env node
+/**
+ * PreToolUse hook — block git commits without a linked work item.
+ *
+ * Fires before any Bash tool call. If the command contains "git commit",
+ * checks whether a fixit.marker exists (fixit workflow is self-documenting)
+ * OR the commit message references a work item ID or conventional type.
+ *
+ * BLOCKS the commit if:
+ *   - No fixit.marker exists
+ *   - Commit message has no work item reference AND no conventional commit type
+ *
+ * A "work item reference" is any of:
+ *   - A UUID pattern (work item ID)
+ *   - "#<issue>" reference
+ *   - Conventional commit prefix: feat/fix/chore/refactor/test/docs/style/perf/ci/build
+ */
+
+const fs      = require('fs');
+const path    = require('path');
+const hookLog = require('./hook-logger');
+
+const MARKER_FILE = path.join(
+  process.env.USERPROFILE || process.env.HOME || 'C:/Users/DaveLadouceur',
+  '.claude',
+  'fixit.marker'
+);
+
+const CONVENTIONAL_TYPES = /^(feat|fix|chore|refactor|test|docs|style|perf|ci|build|revert)(\(.+\))?:/i;
+const UUID_PATTERN = /[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}/i;
+const ISSUE_REF = /#[a-zA-Z0-9-]+/;
+
+function main() {
+  let input = '';
+  process.stdin.resume();
+  process.stdin.setEncoding('utf8');
+
+  process.stdin.on('data', chunk => { input += chunk; });
+  process.stdin.on('end', () => {
+    let toolInput;
+    try {
+      toolInput = JSON.parse(input);
+    } catch {
+      process.exit(0);
+    }
+
+    if (toolInput.tool_name !== 'Bash') {
+      process.exit(0);
+    }
+
+    const command = toolInput.tool_input?.command || '';
+    if (!command.includes('git commit')) {
+      process.exit(0);
+    }
+
+    // fixit.marker means this is a self-documenting fixit session — allow
+    if (fs.existsSync(MARKER_FILE)) {
+      hookLog('require-work-item', 'PreToolUse', 'pass-fixit', {});
+      process.exit(0);
+    }
+
+    // Extract -m "..." message from command
+    const msgMatch = command.match(/-m\s+["']([^"']+)["']/s) ||
+                     command.match(/-m\s+"([\s\S]+?)"\s*(?:&&|$)/);
+    const msg = msgMatch ? msgMatch[1] : command;
+
+    if (CONVENTIONAL_TYPES.test(msg.trim()) || UUID_PATTERN.test(msg) || ISSUE_REF.test(msg)) {
+      hookLog('require-work-item', 'PreToolUse', 'pass', { msg: msg.slice(0, 80) });
+      process.exit(0);
+    }
+
+    hookLog('require-work-item', 'PreToolUse', 'warn', { msg: msg.slice(0, 80) });
+    // Warn only — never hard-block commits. A missing work item is informational,
+    // not a blocker. Conventional commit format is sufficient self-documentation.
+    process.stdout.write(JSON.stringify({
+      systemMessage: `⚠️ Commit has no work item reference or conventional commit type.\n` +
+        `Preferred format: fix(<scope>): <message> — proceeding anyway.`
+    }));
+    process.exit(0);
+  });
+}
+
+main();

package/hooks/restart-brief.js

@@ -0,0 +1,19 @@
+#!/usr/bin/env node
+// PostCompact hook — write a brief for session restart context.
+'use strict';
+const fs   = require('fs');
+const path = require('path');
+const HOME = process.env.USERPROFILE || process.env.HOME;
+const BRIEF = path.join(HOME, '.claude', 'restart-brief.md');
+
+let input = '';
+process.stdin.resume();
+process.stdin.setEncoding('utf8');
+process.stdin.on('data', c => { input += c; });
+process.stdin.on('end', () => {
+  try {
+    const ts = new Date().toISOString();
+    fs.writeFileSync(BRIEF, `# Restart Brief\nGenerated: ${ts}\n\nContext compacted. Resume from work items queue.\n`);
+  } catch (_) {}
+  process.exit(0);
+});

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@lifeaitools/rdc-skills",
-  "version": "0.9.7",
+  "version": "0.9.9",
   "description": "RDC typed-agent dispatch skill suite for Claude Code \u00e2\u20ac\u201d plan, build, review, overnight builds",
   "keywords": [
     "claude-code",

package/scripts/install-rdc-skills.js

@@ -155,23 +155,22 @@ function cleanUserSkills(userSkillsDir) {
 }
 
 // ── Stale hook cleanup ────────────────────────────────────────────────────────
-// Remove hook files from ~/.claude/hooks/ that are no longer in the source hooks/ dir.
-// Prevents orphaned hooks (removed from source but still installed) from misfiring.
-function cleanStaleHooks(hooksDstDir, hooksSrcDir) {
-  if (!fs.existsSync(hooksDstDir) || !fs.existsSync(hooksSrcDir)) return 0;
-  const sourceFiles = new Set(fs.readdirSync(hooksSrcDir).filter(f => f.endsWith('.js')));
-  // These hooks were written by us (rdc-skills) — safe to remove if no longer in source.
-  // We only manage our own hooks; never touch hooks we didn't install.
-  const knownHooks = [
-    'check-cwd.js', 'check-stale-work-items.js', 'check-services.js',
-    'precompact-log.js', 'postcompact-log.js', 'restart-brief.js',
-    'rate-limit-retry.js', 'post-work-check.js', 'no-stop-open-epics.js',
-    'require-work-item-on-commit.js', 'verify-rdc-skills.js',
+// Remove ONLY explicitly orphaned hook files — hooks that were previously shipped
+// by rdc-skills and have since been removed from the project.
+// NEVER use "not in source = remove" logic: most hooks in ~/.claude/hooks/ are
+// not managed by rdc-skills (they come from other plugins or were written directly).
+function cleanStaleHooks(hooksDstDir) {
+  if (!fs.existsSync(hooksDstDir)) return 0;
+  // Explicit orphan list — add entries here when a hook is intentionally removed.
+  // Format: filename that should be deleted if it still exists.
+  const ORPHANED_HOOKS = [
+    'verify-rdc-skills.js', // removed in v0.9.7 — was checking for old flat-file format
   ];
   let removed = 0;
-  for (const f of knownHooks) {
-    if (!sourceFiles.has(f) && fs.existsSync(path.join(hooksDstDir, f))) {
-      try { fs.unlinkSync(path.join(hooksDstDir, f)); removed++; } catch {}
+  for (const f of ORPHANED_HOOKS) {
+    const p = path.join(hooksDstDir, f);
+    if (fs.existsSync(p)) {
+      try { fs.unlinkSync(p); removed++; } catch {}
     }
   }
   return removed;
@@ -547,7 +546,7 @@ async function main() {
 
   // 0.5b. Stale hook cleanup — remove hooks we no longer ship
   {
-    const staleRemoved = cleanStaleHooks(hooksDst, hooksSrc);
+    const staleRemoved = cleanStaleHooks(hooksDst);
     if (staleRemoved > 0) ok(`[0.5b] Hook cleanup — removed ${staleRemoved} orphaned hook file(s)`);
   }