cc-dev-template 0.1.19 → 0.1.21

package/bin/install.js

@@ -20,7 +20,7 @@ console.log('='.repeat(50));
 console.log(`Installing to ${CLAUDE_DIR}...`);
 
 // Create directories
-const dirs = ['agents', 'commands', 'scripts', 'skills', 'mcp-servers'];
+const dirs = ['agents', 'commands', 'scripts', 'skills', 'hooks', 'mcp-servers'];
 dirs.forEach(dir => {
   fs.mkdirSync(path.join(CLAUDE_DIR, dir), { recursive: true });
 });
@@ -92,6 +92,34 @@ if (fs.existsSync(skillsDir)) {
   console.log('  No skills to install');
 }
 
+// Copy hooks
+console.log('\nHooks:');
+const hooksDir = path.join(SRC_DIR, 'hooks');
+if (fs.existsSync(hooksDir)) {
+  const hookScripts = fs.readdirSync(hooksDir).filter(f => f.endsWith('.sh'));
+  const hookConfigs = fs.readdirSync(hooksDir).filter(f => f.endsWith('.json'));
+
+  // Copy shell scripts and make executable
+  hookScripts.forEach(file => {
+    const src = path.join(hooksDir, file);
+    const dest = path.join(CLAUDE_DIR, 'hooks', file);
+    fs.copyFileSync(src, dest);
+    fs.chmodSync(dest, 0o755);  // Make executable
+    console.log(`  ${file}`);
+  });
+
+  // Copy JSON configs to scripts dir for merging later
+  hookConfigs.forEach(file => {
+    const src = path.join(hooksDir, file);
+    const dest = path.join(CLAUDE_DIR, 'scripts', file);
+    fs.copyFileSync(src, dest);
+  });
+
+  console.log(`✓ ${hookScripts.length} hooks installed`);
+} else {
+  console.log('  No hooks to install');
+}
+
 // Install MCP servers
 console.log('\nMCP Servers:');
 const mcpServersDir = path.join(SRC_DIR, 'mcp-servers');
