@sienklogic/plan-build-run 2.0.0 → 2.0.1

package/plugins/pbr/scripts/auto-continue.js

@@ -1,80 +1,80 @@
-#!/usr/bin/env node
-
-/**
- * Stop hook: Auto-continue via signal files.
- *
- * When enabled (features.auto_continue: true in config.json),
- * reads .planning/.auto-next signal file on session stop.
- * If present, reads the next command and injects it.
- * Signal file is ONE-SHOT: read and delete to prevent infinite loops.
- *
- * Hard stops (signal file NOT written):
- * - Milestone completion
- * - human_needed flag set
- * - Execution errors
- * - Gap closure attempted 3+ times
- */
-
-const fs = require('fs');
-const path = require('path');
-const { logHook } = require('./hook-logger');
-const { configLoad } = require('./pbr-tools');
-
-function main() {
-  try {
-    const cwd = process.cwd();
-    const planningDir = path.join(cwd, '.planning');
-    const signalPath = path.join(planningDir, '.auto-next');
-
-    // Check if auto-continue is enabled
-    const config = configLoad(planningDir);
-    if (!config || !config.features || !config.features.auto_continue) {
-      process.exit(0);
-    }
-
-    // Check for signal file
-    if (!fs.existsSync(signalPath)) {
-      logHook('auto-continue', 'Stop', 'no-signal', {});
-      process.exit(0);
-    }
-
-    // Read and DELETE the signal file (one-shot)
-    const nextCommand = fs.readFileSync(signalPath, 'utf8').trim();
-    // Retry unlink with exponential backoff for Windows file locking (antivirus/indexer)
-    for (let attempt = 0; attempt < 3; attempt++) {
-      try {
-        fs.unlinkSync(signalPath);
-        break;
-      } catch (unlinkErr) {
-        if (attempt === 2) {
-          logHook('auto-continue', 'Stop', 'unlink-failed', { error: unlinkErr.message });
-        } else {
-          // Exponential backoff: 100ms, 200ms
-          const delay = 100 * Math.pow(2, attempt);
-          const start = Date.now();
-          while (Date.now() - start < delay) { /* busy-wait */ }
-        }
-      }
-    }
-
-    if (!nextCommand) {
-      logHook('auto-continue', 'Stop', 'empty-signal', {});
-      process.exit(0);
-    }
-
-    logHook('auto-continue', 'Stop', 'continue', { next: nextCommand });
-
-    // Output the next command for Claude Code to execute
-    const output = {
-      message: `Auto-continuing with: ${nextCommand}`,
-      command: nextCommand
-    };
-    process.stdout.write(JSON.stringify(output));
-    process.exit(0);
-  } catch (_e) {
-    // Don't block on errors
-    process.exit(0);
-  }
-}
-
-main();
+#!/usr/bin/env node
+
+/**
+ * Stop hook: Auto-continue via signal files.
+ *
+ * When enabled (features.auto_continue: true in config.json),
+ * reads .planning/.auto-next signal file on session stop.
+ * If present, reads the next command and injects it.
+ * Signal file is ONE-SHOT: read and delete to prevent infinite loops.
+ *
+ * Hard stops (signal file NOT written):
+ * - Milestone completion
+ * - human_needed flag set
+ * - Execution errors
+ * - Gap closure attempted 3+ times
+ */
+
+const fs = require('fs');
+const path = require('path');
+const { logHook } = require('./hook-logger');
+const { configLoad } = require('./pbr-tools');
+
+function main() {
+  try {
+    const cwd = process.cwd();
+    const planningDir = path.join(cwd, '.planning');
+    const signalPath = path.join(planningDir, '.auto-next');
+
+    // Check if auto-continue is enabled
+    const config = configLoad(planningDir);
+    if (!config || !config.features || !config.features.auto_continue) {
+      process.exit(0);
+    }
+
+    // Check for signal file
+    if (!fs.existsSync(signalPath)) {
+      logHook('auto-continue', 'Stop', 'no-signal', {});
+      process.exit(0);
+    }
+
+    // Read and DELETE the signal file (one-shot)
+    const nextCommand = fs.readFileSync(signalPath, 'utf8').trim();
+    // Retry unlink with exponential backoff for Windows file locking (antivirus/indexer)
+    for (let attempt = 0; attempt < 3; attempt++) {
+      try {
+        fs.unlinkSync(signalPath);
+        break;
+      } catch (unlinkErr) {
+        if (attempt === 2) {
+          logHook('auto-continue', 'Stop', 'unlink-failed', { error: unlinkErr.message });
+        } else {
+          // Exponential backoff: 100ms, 200ms
+          const delay = 100 * Math.pow(2, attempt);
+          const start = Date.now();
+          while (Date.now() - start < delay) { /* busy-wait */ }
+        }
+      }
+    }
+
+    if (!nextCommand) {
+      logHook('auto-continue', 'Stop', 'empty-signal', {});
+      process.exit(0);
+    }
+
+    logHook('auto-continue', 'Stop', 'continue', { next: nextCommand });
+
+    // Output the next command for Claude Code to execute
+    const output = {
+      message: `Auto-continuing with: ${nextCommand}`,
+      command: nextCommand
+    };
+    process.stdout.write(JSON.stringify(output));
+    process.exit(0);
+  } catch (_e) {
+    // Don't block on errors
+    process.exit(0);
+  }
+}
+
+main();

