@sienklogic/plan-build-run 2.0.0 → 2.0.1

package/plugins/pbr/scripts/hooks-schema.json

@@ -1,79 +1,79 @@
-{
-  "$schema": "http://json-schema.org/draft-07/schema#",
-  "title": "Plan-Build-Run Hooks",
-  "description": "Schema for Claude Code hooks.json configuration",
-  "type": "object",
-  "properties": {
-    "$schema": { "type": "string" },
-    "description": { "type": "string" },
-    "hooks": {
-      "type": "object",
-      "properties": {
-        "SessionStart": { "$ref": "#/definitions/hookEntryList" },
-        "PreToolUse": { "$ref": "#/definitions/hookEntryList" },
-        "PostToolUse": { "$ref": "#/definitions/hookEntryList" },
-        "PostToolUseFailure": { "$ref": "#/definitions/hookEntryList" },
-        "PreCompact": { "$ref": "#/definitions/hookEntryList" },
-        "Stop": { "$ref": "#/definitions/hookEntryList" },
-        "SubagentStart": { "$ref": "#/definitions/hookEntryList" },
-        "SubagentStop": { "$ref": "#/definitions/hookEntryList" },
-        "TaskCompleted": { "$ref": "#/definitions/hookEntryList" },
-        "SessionEnd": { "$ref": "#/definitions/hookEntryList" }
-      },
-      "additionalProperties": false
-    }
-  },
-  "required": ["hooks"],
-  "additionalProperties": true,
-  "definitions": {
-    "hookEntryList": {
-      "type": "array",
-      "items": { "$ref": "#/definitions/hookEntry" }
-    },
-    "hookEntry": {
-      "type": "object",
-      "properties": {
-        "matcher": {
-          "type": "string",
-          "description": "Regex tested against the tool name (e.g. 'Write|Edit', 'Bash', 'Task')"
-        },
-        "hooks": {
-          "type": "array",
-          "items": { "$ref": "#/definitions/hookCommand" }
-        }
-      },
-      "required": ["hooks"],
-      "additionalProperties": false
-    },
-    "hookCommand": {
-      "type": "object",
-      "properties": {
-        "type": {
-          "type": "string",
-          "enum": ["command"],
-          "description": "Hook type — currently only 'command' is supported"
-        },
-        "command": {
-          "type": "string",
-          "description": "Shell command to execute (use ${CLAUDE_PLUGIN_ROOT} for script paths)"
-        },
-        "statusMessage": {
-          "type": "string",
-          "description": "Status message shown in Claude Code UI while hook runs"
-        },
-        "async": {
-          "type": "boolean",
-          "description": "Run in background without blocking (stdout not captured)",
-          "default": false
-        },
-        "timeout": {
-          "type": "number",
-          "minimum": 1,
-          "description": "Maximum seconds before hook is killed (required when async: true)"
-        }
-      },
-      "required": ["type", "command"],
-      "additionalProperties": false
-    }
-  }
-}
+{
+  "$schema": "http://json-schema.org/draft-07/schema#",
+  "title": "Plan-Build-Run Hooks",
+  "description": "Schema for Claude Code hooks.json configuration",
+  "type": "object",
+  "properties": {
+    "$schema": { "type": "string" },
+    "description": { "type": "string" },
+    "hooks": {
+      "type": "object",
+      "properties": {
+        "SessionStart": { "$ref": "#/definitions/hookEntryList" },
+        "PreToolUse": { "$ref": "#/definitions/hookEntryList" },
+        "PostToolUse": { "$ref": "#/definitions/hookEntryList" },
+        "PostToolUseFailure": { "$ref": "#/definitions/hookEntryList" },
+        "PreCompact": { "$ref": "#/definitions/hookEntryList" },
+        "Stop": { "$ref": "#/definitions/hookEntryList" },
+        "SubagentStart": { "$ref": "#/definitions/hookEntryList" },
+        "SubagentStop": { "$ref": "#/definitions/hookEntryList" },
+        "TaskCompleted": { "$ref": "#/definitions/hookEntryList" },
+        "SessionEnd": { "$ref": "#/definitions/hookEntryList" }
+      },
+      "additionalProperties": false
+    }
+  },
+  "required": ["hooks"],
+  "additionalProperties": true,
+  "definitions": {
+    "hookEntryList": {
+      "type": "array",
+      "items": { "$ref": "#/definitions/hookEntry" }
+    },
+    "hookEntry": {
+      "type": "object",
+      "properties": {
+        "matcher": {
+          "type": "string",
+          "description": "Regex tested against the tool name (e.g. 'Write|Edit', 'Bash', 'Task')"
+        },
+        "hooks": {
+          "type": "array",
+          "items": { "$ref": "#/definitions/hookCommand" }
+        }
+      },
+      "required": ["hooks"],
+      "additionalProperties": false
+    },
+    "hookCommand": {
+      "type": "object",
+      "properties": {
+        "type": {
+          "type": "string",
+          "enum": ["command"],
+          "description": "Hook type — currently only 'command' is supported"
+        },
+        "command": {
+          "type": "string",
+          "description": "Shell command to execute (use ${CLAUDE_PLUGIN_ROOT} for script paths)"
+        },
+        "statusMessage": {
+          "type": "string",
+          "description": "Status message shown in Claude Code UI while hook runs"
+        },
+        "async": {
+          "type": "boolean",
+          "description": "Run in background without blocking (stdout not captured)",
+          "default": false
+        },
+        "timeout": {
+          "type": "number",
+          "minimum": 1,
+          "description": "Maximum seconds before hook is killed (required when async: true)"
+        }
+      },
+      "required": ["type", "command"],
+      "additionalProperties": false
+    }
+  }
+}