@@ -198,7 +226,10 @@ if (fs.existsSync(mergeSettingsPath)) {
   const configs = [
     { file: 'yaml-validation-hook.json', name: 'YAML validation hook' },
     { file: 'read-guard-hook.json', name: 'Context guard for large reads' },
-    { file: 'statusline-config.json', name: 'Custom status line' }
+    { file: 'statusline-config.json', name: 'Custom status line' },
+    { file: 'orchestration-hook.json', name: 'Orchestration guidance hook' },
+    { file: 'bash-overflow-hook.json', name: 'Bash overflow guard hook' },
+    { file: 'bash-precheck-hook.json', name: 'Bash precheck hook' }
   ];
 
   configs.forEach(({ file, name }) => {
@@ -225,6 +256,7 @@ Installed to:
   Commands:    ${CLAUDE_DIR}/commands/
   Scripts:     ${CLAUDE_DIR}/scripts/
   Skills:      ${CLAUDE_DIR}/skills/
+  Hooks:       ${CLAUDE_DIR}/hooks/
   MCP Servers: ${CLAUDE_DIR}/mcp-servers/
   Settings:    ${CLAUDE_DIR}/settings.json
 `);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "cc-dev-template",
-  "version": "0.1.19",
+  "version": "0.1.21",
   "description": "Structured AI-assisted development framework for Claude Code",
   "bin": {
     "cc-dev-template": "./bin/install.js"

package/src/hooks/bash-overflow-guard.sh

@@ -0,0 +1,63 @@
+#!/bin/bash
+# bash-overflow-guard.sh - Intercept large Bash outputs to preserve context
+#
+# PostToolUse hook that catches large Bash outputs, saves them to a file,
+# and tells Claude to use Grep to search the file instead of consuming context.
+
+set -e
+
+# Configuration
+MAX_CHARS=${BASH_OVERFLOW_MAX_CHARS:-20000}  # ~5k tokens
+OVERFLOW_DIR="${HOME}/.claude/bash-overflow"
+
+# Read hook input from stdin
+input=$(cat)
+
+# Parse the tool response
+tool_name=$(echo "$input" | jq -r '.tool_name // empty')
+
+# Only process Bash tool
+if [[ "$tool_name" != "Bash" ]]; then
+    exit 0
+fi
+
+# Extract stdout from the response
+# tool_response can be a string or object depending on output
+stdout=$(echo "$input" | jq -r '.tool_response // empty')
+
+# If tool_response is an object, try to get stdout field
+if echo "$stdout" | jq -e 'type == "object"' > /dev/null 2>&1; then
+    stdout=$(echo "$stdout" | jq -r '.stdout // .output // empty')
+fi
+
+# Measure size
+char_count=${#stdout}
+line_count=$(echo "$stdout" | wc -l | tr -d ' ')
+
+# Check if output exceeds threshold
+if [[ $char_count -gt $MAX_CHARS ]]; then
+    # Create overflow directory
+    mkdir -p "$OVERFLOW_DIR"
+
+    # Generate filename with timestamp
+    timestamp=$(date +%Y%m%d_%H%M%S)
+    overflow_file="$OVERFLOW_DIR/bash_output_${timestamp}.txt"
+
+    # Save output to file
+    echo "$stdout" > "$overflow_file"
+
+    # Calculate approximate token count (rough heuristic: 4 chars per token)
+    approx_tokens=$((char_count / 4))
+
+    # Return block decision with guidance
+    cat << EOF
+{
+  "decision": "block",
+  "reason": "Bash output too large for context (${line_count} lines, ~${approx_tokens} tokens). Output saved to: ${overflow_file}\n\nUse the Grep tool to search this file:\n  Grep(pattern: \"your-pattern\", path: \"${overflow_file}\")\n\nOr read specific sections:\n  Read(file_path: \"${overflow_file}\", offset: 1, limit: 100)"
+}
+EOF
+    exit 0
+fi
+
+# Output is small enough, allow it through
+exit 0

package/src/hooks/bash-overflow-hook.json

@@ -0,0 +1,15 @@
+{
+  "hooks": {
+    "PostToolUse": [
+      {
+        "matcher": "Bash",
+        "hooks": [
+          {
+            "type": "command",
+            "command": "$HOME/.claude/hooks/bash-overflow-guard.sh"
+          }
+        ]
+      }
+    ]
+  }
+}

package/src/hooks/bash-precheck-hook.json

@@ -0,0 +1,15 @@
+{
+  "hooks": {
+    "PreToolUse": [
+      {
+        "matcher": "Bash",
+        "hooks": [
+          {
+            "type": "command",
+            "command": "$HOME/.claude/hooks/bash-precheck.sh"
+          }
+        ]
+      }
+    ]
+  }
+}

package/src/hooks/bash-precheck.sh

@@ -0,0 +1,117 @@
+#!/bin/bash
+# bash-precheck.sh - PreToolUse hook to wrap Bash commands with output limiting
+#
+# Intercepts Bash commands before execution and wraps them to:
+# 1. Capture output to temp file
+# 2. If output exceeds threshold, save and return truncated version
+#
+# This ACTUALLY prevents large outputs from consuming context.
+# Compatible with bash and zsh on macOS and Linux.
+
+set -e
+
+# Configuration
+MAX_CHARS=${BASH_OVERFLOW_MAX_CHARS:-20000}
+OVERFLOW_DIR="${HOME}/.claude/bash-overflow"
+
+# Read hook input from stdin
+input=$(cat)
+
+# Parse tool name and command
+tool_name=$(echo "$input" | jq -r '.tool_name // empty')
+
+# Only process Bash tool
+if [[ "$tool_name" != "Bash" ]]; then
+    exit 0
+fi
+
+# Get the original command
+original_cmd=$(echo "$input" | jq -r '.tool_input.command // empty')
+
+# Skip if empty
+if [[ -z "$original_cmd" ]]; then
+    exit 0
+fi
+
+# Skip commands that are already piped to head/tail or are simple commands
+if [[ "$original_cmd" =~ \|[[:space:]]*(head|tail|wc|grep.*-c) ]]; then
+    exit 0
+fi
+
+# Skip very short commands (likely simple operations)
+if [[ ${#original_cmd} -lt 10 ]]; then
+    exit 0
+fi
+
+# Create overflow directory
+mkdir -p "$OVERFLOW_DIR"
+
+# Generate unique filename
+timestamp=$(date +%Y%m%d_%H%M%S)
+rand_suffix=$RANDOM
+overflow_file="$OVERFLOW_DIR/bash_output_${timestamp}_${rand_suffix}.txt"
+temp_file="/tmp/claude_bash_${timestamp}_${rand_suffix}.tmp"
+
+# Escape the original command for embedding in the wrapper
+# Use base64 to safely embed arbitrary commands
+original_cmd_b64=$(echo "$original_cmd" | base64)
+
+# Create wrapper that uses temp file approach (more portable)
+read -r -d '' wrapped_cmd << 'WRAPPER_EOF' || true
+__cmd_b64="BASE64_CMD_HERE"
+__cmd=$(echo "$__cmd_b64" | base64 -d)
+__tmpfile="TEMP_FILE_HERE"
+__overflow="OVERFLOW_FILE_HERE"
+__max=MAX_CHARS_HERE
+
+# Run command and capture to temp file
+eval "$__cmd" > "$__tmpfile" 2>&1
+__exit_code=$?
+
+# Check size
+__size=$(wc -c < "$__tmpfile" | tr -d ' ')
+
+if [ "$__size" -gt "$__max" ]; then
+    # Save full output
+    cp "$__tmpfile" "$__overflow"
+    __lines=$(wc -l < "$__tmpfile" | tr -d ' ')
+    __tokens=$((__size / 4))
+
+    echo "=== OUTPUT TRUNCATED (${__lines} lines, ~${__tokens} tokens) ==="
+    echo ""
+    echo "--- First 40 lines ---"
+    head -n 40 "$__tmpfile"
+    echo ""
+    echo "--- Last 5 lines ---"
+    tail -n 5 "$__tmpfile"
+    echo ""
+    echo "=== Full output saved to: $__overflow ==="
+    echo "Use Grep(pattern, path) or Read(file_path, offset, limit) to explore"
+else
+    cat "$__tmpfile"
+fi
+
+rm -f "$__tmpfile"
+exit $__exit_code
+WRAPPER_EOF
+
+# Substitute placeholders
+wrapped_cmd="${wrapped_cmd//BASE64_CMD_HERE/$original_cmd_b64}"
+wrapped_cmd="${wrapped_cmd//TEMP_FILE_HERE/$temp_file}"
+wrapped_cmd="${wrapped_cmd//OVERFLOW_FILE_HERE/$overflow_file}"
+wrapped_cmd="${wrapped_cmd//MAX_CHARS_HERE/$MAX_CHARS}"
+
+# Return the modified command
+cat << EOF
+{
+  "hookSpecificOutput": {
+    "hookEventName": "PreToolUse",
+    "permissionDecision": "allow",
+    "updatedInput": {
+      "command": $(echo "$wrapped_cmd" | jq -Rs .)
+    }
+  }
+}
+EOF
+
+exit 0