package/plugins/pbr/scripts/check-dangerous-commands.js

@@ -1,136 +1,136 @@
-#!/usr/bin/env node
-
-/**
- * PreToolUse hook: Blocks dangerous Bash commands that could destroy
- * planning state or repository integrity.
- *
- * Patterns blocked (exit 2):
- *   - rm -rf .planning (or any rm that targets .planning/)
- *   - git reset --hard
- *   - git push --force / -f to main/master
- *   - git clean -fd / -fxd (removes untracked files including .planning/)
- *
- * Patterns warned (exit 0, additionalContext):
- *   - Large rm operations (rm -rf on project directories)
- *   - git checkout -- . (discards all unstaged changes)
- *
- * Exit codes:
- *   0 = not a dangerous command, or a warning-only match
- *   2 = blocked (destructive command detected)
- */
-
-const { logHook } = require('./hook-logger');
-
-// Commands that are outright blocked
-const BLOCK_PATTERNS = [
-  {
-    pattern: /\brm\s+(-[a-zA-Z]*r[a-zA-Z]*f[a-zA-Z]*|-[a-zA-Z]*f[a-zA-Z]*r[a-zA-Z]*)\s+.*\.planning\b/,
-    reason: 'rm -rf targeting .planning/ directory — this would destroy all project state.'
-  },
-  {
-    pattern: /\brm\s+(-[a-zA-Z]*r[a-zA-Z]*f[a-zA-Z]*|-[a-zA-Z]*f[a-zA-Z]*r[a-zA-Z]*)\s+.*\.planning[/\\]/,
-    reason: 'rm -rf targeting files inside .planning/ — this would destroy project state.'
-  },
-  {
-    pattern: /\bgit\s+reset\s+--hard\b/,
-    reason: 'git reset --hard discards all uncommitted changes. Use git stash or git checkout for specific files instead.'
-  },
-  {
-    pattern: /\bgit\s+push\s+.*(-f|--force)\b.*\b(main|master)\b/,
-    reason: 'Force-pushing to main/master can destroy shared history. This is almost never what you want.'
-  },
-  {
-    pattern: /\bgit\s+push\s+.*\b(main|master)\b.*(-f|--force)\b/,
-    reason: 'Force-pushing to main/master can destroy shared history. This is almost never what you want.'
-  },
-  {
-    pattern: /\bgit\s+clean\s+(-[a-zA-Z]*f[a-zA-Z]*d|-[a-zA-Z]*d[a-zA-Z]*f)\b/,
-    reason: 'git clean -fd removes untracked files including .planning/ contents. Use specific file paths instead.'
-  }
-];
-
-// Commands that produce warnings but are not blocked
-const WARN_PATTERNS = [
-  {
-    pattern: /\bgit\s+checkout\s+--\s+\.\s*$/,
-    message: 'git checkout -- . discards ALL unstaged changes. Consider targeting specific files.'
-  },
-  {
-    pattern: /\bgit\s+push\s+.*(-f|--force)\b/,
-    message: 'Force-pushing can overwrite remote history. Ensure this is intentional.'
-  }
-];
-
-/**
- * Check a parsed hook data object for dangerous commands.
- * Returns { output, exitCode } if the command should be blocked/warned, or null if allowed.
- * Used by pre-bash-dispatch.js for consolidated hook execution.
- */
-function checkDangerous(data) {
-  const command = data.tool_input?.command || '';
-
-  // Skip empty commands
-  if (!command.trim()) {
-    return null;
-  }
-
-  // Check block patterns
-  for (const { pattern, reason } of BLOCK_PATTERNS) {
-    if (pattern.test(command)) {
-      logHook('check-dangerous-commands', 'PreToolUse', 'block', {
-        command: command.substring(0, 200),
-        reason
-      });
-      return {
-        output: {
-          decision: 'block',
-          reason: `Dangerous command blocked.\n\n${reason}\n\nCommand: ${command.substring(0, 150)}`
-        },
-        exitCode: 2
-      };
-    }
-  }
-
-  // Check warn patterns
-  for (const { pattern, message } of WARN_PATTERNS) {
-    if (pattern.test(command)) {
-      logHook('check-dangerous-commands', 'PreToolUse', 'warn', {
-        command: command.substring(0, 200),
-        warning: message
-      });
-      return {
-        output: {
-          additionalContext: `Warning: ${message}`
-        },
-        exitCode: 0
-      };
-    }
-  }
-
-  // No match — allow
-  return null;
-}
-
-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 = checkDangerous(data);
-      if (result) {
-        process.stdout.write(JSON.stringify(result.output));
-        process.exit(result.exitCode);
-      }
-      process.exit(0);
-    } catch (_e) {
-      // Parse error — don't block
-      process.exit(0);
-    }
-  });
-}
-
-module.exports = { BLOCK_PATTERNS, WARN_PATTERNS, checkDangerous };
-if (require.main === module) { main(); }
+#!/usr/bin/env node
+
+/**
+ * PreToolUse hook: Blocks dangerous Bash commands that could destroy
+ * planning state or repository integrity.
+ *
+ * Patterns blocked (exit 2):
+ *   - rm -rf .planning (or any rm that targets .planning/)
+ *   - git reset --hard
+ *   - git push --force / -f to main/master
+ *   - git clean -fd / -fxd (removes untracked files including .planning/)
+ *
+ * Patterns warned (exit 0, additionalContext):
+ *   - Large rm operations (rm -rf on project directories)
+ *   - git checkout -- . (discards all unstaged changes)
+ *
+ * Exit codes:
+ *   0 = not a dangerous command, or a warning-only match
+ *   2 = blocked (destructive command detected)
+ */
+
+const { logHook } = require('./hook-logger');
+
+// Commands that are outright blocked
+const BLOCK_PATTERNS = [
+  {
+    pattern: /\brm\s+(-[a-zA-Z]*r[a-zA-Z]*f[a-zA-Z]*|-[a-zA-Z]*f[a-zA-Z]*r[a-zA-Z]*)\s+.*\.planning\b/,
+    reason: 'rm -rf targeting .planning/ directory — this would destroy all project state.'
+  },
+  {
+    pattern: /\brm\s+(-[a-zA-Z]*r[a-zA-Z]*f[a-zA-Z]*|-[a-zA-Z]*f[a-zA-Z]*r[a-zA-Z]*)\s+.*\.planning[/\\]/,
+    reason: 'rm -rf targeting files inside .planning/ — this would destroy project state.'
+  },
+  {
+    pattern: /\bgit\s+reset\s+--hard\b/,
+    reason: 'git reset --hard discards all uncommitted changes. Use git stash or git checkout for specific files instead.'
+  },
+  {
+    pattern: /\bgit\s+push\s+.*(-f|--force)\b.*\b(main|master)\b/,
+    reason: 'Force-pushing to main/master can destroy shared history. This is almost never what you want.'
+  },
+  {
+    pattern: /\bgit\s+push\s+.*\b(main|master)\b.*(-f|--force)\b/,
+    reason: 'Force-pushing to main/master can destroy shared history. This is almost never what you want.'
+  },
+  {
+    pattern: /\bgit\s+clean\s+(-[a-zA-Z]*f[a-zA-Z]*d|-[a-zA-Z]*d[a-zA-Z]*f)\b/,
+    reason: 'git clean -fd removes untracked files including .planning/ contents. Use specific file paths instead.'
+  }
+];
+
+// Commands that produce warnings but are not blocked
+const WARN_PATTERNS = [
+  {
+    pattern: /\bgit\s+checkout\s+--\s+\.\s*$/,
+    message: 'git checkout -- . discards ALL unstaged changes. Consider targeting specific files.'
+  },
+  {
+    pattern: /\bgit\s+push\s+.*(-f|--force)\b/,
+    message: 'Force-pushing can overwrite remote history. Ensure this is intentional.'
+  }
+];
+
+/**
+ * Check a parsed hook data object for dangerous commands.
+ * Returns { output, exitCode } if the command should be blocked/warned, or null if allowed.
+ * Used by pre-bash-dispatch.js for consolidated hook execution.
+ */
+function checkDangerous(data) {
+  const command = data.tool_input?.command || '';
+
+  // Skip empty commands
+  if (!command.trim()) {
+    return null;
+  }
+
+  // Check block patterns
+  for (const { pattern, reason } of BLOCK_PATTERNS) {
+    if (pattern.test(command)) {
+      logHook('check-dangerous-commands', 'PreToolUse', 'block', {
+        command: command.substring(0, 200),
+        reason
+      });
+      return {
+        output: {
+          decision: 'block',
+          reason: `Dangerous command blocked.\n\n${reason}\n\nCommand: ${command.substring(0, 150)}`
+        },
+        exitCode: 2
+      };
+    }
+  }
+
+  // Check warn patterns
+  for (const { pattern, message } of WARN_PATTERNS) {
+    if (pattern.test(command)) {
+      logHook('check-dangerous-commands', 'PreToolUse', 'warn', {
+        command: command.substring(0, 200),
+        warning: message
+      });
+      return {
+        output: {
+          additionalContext: `Warning: ${message}`
+        },
+        exitCode: 0
+      };
+    }
+  }
+
+  // No match — allow
+  return null;
+}
+
+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 = checkDangerous(data);
+      if (result) {
+        process.stdout.write(JSON.stringify(result.output));
+        process.exit(result.exitCode);
+      }
+      process.exit(0);
+    } catch (_e) {
+      // Parse error — don't block
+      process.exit(0);
+    }
+  });
+}
+
+module.exports = { BLOCK_PATTERNS, WARN_PATTERNS, checkDangerous };
+if (require.main === module) { main(); }