package/plugins/pbr/scripts/log-subagent.js

@@ -1,152 +1,164 @@
-#!/usr/bin/env node
-
-/**
- * SubagentStart / SubagentStop logging hook.
- *
- * Usage:
- *   node log-subagent.js start   — called on SubagentStart
- *   node log-subagent.js stop    — called on SubagentStop
- *
- * On start: logs spawn event and injects project context via additionalContext.
- * On stop: logs completion event.
- *
- * Non-blocking — exits 0 always.
- */
-
-const fs = require('fs');
-const path = require('path');
-const { logHook } = require('./hook-logger');
-const { logEvent } = require('./event-logger');
-const { configLoad } = require('./pbr-tools');
-
-function readStdin() {
-  try {
-    const input = fs.readFileSync(0, 'utf8').trim();
-    if (input) return JSON.parse(input);
-  } catch (_e) {
-    // empty or non-JSON stdin
-  }
-  return {};
-}
-
-function main() {
-  const action = process.argv[2]; // 'start' or 'stop'
-  const data = readStdin();
-
-  if (action === 'start') {
-    logHook('log-subagent', 'SubagentStart', 'spawned', {
-      agent_id: data.agent_id || null,
-      agent_type: data.agent_type || data.subagent_type || null,
-      description: data.description || null
-    });
-    logEvent('agent', 'spawn', {
-      agent_id: data.agent_id || null,
-      agent_type: data.agent_type || data.subagent_type || null,
-      description: data.description || null
-    });
-
-    // Write .active-agent signal so other hooks know a subagent is running
-    writeActiveAgent(data.agent_type || data.subagent_type || 'unknown');
-
-    // Inject project context into subagent
-    const context = buildAgentContext();
-    if (context) {
-      const output = {
-        hookSpecificOutput: {
-          hookEventName: 'SubagentStart',
-          additionalContext: context
-        }
-      };
-      process.stdout.write(JSON.stringify(output));
-    }
-  } else if (action === 'stop') {
-    // Remove .active-agent signal
-    removeActiveAgent();
-    logHook('log-subagent', 'SubagentStop', 'completed', {
-      agent_id: data.agent_id || null,
-      agent_type: data.agent_type || data.subagent_type || null,
-      duration_ms: data.duration_ms || null
-    });
-    logEvent('agent', 'complete', {
-      agent_id: data.agent_id || null,
-      agent_type: data.agent_type || data.subagent_type || null,
-      duration_ms: data.duration_ms || null
-    });
-  }
-
-  process.exit(0);
-}
-
-function writeActiveAgent(agentType) {
-  try {
-    const cwd = process.cwd();
-    const filePath = path.join(cwd, '.planning', '.active-agent');
-    if (fs.existsSync(path.join(cwd, '.planning'))) {
-      fs.writeFileSync(filePath, agentType, 'utf8');
-    }
-  } catch (_e) {
-    // Best-effort
-  }
-}
-
-function removeActiveAgent() {
-  try {
-    const cwd = process.cwd();
-    const filePath = path.join(cwd, '.planning', '.active-agent');
-    if (fs.existsSync(filePath)) {
-      fs.unlinkSync(filePath);
-    }
-  } catch (_e) {
-    // Best-effort
-  }
-}
-
-function buildAgentContext() {
-  const cwd = process.cwd();
-  const planningDir = path.join(cwd, '.planning');
-
-  if (!fs.existsSync(planningDir)) return '';
-
-  const parts = [];
-
-  // Current phase and status from STATE.md
-  const stateFile = path.join(planningDir, 'STATE.md');
-  if (fs.existsSync(stateFile)) {
-    try {
-      const state = fs.readFileSync(stateFile, 'utf8');
-      const phaseMatch = state.match(/Phase:\s*(\d+)\s+of\s+(\d+)/);
-      const statusMatch = state.match(/\*{0,2}(?:Phase\s+)?Status\*{0,2}:\s*["']?(\w+)["']?/i);
-      if (phaseMatch) {
-        parts.push(`Phase ${phaseMatch[1]} of ${phaseMatch[2]}${statusMatch ? ' (' + statusMatch[1] + ')' : ''}`);
-      }
-    } catch (_e) {
-      // skip
-    }
-  }
-
-  // Active skill context
-  const activeSkillFile = path.join(planningDir, '.active-skill');
-  if (fs.existsSync(activeSkillFile)) {
-    try {
-      const skill = fs.readFileSync(activeSkillFile, 'utf8').trim();
-      if (skill) parts.push(`Active skill: /pbr:${skill}`);
-    } catch (_e) {
-      // skip
-    }
-  }
-
-  // Config highlights
-  const config = configLoad(planningDir);
-  if (config) {
-    const configParts = [];
-    if (config.depth) configParts.push(`depth=${config.depth}`);
-    if (config.git && config.git.auto_commit !== undefined) configParts.push(`auto_commit=${config.git.auto_commit}`);
-    if (configParts.length > 0) parts.push(`Config: ${configParts.join(', ')}`);
-  }
-
-  if (parts.length === 0) return '';
-  return '[Plan-Build-Run Project Context] ' + parts.join(' | ');
-}
-
-module.exports = { buildAgentContext };
-if (require.main === module) { main(); }
+#!/usr/bin/env node
+
+/**
+ * SubagentStart / SubagentStop logging hook.
+ *
+ * Usage:
+ *   node log-subagent.js start   — called on SubagentStart
+ *   node log-subagent.js stop    — called on SubagentStop
+ *
+ * On start: logs spawn event and injects project context via additionalContext.
+ * On stop: logs completion event.
+ *
+ * Non-blocking — exits 0 always.
+ */
+
+const fs = require('fs');
+const path = require('path');
+const { logHook } = require('./hook-logger');
+const { logEvent } = require('./event-logger');
+const { configLoad } = require('./pbr-tools');
+
+function readStdin() {
+  try {
+    const input = fs.readFileSync(0, 'utf8').trim();
+    if (input) return JSON.parse(input);
+  } catch (_e) {
+    // empty or non-JSON stdin
+  }
+  return {};
+}
+
+/**
+ * Extract agent type from hook data, checking multiple possible field locations.
+ * Returns the first non-empty value found, or null if no type info is available.
+ */
+function resolveAgentType(data) {
+  return data.agent_type
+    || data.subagent_type
+    || (data.tool_input && (data.tool_input.subagent_type || data.tool_input.agent_type))
+    || null;
+}
+
+function main() {
+  const action = process.argv[2]; // 'start' or 'stop'
+  const data = readStdin();
+  const agentType = resolveAgentType(data);
+
+  if (action === 'start') {
+    logHook('log-subagent', 'SubagentStart', 'spawned', {
+      agent_id: data.agent_id || null,
+      agent_type: agentType,
+      description: data.description || null
+    });
+    logEvent('agent', 'spawn', {
+      agent_id: data.agent_id || null,
+      agent_type: agentType,
+      description: data.description || null
+    });
+
+    // Write .active-agent signal so other hooks know a subagent is running
+    writeActiveAgent(agentType || 'unknown');
+
+    // Inject project context into subagent
+    const context = buildAgentContext();
+    if (context) {
+      const output = {
+        hookSpecificOutput: {
+          hookEventName: 'SubagentStart',
+          additionalContext: context
+        }
+      };
+      process.stdout.write(JSON.stringify(output));
+    }
+  } else if (action === 'stop') {
+    // Remove .active-agent signal
+    removeActiveAgent();
+    logHook('log-subagent', 'SubagentStop', 'completed', {
+      agent_id: data.agent_id || null,
+      agent_type: agentType,
+      duration_ms: data.duration_ms || null
+    });
+    logEvent('agent', 'complete', {
+      agent_id: data.agent_id || null,
+      agent_type: agentType,
+      duration_ms: data.duration_ms || null
+    });
+  }
+
+  process.exit(0);
+}
+
+function writeActiveAgent(agentType) {
+  try {
+    const cwd = process.cwd();
+    const filePath = path.join(cwd, '.planning', '.active-agent');
+    if (fs.existsSync(path.join(cwd, '.planning'))) {
+      fs.writeFileSync(filePath, agentType, 'utf8');
+    }
+  } catch (_e) {
+    // Best-effort
+  }
+}
+
+function removeActiveAgent() {
+  try {
+    const cwd = process.cwd();
+    const filePath = path.join(cwd, '.planning', '.active-agent');
+    if (fs.existsSync(filePath)) {
+      fs.unlinkSync(filePath);
+    }
+  } catch (_e) {
+    // Best-effort
+  }
+}
+
+function buildAgentContext() {
+  const cwd = process.cwd();
+  const planningDir = path.join(cwd, '.planning');
+
+  if (!fs.existsSync(planningDir)) return '';
+
+  const parts = [];
+
+  // Current phase and status from STATE.md
+  const stateFile = path.join(planningDir, 'STATE.md');
+  if (fs.existsSync(stateFile)) {
+    try {
+      const state = fs.readFileSync(stateFile, 'utf8');
+      const phaseMatch = state.match(/Phase:\s*(\d+)\s+of\s+(\d+)/);
+      const statusMatch = state.match(/\*{0,2}(?:Phase\s+)?Status\*{0,2}:\s*["']?(\w+)["']?/i);
+      if (phaseMatch) {
+        parts.push(`Phase ${phaseMatch[1]} of ${phaseMatch[2]}${statusMatch ? ' (' + statusMatch[1] + ')' : ''}`);
+      }
+    } catch (_e) {
+      // skip
+    }
+  }
+
+  // Active skill context
+  const activeSkillFile = path.join(planningDir, '.active-skill');
+  if (fs.existsSync(activeSkillFile)) {
+    try {
+      const skill = fs.readFileSync(activeSkillFile, 'utf8').trim();
+      if (skill) parts.push(`Active skill: /pbr:${skill}`);
+    } catch (_e) {
+      // skip
+    }
+  }
+
+  // Config highlights
+  const config = configLoad(planningDir);
+  if (config) {
+    const configParts = [];
+    if (config.depth) configParts.push(`depth=${config.depth}`);
+    if (config.git && config.git.auto_commit !== undefined) configParts.push(`auto_commit=${config.git.auto_commit}`);
+    if (configParts.length > 0) parts.push(`Config: ${configParts.join(', ')}`);
+  }
+
+  if (parts.length === 0) return '';
+  return '[Plan-Build-Run Project Context] ' + parts.join(' | ');
+}
+
+module.exports = { buildAgentContext, resolveAgentType };
+if (require.main === module) { main(); }

package/plugins/pbr/scripts/log-tool-failure.js

@@ -1,88 +1,88 @@
-#!/usr/bin/env node
-
-/**
- * PostToolUseFailure hook: Logs tool failures to events.jsonl
- * and provides recovery hints via additionalContext.
- *
- * Fires when any tool execution fails. Captures tool name, error,
- * and session context for debugging.
- *
- * Exit codes:
- *   0 = always (informational hook, never blocks)
- */
-
-const { logHook } = require('./hook-logger');
-const { logEvent } = require('./event-logger');
-
-function readStdin() {
-  return new Promise((resolve) => {
-    let input = '';
-    process.stdin.setEncoding('utf8');
-    process.stdin.on('data', (chunk) => { input += chunk; });
-    process.stdin.on('end', () => {
-      try {
-        resolve(JSON.parse(input));
-      } catch (_e) {
-        resolve({});
-      }
-    });
-  });
-}
-
-async function main() {
-  const data = await readStdin();
-
-  const toolName = data.tool_name || 'unknown';
-  const error = data.error || 'unknown error';
-  const isInterrupt = data.is_interrupt || false;
-  const toolInput = data.tool_input || {};
-
-  // Log to hooks.jsonl
-  logHook('log-tool-failure', 'PostToolUseFailure', 'logged', {
-    tool: toolName,
-    error: typeof error === 'string' ? error.substring(0, 200) : JSON.stringify(error).substring(0, 200),
-    interrupt: isInterrupt
-  });
-
-  // Log to events.jsonl with more detail
-  logEvent('tool', 'failure', {
-    tool: toolName,
-    error: typeof error === 'string' ? error.substring(0, 500) : JSON.stringify(error).substring(0, 500),
-    interrupt: isInterrupt,
-    input_summary: summarizeInput(toolName, toolInput)
-  });
-
-  // Provide recovery hints for Bash failures (most common actionable failure)
-  if (toolName === 'Bash' && !isInterrupt) {
-    const output = {
-      hookSpecificOutput: {
-        hookEventName: 'PostToolUseFailure',
-        additionalContext: 'Bash command failed. If this is a recurring issue, consider using /pbr:debug for systematic investigation.'
-      }
-    };
-    process.stdout.write(JSON.stringify(output));
-  }
-
-  process.exit(0);
-}
-
-function summarizeInput(toolName, toolInput) {
-  switch (toolName) {
-  case 'Bash':
-    return (toolInput.command || '').substring(0, 100);
-  case 'Write':
-  case 'Read':
-  case 'Edit':
-    return toolInput.file_path || '';
-  case 'Glob':
-    return toolInput.pattern || '';
-  case 'Grep':
-    return toolInput.pattern || '';
-  case 'Task':
-    return (toolInput.description || '').substring(0, 100);
-  default:
-    return '';
-  }
-}
-
-main();
+#!/usr/bin/env node
+
+/**
+ * PostToolUseFailure hook: Logs tool failures to events.jsonl
+ * and provides recovery hints via additionalContext.
+ *
+ * Fires when any tool execution fails. Captures tool name, error,
+ * and session context for debugging.
+ *
+ * Exit codes:
+ *   0 = always (informational hook, never blocks)
+ */
+
+const { logHook } = require('./hook-logger');
+const { logEvent } = require('./event-logger');
+
+function readStdin() {
+  return new Promise((resolve) => {
+    let input = '';
+    process.stdin.setEncoding('utf8');
+    process.stdin.on('data', (chunk) => { input += chunk; });
+    process.stdin.on('end', () => {
+      try {
+        resolve(JSON.parse(input));
+      } catch (_e) {
+        resolve({});
+      }
+    });
+  });
+}
+
+async function main() {
+  const data = await readStdin();
+
+  const toolName = data.tool_name || 'unknown';
+  const error = data.error || 'unknown error';
+  const isInterrupt = data.is_interrupt || false;
+  const toolInput = data.tool_input || {};
+
+  // Log to hooks.jsonl
+  logHook('log-tool-failure', 'PostToolUseFailure', 'logged', {
+    tool: toolName,
+    error: typeof error === 'string' ? error.substring(0, 200) : JSON.stringify(error).substring(0, 200),
+    interrupt: isInterrupt
+  });
+
+  // Log to events.jsonl with more detail
+  logEvent('tool', 'failure', {
+    tool: toolName,
+    error: typeof error === 'string' ? error.substring(0, 500) : JSON.stringify(error).substring(0, 500),
+    interrupt: isInterrupt,
+    input_summary: summarizeInput(toolName, toolInput)
+  });
+
+  // Provide recovery hints for Bash failures (most common actionable failure)
+  if (toolName === 'Bash' && !isInterrupt) {
+    const output = {
+      hookSpecificOutput: {
+        hookEventName: 'PostToolUseFailure',
+        additionalContext: 'Bash command failed. If this is a recurring issue, consider using /pbr:debug for systematic investigation.'
+      }
+    };
+    process.stdout.write(JSON.stringify(output));
+  }
+
+  process.exit(0);
+}
+
+function summarizeInput(toolName, toolInput) {
+  switch (toolName) {
+  case 'Bash':
+    return (toolInput.command || '').substring(0, 100);
+  case 'Write':
+  case 'Read':
+  case 'Edit':
+    return toolInput.file_path || '';
+  case 'Glob':
+    return toolInput.pattern || '';
+  case 'Grep':
+    return toolInput.pattern || '';
+  case 'Task':
+    return (toolInput.description || '').substring(0, 100);
+  default:
+    return '';
+  }
+}
+
+main();