@sienklogic/plan-build-run 2.0.0 → 2.0.1

package/plugins/pbr/scripts/event-handler.js

@@ -1,151 +1,151 @@
-#!/usr/bin/env node
-
-/**
- * SubagentStop event handler for auto-verification triggering.
- *
- * Detects executor agent completion and conditionally queues verification
- * by writing a .auto-verify signal file. Respects depth profile and
- * config.features.goal_verification setting.
- *
- * Non-blocking — exits 0 always.
- */
-
-const fs = require('fs');
-const path = require('path');
-const { logHook } = require('./hook-logger');
-const { logEvent } = require('./event-logger');
-// configLoad not used here to avoid mtime-based cache issues across directories.
-// Config is read directly in shouldAutoVerify().
-
-function readStdin() {
-  try {
-    const input = fs.readFileSync(0, 'utf8').trim();
-    if (input) return JSON.parse(input);
-  } catch (_e) {
-    // empty or non-JSON stdin
-  }
-  return {};
-}
-
-/**
- * Check if the stdin data represents an executor agent completion.
- * @param {object} data - Parsed stdin JSON from SubagentStop event
- * @returns {boolean}
- */
-function isExecutorAgent(data) {
-  const agentType = data.agent_type || data.subagent_type || null;
-  return agentType === 'pbr:executor';
-}
-
-/**
- * Determine whether auto-verification should run based on config.
- * @param {string} planningDir - Path to .planning directory
- * @returns {boolean}
- */
-function shouldAutoVerify(planningDir) {
-  // Read config directly instead of using configLoad to avoid mtime-based
-  // cache issues when called repeatedly with different planning directories.
-  const configPath = path.join(planningDir, 'config.json');
-  let config;
-  try {
-    if (!fs.existsSync(configPath)) return false;
-    config = JSON.parse(fs.readFileSync(configPath, 'utf8'));
-  } catch (_e) {
-    return false;
-  }
-  if (config === null) return false;
-
-  // Check explicit goal_verification toggle
-  if (config.features && config.features.goal_verification === false) return false;
-
-  // Check depth profile
-  const depth = (config.depth || 'standard').toLowerCase();
-  if (depth === 'quick') return false;
-
-  // "standard", "comprehensive", and any other depth default to true
-  return true;
-}
-
-/**
- * Parse current phase info from STATE.md.
- * @param {string} planningDir - Path to .planning directory
- * @returns {{ phase: number, total: number, status: string } | null}
- */
-function getPhaseFromState(planningDir) {
-  const statePath = path.join(planningDir, 'STATE.md');
-  try {
-    if (!fs.existsSync(statePath)) return null;
-    const content = fs.readFileSync(statePath, 'utf8');
-
-    const phaseMatch = content.match(/Phase:\s*(\d+)\s+of\s+(\d+)/);
-    if (!phaseMatch) return null;
-
-    const statusMatch = content.match(/\*{0,2}(?:Phase\s+)?Status\*{0,2}:\s*["']?(\w+)["']?/i);
-    const status = statusMatch ? statusMatch[1] : null;
-
-    return {
-      phase: parseInt(phaseMatch[1], 10),
-      total: parseInt(phaseMatch[2], 10),
-      status: status
-    };
-  } catch (_e) {
-    return null;
-  }
-}
-
-/**
- * Write signal file for orchestrator to pick up and spawn verifier.
- * @param {string} planningDir - Path to .planning directory
- * @param {number} phaseNumber - Current phase number
- */
-function writeAutoVerifySignal(planningDir, phaseNumber) {
-  const signalPath = path.join(planningDir, '.auto-verify');
-  const payload = {
-    phase: phaseNumber,
-    timestamp: new Date().toISOString()
-  };
-  fs.writeFileSync(signalPath, JSON.stringify(payload, null, 2), 'utf8');
-}
-
-function main() {
-  const data = readStdin();
-
-  // Only handle executor agent completions
-  if (!isExecutorAgent(data)) {
-    process.exit(0);
-  }
-
-  const agentType = data.agent_type || data.subagent_type;
-
-  logHook('event-handler', 'SubagentStop', 'executor-complete', { agent_type: agentType });
-  logEvent('workflow', 'executor-complete', { agent_type: agentType });
-
-  const planningDir = path.join(process.cwd(), '.planning');
-  if (!fs.existsSync(planningDir)) {
-    process.exit(0);
-  }
-
-  if (!shouldAutoVerify(planningDir)) {
-    logHook('event-handler', 'SubagentStop', 'skip-verify', { reason: 'config/depth' });
-    process.exit(0);
-  }
-
-  const stateInfo = getPhaseFromState(planningDir);
-  if (!stateInfo || stateInfo.status !== 'building') {
-    logHook('event-handler', 'SubagentStop', 'skip-verify', {
-      reason: stateInfo ? `status=${stateInfo.status}` : 'no-state'
-    });
-    process.exit(0);
-  }
-
-  writeAutoVerifySignal(planningDir, stateInfo.phase);
-
-  const output = {
-    message: `Executor complete. Auto-verification queued for Phase ${stateInfo.phase}.`
-  };
-  process.stdout.write(JSON.stringify(output));
-  process.exit(0);
-}
-
-module.exports = { isExecutorAgent, shouldAutoVerify, getPhaseFromState };
-if (require.main === module) { main(); }
+#!/usr/bin/env node
+
+/**
+ * SubagentStop event handler for auto-verification triggering.
+ *
+ * Detects executor agent completion and conditionally queues verification
+ * by writing a .auto-verify signal file. Respects depth profile and
+ * config.features.goal_verification setting.
+ *
+ * Non-blocking — exits 0 always.
+ */
+
+const fs = require('fs');
+const path = require('path');
+const { logHook } = require('./hook-logger');
+const { logEvent } = require('./event-logger');
+// configLoad not used here to avoid mtime-based cache issues across directories.
+// Config is read directly in shouldAutoVerify().
+
+function readStdin() {
+  try {
+    const input = fs.readFileSync(0, 'utf8').trim();
+    if (input) return JSON.parse(input);
+  } catch (_e) {
+    // empty or non-JSON stdin
+  }
+  return {};
+}
+
+/**
+ * Check if the stdin data represents an executor agent completion.
+ * @param {object} data - Parsed stdin JSON from SubagentStop event
+ * @returns {boolean}
+ */
+function isExecutorAgent(data) {
+  const agentType = data.agent_type || data.subagent_type || null;
+  return agentType === 'pbr:executor';
+}
+
+/**
+ * Determine whether auto-verification should run based on config.
+ * @param {string} planningDir - Path to .planning directory
+ * @returns {boolean}
+ */
+function shouldAutoVerify(planningDir) {
+  // Read config directly instead of using configLoad to avoid mtime-based
+  // cache issues when called repeatedly with different planning directories.
+  const configPath = path.join(planningDir, 'config.json');
+  let config;
+  try {
+    if (!fs.existsSync(configPath)) return false;
+    config = JSON.parse(fs.readFileSync(configPath, 'utf8'));
+  } catch (_e) {
+    return false;
+  }
+  if (config === null) return false;
+
+  // Check explicit goal_verification toggle
+  if (config.features && config.features.goal_verification === false) return false;
+
+  // Check depth profile
+  const depth = (config.depth || 'standard').toLowerCase();
+  if (depth === 'quick') return false;
+
+  // "standard", "comprehensive", and any other depth default to true
+  return true;
+}
+
+/**
+ * Parse current phase info from STATE.md.
+ * @param {string} planningDir - Path to .planning directory
+ * @returns {{ phase: number, total: number, status: string } | null}
+ */
+function getPhaseFromState(planningDir) {
+  const statePath = path.join(planningDir, 'STATE.md');
+  try {
+    if (!fs.existsSync(statePath)) return null;
+    const content = fs.readFileSync(statePath, 'utf8');
+
+    const phaseMatch = content.match(/Phase:\s*(\d+)\s+of\s+(\d+)/);
+    if (!phaseMatch) return null;
+
+    const statusMatch = content.match(/\*{0,2}(?:Phase\s+)?Status\*{0,2}:\s*["']?(\w+)["']?/i);
+    const status = statusMatch ? statusMatch[1] : null;
+
+    return {
+      phase: parseInt(phaseMatch[1], 10),
+      total: parseInt(phaseMatch[2], 10),
+      status: status
+    };
+  } catch (_e) {
+    return null;
+  }
+}
+
+/**
+ * Write signal file for orchestrator to pick up and spawn verifier.
+ * @param {string} planningDir - Path to .planning directory
+ * @param {number} phaseNumber - Current phase number
+ */
+function writeAutoVerifySignal(planningDir, phaseNumber) {
+  const signalPath = path.join(planningDir, '.auto-verify');
+  const payload = {
+    phase: phaseNumber,
+    timestamp: new Date().toISOString()
+  };
+  fs.writeFileSync(signalPath, JSON.stringify(payload, null, 2), 'utf8');
+}
+
+function main() {
+  const data = readStdin();
+
+  // Only handle executor agent completions
+  if (!isExecutorAgent(data)) {
+    process.exit(0);
+  }
+
+  const agentType = data.agent_type || data.subagent_type;
+
+  logHook('event-handler', 'SubagentStop', 'executor-complete', { agent_type: agentType });
+  logEvent('workflow', 'executor-complete', { agent_type: agentType });
+
+  const planningDir = path.join(process.cwd(), '.planning');
+  if (!fs.existsSync(planningDir)) {
+    process.exit(0);
+  }
+
+  if (!shouldAutoVerify(planningDir)) {
+    logHook('event-handler', 'SubagentStop', 'skip-verify', { reason: 'config/depth' });
+    process.exit(0);
+  }
+
+  const stateInfo = getPhaseFromState(planningDir);
+  if (!stateInfo || stateInfo.status !== 'building') {
+    logHook('event-handler', 'SubagentStop', 'skip-verify', {
+      reason: stateInfo ? `status=${stateInfo.status}` : 'no-state'
+    });
+    process.exit(0);
+  }
+
+  writeAutoVerifySignal(planningDir, stateInfo.phase);
+
+  const output = {
+    message: `Executor complete. Auto-verification queued for Phase ${stateInfo.phase}.`
+  };
+  process.stdout.write(JSON.stringify(output));
+  process.exit(0);
+}
+
+module.exports = { isExecutorAgent, shouldAutoVerify, getPhaseFromState };
+if (require.main === module) { main(); }

package/plugins/pbr/scripts/event-logger.js

@@ -1,92 +1,92 @@
-#!/usr/bin/env node
-
-/**
- * Workflow event logger for Plan-Build-Run observability.
- *
- * Usage as module:
- *   const { logEvent } = require('./event-logger');
- *   logEvent('workflow', 'phase-start', { phase: 3, name: 'API' });
- *
- * Usage as CLI:
- *   node event-logger.js <category> <event> [JSON-details]
- *
- * Log file: .planning/logs/events.jsonl
- * Format: One JSON line per entry (JSONL)
- * Rotation: Keeps last 1000 entries max
- */
-
-const fs = require('fs');
-const path = require('path');
-
-const MAX_ENTRIES = 1000;
-
-function getLogPath() {
-  const cwd = process.cwd();
-  const planningDir = path.join(cwd, '.planning');
-  if (!fs.existsSync(planningDir)) return null;
-  const logsDir = path.join(planningDir, 'logs');
-  if (!fs.existsSync(logsDir)) {
-    fs.mkdirSync(logsDir, { recursive: true });
-  }
-  return path.join(logsDir, 'events.jsonl');
-}
-
-function logEvent(category, event, details = {}) {
-  const logPath = getLogPath();
-  if (!logPath) return;
-
-  const entry = {
-    ts: new Date().toISOString(),
-    cat: category,
-    event,
-    ...details
-  };
-
-  try {
-    let lines = [];
-    if (fs.existsSync(logPath)) {
-      const content = fs.readFileSync(logPath, 'utf8').trim();
-      if (content) {
-        lines = content.split('\n');
-      }
-    }
-
-    lines.push(JSON.stringify(entry));
-
-    if (lines.length > MAX_ENTRIES) {
-      lines = lines.slice(lines.length - MAX_ENTRIES);
-    }
-
-    fs.writeFileSync(logPath, lines.join('\n') + '\n', 'utf8');
-  } catch (_e) {
-    // Best-effort logging — never fail the caller
-  }
-}
-
-// CLI mode
-function main() {
-  const args = process.argv.slice(2);
-  const category = args[0];
-  const event = args[1];
-  let details = {};
-
-  if (args[2]) {
-    try {
-      details = JSON.parse(args[2]);
-    } catch (_e) {
-      details = { raw: args[2] };
-    }
-  }
-
-  if (!category || !event) {
-    process.stdout.write(JSON.stringify({ error: 'Usage: event-logger.js <category> <event> [JSON-details]' }));
-    process.exit(1);
-  }
-
-  logEvent(category, event, details);
-  process.stdout.write(JSON.stringify({ logged: true, category, event }));
-  process.exit(0);
-}
-
-if (require.main === module) { main(); }
-module.exports = { logEvent };
+#!/usr/bin/env node
+
+/**
+ * Workflow event logger for Plan-Build-Run observability.
+ *
+ * Usage as module:
+ *   const { logEvent } = require('./event-logger');
+ *   logEvent('workflow', 'phase-start', { phase: 3, name: 'API' });
+ *
+ * Usage as CLI:
+ *   node event-logger.js <category> <event> [JSON-details]
+ *
+ * Log file: .planning/logs/events.jsonl
+ * Format: One JSON line per entry (JSONL)
+ * Rotation: Keeps last 1000 entries max
+ */
+
+const fs = require('fs');
+const path = require('path');
+
+const MAX_ENTRIES = 1000;
+
+function getLogPath() {
+  const cwd = process.cwd();
+  const planningDir = path.join(cwd, '.planning');
+  if (!fs.existsSync(planningDir)) return null;
+  const logsDir = path.join(planningDir, 'logs');
+  if (!fs.existsSync(logsDir)) {
+    fs.mkdirSync(logsDir, { recursive: true });
+  }
+  return path.join(logsDir, 'events.jsonl');
+}
+
+function logEvent(category, event, details = {}) {
+  const logPath = getLogPath();
+  if (!logPath) return;
+
+  const entry = {
+    ts: new Date().toISOString(),
+    cat: category,
+    event,
+    ...details
+  };
+
+  try {
+    let lines = [];
+    if (fs.existsSync(logPath)) {
+      const content = fs.readFileSync(logPath, 'utf8').trim();
+      if (content) {
+        lines = content.split('\n');
+      }
+    }
+
+    lines.push(JSON.stringify(entry));
+
+    if (lines.length > MAX_ENTRIES) {
+      lines = lines.slice(lines.length - MAX_ENTRIES);
+    }
+
+    fs.writeFileSync(logPath, lines.join('\n') + '\n', 'utf8');
+  } catch (_e) {
+    // Best-effort logging — never fail the caller
+  }
+}
+
+// CLI mode
+function main() {
+  const args = process.argv.slice(2);
+  const category = args[0];
+  const event = args[1];
+  let details = {};
+
+  if (args[2]) {
+    try {
+      details = JSON.parse(args[2]);
+    } catch (_e) {
+      details = { raw: args[2] };
+    }
+  }
+
+  if (!category || !event) {
+    process.stdout.write(JSON.stringify({ error: 'Usage: event-logger.js <category> <event> [JSON-details]' }));
+    process.exit(1);
+  }
+
+  logEvent(category, event, details);
+  process.stdout.write(JSON.stringify({ logged: true, category, event }));
+  process.exit(0);
+}
+
+if (require.main === module) { main(); }
+module.exports = { logEvent };

package/plugins/pbr/scripts/hook-logger.js

@@ -1,76 +1,80 @@
-#!/usr/bin/env node
-
-/**
- * Shared hook execution logger.
- *
- * Usage in hooks:
- *   const { logHook } = require('./hook-logger');
- *   logHook('validate-commit', 'PreToolUse', 'allow', { message: 'chore: ...' });
- *
- * Log file: .planning/logs/hooks.jsonl (in the project's .planning directory)
- * Format: One JSON line per entry (JSONL)
- * Rotation: Keeps last 200 entries max
- */
-
-const fs = require('fs');
-const path = require('path');
-
-const MAX_ENTRIES = 200;
-
-function getLogPath() {
-  const cwd = process.cwd();
-  const planningDir = path.join(cwd, '.planning');
-  if (!fs.existsSync(planningDir)) return null;
-
-  const logsDir = path.join(planningDir, 'logs');
-  const newPath = path.join(logsDir, 'hooks.jsonl');
-  const oldPath = path.join(planningDir, '.hook-log');
-
-  // Auto-create logs/ directory if it doesn't exist
-  if (!fs.existsSync(logsDir)) {
-    fs.mkdirSync(logsDir, { recursive: true });
-  }
-
-  // One-time migration: move old .hook-log to new location
-  if (fs.existsSync(oldPath) && !fs.existsSync(newPath)) {
-    fs.renameSync(oldPath, newPath);
-  }
-
-  return newPath;
-}
-
-function logHook(hookName, eventType, decision, details = {}) {
-  const logPath = getLogPath();
-  if (!logPath) return; // Not a Plan-Build-Run project
-
-  const entry = {
-    ts: new Date().toISOString(),
-    hook: hookName,
-    event: eventType,
-    decision,
-    ...details
-  };
-
-  try {
-    let lines = [];
-    if (fs.existsSync(logPath)) {
-      const content = fs.readFileSync(logPath, 'utf8').trim();
-      if (content) {
-        lines = content.split('\n');
-      }
-    }
-
-    lines.push(JSON.stringify(entry));
-
-    // Keep only last MAX_ENTRIES
-    if (lines.length > MAX_ENTRIES) {
-      lines = lines.slice(lines.length - MAX_ENTRIES);
-    }
-
-    fs.writeFileSync(logPath, lines.join('\n') + '\n', 'utf8');
-  } catch (_e) {
-    // Best-effort logging — never fail the hook
-  }
-}
-
-module.exports = { logHook };
+#!/usr/bin/env node
+
+/**
+ * Shared hook execution logger.
+ *
+ * Usage in hooks:
+ *   const { logHook } = require('./hook-logger');
+ *   logHook('validate-commit', 'PreToolUse', 'allow', { message: 'chore: ...' });
+ *
+ * Log file: .planning/logs/hooks.jsonl (in the project's .planning directory)
+ * Format: One JSON line per entry (JSONL)
+ * Rotation: Keeps last 200 entries max
+ */
+
+const fs = require('fs');
+const path = require('path');
+
+const MAX_ENTRIES = 200;
+
+function getLogPath() {
+  const cwd = process.cwd();
+  const planningDir = path.join(cwd, '.planning');
+  if (!fs.existsSync(planningDir)) return null;
+
+  const logsDir = path.join(planningDir, 'logs');
+  const newPath = path.join(logsDir, 'hooks.jsonl');
+  const oldPath = path.join(planningDir, '.hook-log');
+
+  // Auto-create logs/ directory if it doesn't exist
+  if (!fs.existsSync(logsDir)) {
+    fs.mkdirSync(logsDir, { recursive: true });
+  }
+
+  // One-time migration: move old .hook-log to new location
+  if (fs.existsSync(oldPath) && !fs.existsSync(newPath)) {
+    fs.renameSync(oldPath, newPath);
+  }
+
+  return newPath;
+}
+
+function logHook(hookName, eventType, decision, details = {}, startTime) {
+  const logPath = getLogPath();
+  if (!logPath) return; // Not a Plan-Build-Run project
+
+  const entry = {
+    ts: new Date().toISOString(),
+    hook: hookName,
+    event: eventType,
+    decision,
+    ...details
+  };
+
+  if (typeof startTime === 'number' && startTime > 0) {
+    entry.duration_ms = Date.now() - startTime;
+  }
+
+  try {
+    let lines = [];
+    if (fs.existsSync(logPath)) {
+      const content = fs.readFileSync(logPath, 'utf8').trim();
+      if (content) {
+        lines = content.split('\n');
+      }
+    }
+
+    lines.push(JSON.stringify(entry));
+
+    // Keep only last MAX_ENTRIES
+    if (lines.length > MAX_ENTRIES) {
+      lines = lines.slice(lines.length - MAX_ENTRIES);
+    }
+
+    fs.writeFileSync(logPath, lines.join('\n') + '\n', 'utf8');
+  } catch (_e) {
+    // Best-effort logging — never fail the hook
+  }
+}
+
+module.exports = { logHook };