package/plugins/pbr/scripts/check-doc-sprawl.js

@@ -1,102 +1,102 @@
-#!/usr/bin/env node
-
-/**
- * PreToolUse check: Blocks creation of new .md/.txt documentation files
- * outside a known allowlist, preventing doc sprawl during builds.
- *
- * Opt-in via .planning/config.json: { "hooks": { "blockDocSprawl": true } }
- *
- * Allowlist:
- *   - README.md, CLAUDE.md, CONTRIBUTING.md, CHANGELOG.md, LICENSE.md, LICENSE, LICENSE.txt
- *   - Any file under .planning/, .claude/, node_modules/, .git/
- *   - Any file that already exists (edits to existing docs are always allowed)
- *
- * Called by pre-write-dispatch.js — not wired directly in hooks.json.
- *
- * Exit codes (when standalone):
- *   0 = pass (allowed)
- *   2 = block (not on allowlist)
- */
-
-const fs = require('fs');
-const path = require('path');
-const { logHook } = require('./hook-logger');
-
-const ALLOWED_DOC_BASENAMES = new Set([
-  'readme.md',
-  'claude.md',
-  'contributing.md',
-  'changelog.md',
-  'license.md',
-  'license',
-  'license.txt',
-]);
-
-const ALLOWED_DIR_SEGMENTS = [
-  '.planning',
-  '.claude',
-  'node_modules',
-  '.git',
-];
-
-const DOC_EXTENSIONS = new Set(['.md', '.txt']);
-
-/**
- * Check if a Write operation would create a disallowed documentation file.
- * @param {Object} data - Parsed hook input (tool_input, etc.)
- * @param {string} [cwd] - Working directory override (defaults to process.cwd())
- * @returns {null|{exitCode: number, output: Object}} null if allowed, block result otherwise
- */
-function checkDocSprawl(data, cwd) {
-  const filePath = data.tool_input?.file_path || data.tool_input?.path || '';
-  if (!filePath) return null;
-
-  const ext = path.extname(filePath).toLowerCase();
-  if (!DOC_EXTENSIONS.has(ext)) return null;
-
-  // Only block NEW file creation — existing docs can always be edited
-  if (fs.existsSync(filePath)) return null;
-
-  // Check config — disabled by default
-  const effectiveCwd = cwd || process.cwd();
-  if (!isBlockDocSprawlEnabled(effectiveCwd)) return null;
-
-  // Check basename allowlist
-  const basename = path.basename(filePath).toLowerCase();
-  if (ALLOWED_DOC_BASENAMES.has(basename)) return null;
-
-  // Check if file is in an allowed directory
-  const normalized = filePath.replace(/\\/g, '/');
-  for (const seg of ALLOWED_DIR_SEGMENTS) {
-    if (normalized.includes(`/${seg}/`)) return null;
-  }
-
-  logHook('check-doc-sprawl', 'PreToolUse', 'block', {
-    file: path.basename(filePath),
-    ext
-  });
-
-  return {
-    exitCode: 2,
-    output: {
-      decision: 'block',
-      reason: `[Doc Sprawl] Blocked creation of ${path.basename(filePath)}. ` +
-        'Only known docs (README.md, CLAUDE.md, CONTRIBUTING.md, CHANGELOG.md, LICENSE.md) ' +
-        'and .planning/ files are allowed when blockDocSprawl is enabled. ' +
-        'Add content to an existing file instead, or disable hooks.blockDocSprawl in config.'
-    }
-  };
-}
-
-function isBlockDocSprawlEnabled(cwd) {
-  try {
-    const configPath = path.join(cwd, '.planning', 'config.json');
-    if (!fs.existsSync(configPath)) return false;
-    const config = JSON.parse(fs.readFileSync(configPath, 'utf8'));
-    return !!config.hooks?.blockDocSprawl;
-  } catch (_e) {
-    return false;
-  }
-}
-
-module.exports = { checkDocSprawl, isBlockDocSprawlEnabled, ALLOWED_DOC_BASENAMES, ALLOWED_DIR_SEGMENTS, DOC_EXTENSIONS };
+#!/usr/bin/env node
+
+/**
+ * PreToolUse check: Blocks creation of new .md/.txt documentation files
+ * outside a known allowlist, preventing doc sprawl during builds.
+ *
+ * Opt-in via .planning/config.json: { "hooks": { "blockDocSprawl": true } }
+ *
+ * Allowlist:
+ *   - README.md, CLAUDE.md, CONTRIBUTING.md, CHANGELOG.md, LICENSE.md, LICENSE, LICENSE.txt
+ *   - Any file under .planning/, .claude/, node_modules/, .git/
+ *   - Any file that already exists (edits to existing docs are always allowed)
+ *
+ * Called by pre-write-dispatch.js — not wired directly in hooks.json.
+ *
+ * Exit codes (when standalone):
+ *   0 = pass (allowed)
+ *   2 = block (not on allowlist)
+ */
+
+const fs = require('fs');
+const path = require('path');
+const { logHook } = require('./hook-logger');
+
+const ALLOWED_DOC_BASENAMES = new Set([
+  'readme.md',
+  'claude.md',
+  'contributing.md',
+  'changelog.md',
+  'license.md',
+  'license',
+  'license.txt',
+]);
+
+const ALLOWED_DIR_SEGMENTS = [
+  '.planning',
+  '.claude',
+  'node_modules',
+  '.git',
+];
+
+const DOC_EXTENSIONS = new Set(['.md', '.txt']);
+
+/**
+ * Check if a Write operation would create a disallowed documentation file.
+ * @param {Object} data - Parsed hook input (tool_input, etc.)
+ * @param {string} [cwd] - Working directory override (defaults to process.cwd())
+ * @returns {null|{exitCode: number, output: Object}} null if allowed, block result otherwise
+ */
+function checkDocSprawl(data, cwd) {
+  const filePath = data.tool_input?.file_path || data.tool_input?.path || '';
+  if (!filePath) return null;
+
+  const ext = path.extname(filePath).toLowerCase();
+  if (!DOC_EXTENSIONS.has(ext)) return null;
+
+  // Only block NEW file creation — existing docs can always be edited
+  if (fs.existsSync(filePath)) return null;
+
+  // Check config — disabled by default
+  const effectiveCwd = cwd || process.cwd();
+  if (!isBlockDocSprawlEnabled(effectiveCwd)) return null;
+
+  // Check basename allowlist
+  const basename = path.basename(filePath).toLowerCase();
+  if (ALLOWED_DOC_BASENAMES.has(basename)) return null;
+
+  // Check if file is in an allowed directory
+  const normalized = filePath.replace(/\\/g, '/');
+  for (const seg of ALLOWED_DIR_SEGMENTS) {
+    if (normalized.includes(`/${seg}/`)) return null;
+  }
+
+  logHook('check-doc-sprawl', 'PreToolUse', 'block', {
+    file: path.basename(filePath),
+    ext
+  });
+
+  return {
+    exitCode: 2,
+    output: {
+      decision: 'block',
+      reason: `[Doc Sprawl] Blocked creation of ${path.basename(filePath)}. ` +
+        'Only known docs (README.md, CLAUDE.md, CONTRIBUTING.md, CHANGELOG.md, LICENSE.md) ' +
+        'and .planning/ files are allowed when blockDocSprawl is enabled. ' +
+        'Add content to an existing file instead, or disable hooks.blockDocSprawl in config.'
+    }
+  };
+}
+
+function isBlockDocSprawlEnabled(cwd) {
+  try {
+    const configPath = path.join(cwd, '.planning', 'config.json');
+    if (!fs.existsSync(configPath)) return false;
+    const config = JSON.parse(fs.readFileSync(configPath, 'utf8'));
+    return !!config.hooks?.blockDocSprawl;
+  } catch (_e) {
+    return false;
+  }
+}
+
+module.exports = { checkDocSprawl, isBlockDocSprawlEnabled, ALLOWED_DOC_BASENAMES, ALLOWED_DIR_SEGMENTS, DOC_EXTENSIONS };