@sienklogic/plan-build-run 2.21.1 → 2.21.2

package/plugins/pbr/dist/post-write-quality.js

@@ -0,0 +1,208 @@
+#!/usr/bin/env node
+
+/**
+ * PostToolUse quality check hook for Write|Edit.
+ *
+ * Runs opt-in code quality checks on modified JS/TS files:
+ *   1. autoFormat:        Run Prettier on the file (requires local installation)
+ *   2. typeCheck:         Run tsc --noEmit filtered to the edited file (requires local typescript)
+ *   3. detectConsoleLogs: Warn about console.log statements left in the file
+ *
+ * All checks disabled by default. Enable via .planning/config.json:
+ *   { "hooks": { "autoFormat": true, "typeCheck": true, "detectConsoleLogs": true } }
+ *
+ * Only processes JS/TS files (.js, .jsx, .ts, .tsx, .mjs, .cjs).
+ * Silently skips if tools (prettier, tsc) are not installed in the project.
+ *
+ * Exit codes:
+ *   0 = always (PostToolUse hook, advisory only)
+ */
+
+const fs = require('fs');
+const path = require('path');
+const { execFileSync } = require('child_process');
+const { logHook } = require('./hook-logger');
+
+const JS_TS_EXTENSIONS = new Set(['.js', '.jsx', '.ts', '.tsx', '.mjs', '.cjs']);
+const TS_EXTENSIONS = new Set(['.ts', '.tsx']);
+
+function main() {
+  let input = '';
+
+  process.stdin.setEncoding('utf8');
+  process.stdin.on('data', (chunk) => { input += chunk; });
+  process.stdin.on('end', () => {
+    try {
+      const data = JSON.parse(input);
+      const result = checkQuality(data);
+      if (result) {
+        process.stdout.write(JSON.stringify(result.output));
+      }
+      process.exit(0);
+    } catch (_e) {
+      process.stdout.write(JSON.stringify({ additionalContext: '⚠ [PBR] post-write-quality failed: ' + _e.message }));
+      process.exit(0);
+    }
+  });
+}
+
+/**
+ * Core quality check logic for use by dispatchers or standalone.
+ * @param {Object} data - Parsed hook input (tool_input, etc.)
+ * @returns {null|{output: Object}} null if no checks fired, result otherwise
+ */
+function checkQuality(data) {
+  const filePath = data.tool_input?.file_path || data.tool_input?.path || '';
+  if (!filePath) return null;
+
+  const ext = path.extname(filePath).toLowerCase();
+  if (!JS_TS_EXTENSIONS.has(ext)) return null;
+
+  const cwd = process.cwd();
+  const config = loadHooksConfig(cwd);
+
+  // No quality hooks enabled — early exit
+  if (!config.autoFormat && !config.typeCheck && !config.detectConsoleLogs) return null;
+
+  const messages = [];
+
+  // 1. Auto-format with Prettier
+  if (config.autoFormat) {
+    const msg = runPrettier(filePath, cwd);
+    if (msg) messages.push(msg);
+  }
+
+  // 2. TypeScript type-check (only for .ts/.tsx)
+  if (config.typeCheck && TS_EXTENSIONS.has(ext)) {
+    const msg = runTypeCheck(filePath, cwd);
+    if (msg) messages.push(msg);
+  }
+
+  // 3. Console.log detection
+  if (config.detectConsoleLogs) {
+    const msg = detectConsoleLogs(filePath);
+    if (msg) messages.push(msg);
+  }
+
+  if (messages.length === 0) return null;
+
+  logHook('post-write-quality', 'PostToolUse', 'quality-check', {
+    file: path.basename(filePath),
+    checks: messages.length
+  });
+
+  return {
+    output: {
+      additionalContext: messages.join('\n')
+    }
+  };
+}
+
+/**
+ * Load the hooks section from .planning/config.json.
+ * Returns {} if not found or not configured.
+ */
+function loadHooksConfig(cwd) {
+  const configPath = path.join(cwd, '.planning', 'config.json');
+  if (!fs.existsSync(configPath)) return {};
+  try {
+    const config = JSON.parse(fs.readFileSync(configPath, 'utf8'));
+    return config.hooks || {};
+  } catch (_e) {
+    return {};
+  }
+}
+
+/**
+ * Find a locally installed binary in node_modules/.bin/.
+ * Returns the full path or null if not found.
+ */
+function findLocalBin(cwd, name) {
+  const candidates = process.platform === 'win32'
+    ? [path.join(cwd, 'node_modules', '.bin', name + '.cmd'),
+      path.join(cwd, 'node_modules', '.bin', name)]
+    : [path.join(cwd, 'node_modules', '.bin', name)];
+  return candidates.find(c => fs.existsSync(c)) || null;
+}
+
+/**
+ * Run Prettier on the file. Returns a message string or null.
+ */
+function runPrettier(filePath, cwd) {
+  const bin = findLocalBin(cwd, 'prettier');
+  if (!bin) return null;
+
+  try {
+    execFileSync(bin, ['--write', filePath], {
+      cwd,
+      timeout: 15000,
+      stdio: 'pipe',
+    });
+    return `[Auto-format] Prettier reformatted ${path.basename(filePath)}. File on disk may differ from context — re-read before further edits.`;
+  } catch (_e) {
+    // Prettier failed (syntax error, unsupported file, etc.) — skip
+    return null;
+  }
+}
+
+/**
+ * Run tsc --noEmit and filter to errors in the modified file.
+ * Returns a message string or null.
+ */
+function runTypeCheck(filePath, cwd) {
+  const bin = findLocalBin(cwd, 'tsc');
+  if (!bin) return null;
+  if (!fs.existsSync(path.join(cwd, 'tsconfig.json'))) return null;
+
+  try {
+    execFileSync(bin, ['--noEmit'], {
+      cwd,
+      timeout: 30000,
+      stdio: 'pipe',
+      encoding: 'utf8',
+    });
+    return null; // Clean pass — no errors
+  } catch (e) {
+    const output = (e.stdout || '').toString();
+    const basename = path.basename(filePath);
+    const relevantLines = output.split('\n')
+      .filter(line => line.includes(basename) && /error TS\d+/.test(line));
+
+    if (relevantLines.length === 0) return null;
+    const detail = relevantLines.slice(0, 3).join('\n  ');
+    const extra = relevantLines.length > 3 ? `\n  ...and ${relevantLines.length - 3} more` : '';
+    return `[Type Check] ${relevantLines.length} error(s) in ${basename}:\n  ${detail}${extra}`;
+  }
+}
+
+/**
+ * Scan file for console.log statements. Returns a message string or null.
+ */
+function detectConsoleLogs(filePath) {
+  if (!fs.existsSync(filePath)) return null;
+
+  try {
+    const content = fs.readFileSync(filePath, 'utf8');
+    const lines = content.split('\n');
+    const matches = [];
+
+    for (let i = 0; i < lines.length; i++) {
+      const line = lines[i];
+      if (/^\s*\/\//.test(line)) continue; // skip single-line comments
+      if (/\bconsole\.log\s*\(/.test(line)) {
+        matches.push({ line: i + 1, text: line.trim().substring(0, 80) });
+      }
+    }
+
+    if (matches.length === 0) return null;
+
+    const detail = matches.slice(0, 3).map(m => `  L${m.line}: ${m.text}`).join('\n');
+    const extra = matches.length > 3 ? `\n  ...and ${matches.length - 3} more` : '';
+    return `[Console.log] ${matches.length} console.log(s) in ${path.basename(filePath)}:\n${detail}${extra}`;
+  } catch (_e) {
+    return null;
+  }
+}
+
+module.exports = { checkQuality, loadHooksConfig, findLocalBin, runPrettier, runTypeCheck, detectConsoleLogs };
+if (require.main === module || process.argv[1] === __filename) { main(); }

package/plugins/pbr/dist/pre-bash-dispatch.js

@@ -0,0 +1,212 @@
+#!/usr/bin/env node
+
+/**
+ * PreToolUse dispatcher for Bash hooks.
+ *
+ * Consolidates check-dangerous-commands.js and validate-commit.js
+ * into a single process, reading stdin once and routing to both
+ * checks sequentially. This halves the process spawns per Bash call.
+ *
+ * -- Dispatch Order & Rationale --
+ *
+ *   1. check-dangerous-commands -- Blocks destructive shell operations
+ *      (rm -rf, git push --force, etc.). Runs first because safety
+ *      takes priority: if a command is dangerous, we must reject it
+ *      before even considering whether its commit message is valid.
+ *      Can block (exit 2).
+ *
+ *   2. validate-commit          -- Enforces conventional commit format
+ *      ({type}({scope}): {desc}) on git commit commands. Runs second
+ *      because commit format validation is only relevant for git
+ *      commit operations, a narrow subset of all Bash calls. There's
+ *      no benefit to checking format if the command was already
+ *      blocked as dangerous. Can block (exit 2).
+ *
+ * -- Short-Circuit Behavior --
+ *
+ *   If an earlier check returns a result (blocking with exit 2),
+ *   later checks are skipped entirely. The first failure is the
+ *   most relevant -- a dangerous command should be blocked regardless
+ *   of whether it also has a valid commit message.
+ *
+ * -- Adding New Checks --
+ *
+ *   1. Create a new check module exporting a function that takes
+ *      the parsed hook data and returns null (pass) or
+ *      { output: {...}, exitCode: N }.
+ *   2. require() it at the top of this file.
+ *   3. Add the call in sequence below, following the pattern:
+ *        const result = checkFoo(data);
+ *        if (result) { log; write output; exit with code; }
+ *   4. Position the check based on severity: safety-critical checks
+ *      should run earlier; format/style checks should run later.
+ *
+ * Exit codes:
+ *   0 = allowed or warning only
+ *   2 = blocked (dangerous command or invalid commit format)
+ */
+
+const { logHook } = require('./hook-logger');
+const { checkDangerous } = require('./check-dangerous-commands');
+const { checkCommit } = require('./validate-commit');
+const { checkUnmanagedCommit } = require('./enforce-pbr-workflow');
+const { checkRequirePaths, checkMirrorSync, checkLintErrors } = require('./lib/pre-commit-checks');
+// Cross-plugin sync disabled -- derivative plugins updated separately
+// const { checkCrossPluginSync } = require('./check-cross-plugin-sync');
+
+/**
+ * Core dispatch logic extracted for both stdin (main) and HTTP (handleHttp) paths.
+ *
+ * Runs all checks sequentially. Block decisions short-circuit immediately.
+ * Warnings are collected and merged into a single advisory response.
+ *
+ * @param {Object} data - Parsed hook input (same as stdin JSON)
+ * @returns {Promise<Object|null>} Hook response: { decision: 'block', reason } or { decision: 'allow', additionalContext? } or null
+ */
+async function processEvent(data) {
+  try {
+    // Dangerous commands check first -- can block
+    const dangerousResult = checkDangerous(data);
+    if (dangerousResult) {
+      logHook('pre-bash-dispatch', 'PreToolUse', 'dispatched', { handler: 'check-dangerous-commands' });
+      if (dangerousResult.exitCode === 2) {
+        return { decision: 'block', reason: dangerousResult.output.reason || dangerousResult.output.additionalContext || 'Dangerous command blocked' };
+      }
+    }
+
+    // Commit validation check -- can block
+    const commitResult = checkCommit(data);
+    if (commitResult) {
+      logHook('pre-bash-dispatch', 'PreToolUse', 'dispatched', { handler: 'validate-commit' });
+      if (commitResult.exitCode === 2) {
+        return { decision: 'block', reason: commitResult.output.reason || commitResult.output.additionalContext || 'Invalid commit format' };
+      }
+      // exitCode 0 with output = warning
+      if (commitResult.output && commitResult.output.additionalContext) {
+        // Collect as warning below
+      }
+    }
+
+    // Soft warnings for risky-but-allowed commands
+    const command = data.tool_input?.command || '';
+    const warnings = [];
+
+    // Carry forward commit warning if it was advisory (exitCode 0)
+    if (commitResult && commitResult.exitCode === 0 && commitResult.output && commitResult.output.additionalContext) {
+      warnings.push(commitResult.output.additionalContext);
+    }
+
+    if (command) {
+      // Warn about npm publish / deploy commands
+      if (/\bnpm\s+publish\b/.test(command)) {
+        warnings.push('npm publish detected -- ensure version is correct before publishing');
+      }
+
+      // Warn about touching production config files
+      if (/\b(production|prod)\b.*\.(json|ya?ml|env|conf|cfg)\b/i.test(command) ||
+          /\.(json|ya?ml|env|conf|cfg)\b.*\b(production|prod)\b/i.test(command)) {
+        warnings.push('command references production config files -- verify you are not in a live environment');
+      }
+
+      // Warn about database operations
+      if (/\b(DROP|TRUNCATE|DELETE\s+FROM|ALTER\s+TABLE)\b/i.test(command)) {
+        warnings.push('destructive database operation (DROP/TRUNCATE/DELETE/ALTER) -- verify correct database is targeted and a backup exists');
+      }
+    }
+
+    // Pre-commit quality checks -- advisory only, on git commit commands
+    if (/\bgit\s+commit\b/.test(command)) {
+      const pathResult = checkRequirePaths(data);
+      if (pathResult) warnings.push(...pathResult.warnings);
+
+      const mirrorResult = checkMirrorSync(data);
+      if (mirrorResult) warnings.push(...mirrorResult.warnings);
+
+      const lintResult = checkLintErrors(data);
+      if (lintResult) warnings.push(...lintResult.warnings);
+    }
+
+    // Unmanaged commit advisory -- warn when git commit runs without PBR skill
+    const unmanagedCommitResult = checkUnmanagedCommit(data);
+    if (unmanagedCommitResult) {
+      warnings.push(unmanagedCommitResult.output.additionalContext);
+    }
+
+    // Cross-plugin sync advisory -- disabled (derivative plugins updated separately)
+    // const syncResult = checkCrossPluginSync(data);
+    // if (syncResult) {
+    //   warnings.push(syncResult.additionalContext);
+    // }
+
+    if (warnings.length > 0) {
+      logHook('pre-bash-dispatch', 'PreToolUse', 'warn', { warnings: warnings.length, cmd: command.substring(0, 80) });
+      return {
+        decision: 'allow',
+        additionalContext: `[pbr] Advisory: ${warnings.join('; ')}.`
+      };
+    }
+
+    // Log pass-through so hook activity is visible in logs AND session JSONL
+    logHook('pre-bash-dispatch', 'PreToolUse', 'allow', { cmd: command.substring(0, 80) });
+    return { decision: 'allow' };
+  } catch (e) {
+    logHook('pre-bash-dispatch', 'PreToolUse', 'error', { error: e.message });
+    return null;
+  }
+}
+
+/**
+ * HTTP handler for hook-server.js.
+ * Called as handleHttp(reqBody, cache) where reqBody = { event, tool, data, planningDir, cache }.
+ * Must NOT call process.exit().
+ *
+ * @param {Object} reqBody - Request body from hook-server
+ * @param {Object} _cache - In-memory server cache (unused)
+ * @returns {Promise<Object|null>} Hook response or null
+ */
+async function handleHttp(reqBody, _cache) {
+  const data = reqBody.data || {};
+  try {
+    return await processEvent(data);
+  } catch (_e) {
+    logHook('pre-bash-dispatch', 'PreToolUse', 'error', { error: _e.message });
+    return null;
+  }
+}
+
+module.exports = { handleHttp, processEvent };
+
+function main() {
+  let input = '';
+
+  process.stdin.setEncoding('utf8');
+  process.stdin.on('data', (chunk) => { input += chunk; });
+  process.stdin.on('end', async () => {
+    try {
+      const data = JSON.parse(input);
+
+      const result = await processEvent(data);
+
+      if (result && result.decision === 'block') {
+        process.stdout.write(JSON.stringify(result));
+        process.exit(2);
+      }
+
+      if (result) {
+        process.stdout.write(JSON.stringify(result));
+      } else {
+        // processEvent returned null (error) -- allow through
+        process.stdout.write(JSON.stringify({ decision: 'allow' }));
+      }
+      process.exit(0);
+    } catch (e) {
+      // Don't block on errors -- but emit valid output so Claude Code
+      // doesn't report "hook error" for silent exit
+      process.stderr.write(`[pbr] pre-bash-dispatch error: ${e.message}\n`);
+      process.stdout.write(JSON.stringify({ decision: 'allow', additionalContext: '\u26a0 [PBR] pre-bash-dispatch failed: ' + e.message }));
+      process.exit(0);
+    }
+  });
+}
+
+if (require.main === module || process.argv[1] === __filename) { main(); }

package/plugins/pbr/dist/pre-skill-dispatch.js

@@ -0,0 +1,114 @@
+#!/usr/bin/env node
+
+/**
+ * PreToolUse dispatcher for Skill hooks.
+ *
+ * Consolidates enforce-context-budget.js and validate-skill-args.js
+ * into a single process, reading stdin once and routing to both
+ * checks sequentially. Budget check runs first (cheap) and
+ * short-circuits before skill argument validation.
+ *
+ * ── Dispatch Order & Rationale ──────────────────────────────────
+ *
+ *   1. enforce-context-budget — Blocks Skill invocations when context
+ *      usage exceeds the hard_stop_percent threshold. Runs first
+ *      because it is a cheap file read that can short-circuit before
+ *      argument validation.
+ *
+ *   2. validate-skill-args   — Validates skill arguments (phase
+ *      number existence, freeform text detection for /pbr:plan-phase).
+ *      Can block (exit 2) or allow (exit 0).
+ *
+ * Exit codes:
+ *   0 = allowed or warning only
+ *   2 = blocked (budget exceeded or invalid skill args)
+ */
+
+const path = require('path');
+const { logHook } = require('./hook-logger');
+const { checkBudget } = require('./enforce-context-budget');
+const { checkSkillArgs } = require('./validate-skill-args');
+
+/**
+ * Core dispatch logic for PreToolUse:Skill events.
+ *
+ * Step 1: Budget check (cheap, fast — short-circuits on block)
+ * Step 2: Skill argument validation
+ * Step 3: All clear
+ *
+ * @param {Object} data - Parsed hook event data
+ * @returns {Object} { decision: 'block'|'allow', reason?: string, additionalContext?: string }
+ */
+async function processEvent(data) {
+  // Step 1 — Budget check (cheap, fast)
+  const planningDir = path.join(data.cwd || process.env.PBR_PROJECT_ROOT || process.cwd(), '.planning');
+  const budgetResult = checkBudget({ toolName: 'Skill', planningDir });
+  if (budgetResult) {
+    logHook('pre-skill-dispatch', 'PreToolUse', 'blocked', { handler: 'enforce-context-budget' });
+    return budgetResult; // already { decision: 'block', reason: '...' }
+  }
+
+  // Step 2 — Skill argument validation
+  const skillResult = checkSkillArgs(data);
+  if (skillResult) {
+    if (skillResult.exitCode === 2) {
+      // Blocking result
+      logHook('pre-skill-dispatch', 'PreToolUse', 'blocked', { handler: 'validate-skill-args' });
+      return skillResult.output; // { decision: 'block', reason: '...' }
+    }
+    // Advisory result (exitCode 0 with output)
+    if (skillResult.output) {
+      logHook('pre-skill-dispatch', 'PreToolUse', 'warn', { handler: 'validate-skill-args' });
+      return skillResult.output;
+    }
+  }
+
+  // Step 3 — All clear
+  logHook('pre-skill-dispatch', 'PreToolUse', 'allow', {});
+  return { decision: 'allow' };
+}
+
+/**
+ * HTTP handler for hook-server integration.
+ *
+ * @param {Object} reqBody - HTTP request body with { data: {...} }
+ * @param {Object} _cache - Hook server cache (unused)
+ * @returns {Object|null} Hook result or null on error
+ */
+async function handleHttp(reqBody, _cache) {
+  try {
+    const data = reqBody.data || {};
+    return await processEvent(data);
+  } catch (_e) {
+    return null;
+  }
+}
+
+function main() {
+  let input = '';
+
+  process.stdin.setEncoding('utf8');
+  process.stdin.on('data', (chunk) => { input += chunk; });
+  process.stdin.on('end', async () => {
+    try {
+      const data = JSON.parse(input);
+      const result = await processEvent(data);
+
+      if (result && result.decision === 'block') {
+        process.stdout.write(JSON.stringify(result));
+        process.exit(2);
+        return;
+      }
+
+      process.stdout.write(JSON.stringify(result || {}));
+      process.exit(0);
+    } catch (_e) {
+      process.stderr.write(`[pbr] pre-skill-dispatch error: ${_e.message}\n`);
+      process.stdout.write(JSON.stringify({ decision: 'allow', additionalContext: '[PBR] pre-skill-dispatch failed: ' + _e.message }));
+      process.exit(0);
+    }
+  });
+}
+
+module.exports = { handleHttp, processEvent };
+if (require.main === module || process.argv[1] === __filename) { main(); }