claudeguide-engineer 1.14.8

package/.claude/hooks/modularization-hook.js

@@ -0,0 +1,108 @@
+#!/usr/bin/env node
+
+/**
+ * Modularization Hook - PostToolUse Command Hook
+ *
+ * Analyzes files modified via Write/Edit tools and suggests modularization
+ * for files exceeding 200 lines of code. Non-blocking implementation.
+ *
+ * Exit Codes:
+ *   0 - Success (non-blocking, allows continuation)
+ *   1 - Error (logs but doesn't block)
+ */
+
+const fs = require('fs');
+const path = require('path');
+
+// Constants
+const LOC_THRESHOLD = 200;
+const DEBUG = process.env.MODULARIZATION_HOOK_DEBUG === 'true';
+
+/**
+ * Conditionally log diagnostic information to stderr without breaking JSON stdout parsing.
+ * Keeping logs opt-in avoids noisy transcripts while still letting us validate hook flow.
+ */
+function debugLog(message) {
+  if (DEBUG) {
+    console.error(`[modularization-hook] ${message}`);
+  }
+}
+
+/**
+ * Main hook execution
+ */
+async function main() {
+  try {
+    // Read hook payload from stdin
+    const stdin = fs.readFileSync(0, 'utf-8').trim();
+
+    if (!stdin) {
+      // No input, skip silently
+      process.exit(0);
+    }
+
+    const payload = JSON.parse(stdin);
+    debugLog(`Hook triggered for tool: ${payload.tool_name ?? 'unknown'}`);
+
+    // Extract file path from tool input
+    const filePath = payload.tool_input?.file_path;
+
+    if (!filePath) {
+      debugLog('No file path in payload; skipping.');
+      // No file path in payload, skip
+      process.exit(0);
+    }
+
+    // Check if file exists and is readable
+    if (!fs.existsSync(filePath)) {
+      debugLog(`File not found at path: ${filePath}`);
+      process.exit(0);
+    }
+
+    // Read file and count lines
+    const fileContent = fs.readFileSync(filePath, 'utf-8');
+    const lines = fileContent.split('\n').length;
+    debugLog(`File ${filePath} has ${lines} LOC.`);
+
+    // Check if modularization suggestion is warranted
+    if (lines > LOC_THRESHOLD) {
+      const fileName = path.basename(filePath);
+      const relativePath = path.relative(process.cwd(), filePath);
+      debugLog(`LOC threshold exceeded for ${relativePath}.`);
+
+      // Output non-blocking context injection
+      const output = {
+        continue: true,
+        hookSpecificOutput: {
+          hookEventName: "PostToolUse",
+          additionalContext: [
+            `📊 File ${relativePath} has ${lines} LOC (threshold: ${LOC_THRESHOLD}).`,
+            `Consider modularization:`,
+            `- Analyze logical separation boundaries (functions, classes, concerns)`,
+            `- Use kebab-case naming with descriptive names (e.g., user-authentication-service.ts, data-validation-helpers.ts)`,
+            `- Ensure file names are self-documenting for LLM tools (Grep, Glob)`,
+            `- After modularization, continue with main task`
+          ].join('\n')
+        }
+      };
+
+      console.log(JSON.stringify(output));
+    }
+
+    // Always exit with 0 (non-blocking)
+    process.exit(0);
+
+  } catch (error) {
+    // Log error but don't block execution
+    console.error(JSON.stringify({
+      hookSpecificOutput: {
+        hookEventName: "PostToolUse",
+        additionalContext: `Modularization hook error: ${error.message}`
+      }
+    }));
+
+    process.exit(0); // Still non-blocking even on error
+  }
+}
+
+main();

package/.claude/hooks/scout-block.js

@@ -0,0 +1,89 @@
+#!/usr/bin/env node
+
+/**
+ * scout-block.js - Cross-platform hook dispatcher
+ *
+ * Blocks access to heavy directories: node_modules, __pycache__, .git/, dist/, build/
+ *
+ * Platform Detection:
+ * - Windows (win32): Uses PowerShell via scout-block.ps1
+ * - Unix (linux/darwin): Uses Bash via scout-block.sh
+ * - WSL: Automatically detects and uses bash implementation
+ *
+ * Exit Codes:
+ * - 0: Command allowed
+ * - 2: Command blocked or error occurred
+ */
+
+const { execSync } = require('child_process');
+const path = require('path');
+const fs = require('fs');
+
+try {
+  // Read stdin synchronously
+  const hookInput = fs.readFileSync(0, 'utf-8');
+
+  // Validate input not empty
+  if (!hookInput || hookInput.trim().length === 0) {
+    console.error('ERROR: Empty input');
+    process.exit(2);
+  }
+
+  // Validate JSON structure (basic check)
+  try {
+    const data = JSON.parse(hookInput);
+    if (!data.tool_input || typeof data.tool_input.command !== 'string') {
+      console.error('ERROR: Invalid JSON structure');
+      process.exit(2);
+    }
+  } catch (parseError) {
+    console.error('ERROR: JSON parse failed:', parseError.message);
+    process.exit(2);
+  }
+
+  // Determine platform
+  const platform = process.platform;
+  const scriptDir = __dirname;
+
+  if (platform === 'win32') {
+    // Windows: Use PowerShell implementation
+    const psScript = path.join(scriptDir, 'scout-block.ps1');
+
+    // Check if PowerShell script exists
+    if (!fs.existsSync(psScript)) {
+      console.error(`ERROR: PowerShell script not found: ${psScript}`);
+      process.exit(2);
+    }
+
+    // Execute PowerShell script with stdin piped
+    execSync(`powershell -NoProfile -ExecutionPolicy Bypass -File "${psScript}"`, {
+      input: hookInput,
+      stdio: ['pipe', 'inherit', 'inherit'],
+      encoding: 'utf-8'
+    });
+  } else {
+    // Unix (Linux, macOS, WSL): Use bash implementation
+    const bashScript = path.join(scriptDir, 'scout-block.sh');
+
+    // Check if bash script exists
+    if (!fs.existsSync(bashScript)) {
+      console.error(`ERROR: Bash script not found: ${bashScript}`);
+      process.exit(2);
+    }
+
+    // Execute bash script with stdin piped
+    execSync(`bash "${bashScript}"`, {
+      input: hookInput,
+      stdio: ['pipe', 'inherit', 'inherit'],
+      encoding: 'utf-8'
+    });
+  }
+} catch (error) {
+  // Log error details for debugging
+  if (error.message) {
+    console.error('ERROR:', error.message);
+  }
+
+  // Exit with error code from child process, or 2 if undefined
+  process.exit(error.status || 2);
+}

package/.claude/hooks/scout-block.ps1

@@ -0,0 +1,65 @@
+# scout-block.ps1 - PowerShell implementation for blocking heavy directories
+# Blocks: node_modules, __pycache__, .git/, dist/, build/
+
+# Read JSON input from stdin
+$inputJson = $input | Out-String
+
+# Validate input not empty
+if ([string]::IsNullOrWhiteSpace($inputJson)) {
+    Write-Error "ERROR: Empty input"
+    exit 2
+}
+
+# Parse JSON (PowerShell 5.1+ compatible)
+try {
+    $hookData = $inputJson | ConvertFrom-Json
+} catch {
+    Write-Error "ERROR: Failed to parse JSON input"
+    exit 2
+}
+
+# Validate JSON structure
+if (-not $hookData.tool_input) {
+    Write-Error "ERROR: Invalid JSON structure - missing tool_input"
+    exit 2
+}
+
+if (-not $hookData.tool_input.command) {
+    Write-Error "ERROR: Invalid JSON structure - missing command"
+    exit 2
+}
+
+# Extract command from hook input
+$command = $hookData.tool_input.command
+
+# Validate command is string
+if ($command -isnot [string]) {
+    Write-Error "ERROR: Command must be string"
+    exit 2
+}
+
+# Validate command not empty
+if ([string]::IsNullOrWhiteSpace($command)) {
+    Write-Error "ERROR: Empty command"
+    exit 2
+}
+
+# Define blocked patterns (regex)
+$blockedPatterns = @(
+    'node_modules',
+    '__pycache__',
+    '\.git/',
+    'dist/',
+    'build/'
+)
+
+# Check if command matches any blocked pattern
+foreach ($pattern in $blockedPatterns) {
+    if ($command -match $pattern) {
+        Write-Error "ERROR: Blocked directory pattern"
+        exit 2
+    }
+}
+
+# Allow command to proceed (exit 0)
+exit 0

package/.claude/hooks/scout-block.sh

@@ -0,0 +1,51 @@
+#!/bin/bash
+# scout-block.sh - Bash implementation for blocking heavy directories
+# Blocks: node_modules, __pycache__, .git/, dist/, build/
+
+# Read stdin
+INPUT=$(cat)
+
+# Validate input not empty
+if [ -z "$INPUT" ]; then
+  echo "ERROR: Empty input" >&2
+  exit 2
+fi
+
+# Parse JSON using Node.js (eliminates jq dependency) with error handling
+COMMAND=$(echo "$INPUT" | node -e "
+try {
+  const input = require('fs').readFileSync(0, 'utf-8');
+  const data = JSON.parse(input);
+  if (!data.tool_input || typeof data.tool_input.command !== 'string') {
+    console.error('ERROR: Invalid JSON structure');
+    process.exit(2);
+  }
+  console.log(data.tool_input.command);
+} catch (error) {
+  console.error('ERROR: JSON parse failed');
+  process.exit(2);
+}
+")
+
+# Check if parsing failed
+if [ $? -ne 0 ]; then
+  exit 2
+fi
+
+# Validate command not empty
+if [ -z "$COMMAND" ]; then
+  echo "ERROR: Empty command" >&2
+  exit 2
+fi
+
+# Blocked patterns (regex)
+BLOCKED="node_modules|__pycache__|\.git/|dist/|build/"
+
+# Check if command matches blocked pattern
+if echo "$COMMAND" | grep -qE "$BLOCKED"; then
+  echo "ERROR: Blocked directory pattern" >&2
+  exit 2
+fi
+
+# Allow command (exit 0)
+exit 0

package/.claude/hooks/send-discord.sh

@@ -0,0 +1,75 @@
+#!/bin/bash
+
+# Usage: ./send-discord.sh 'Your message here'
+# Note: Remember to escape the string
+
+# Load environment variables with priority: process.env > .claude/.env > .claude/hooks/.env
+load_env() {
+    # 1. Start with lowest priority: .claude/hooks/.env
+    if [[ -f "$(dirname "$0")/.env" ]]; then
+        set -a
+        source "$(dirname "$0")/.env"
+        set +a
+    fi
+
+    # 2. Override with .claude/.env
+    if [[ -f .claude/.env ]]; then
+        set -a
+        source .claude/.env
+        set +a
+    fi
+
+    # 3. Process env (already loaded) has highest priority - no action needed
+    # Variables already in process.env will not be overwritten by 'source'
+}
+
+load_env
+
+message="$1"
+    
+if [[ -z "$DISCORD_WEBHOOK_URL" ]]; then
+    echo "⚠️  Discord notification skipped: DISCORD_WEBHOOK_URL not set"
+    exit 1
+fi
+
+# Prepare message for Discord (Discord markdown supports \n)
+discord_message="$message"
+
+# Discord embeds for richer formatting
+payload=$(cat <<EOF
+{
+"embeds": [{
+    "title": "🤖 Claude Code Session Complete",
+    "description": "$discord_message",
+    "color": 5763719,
+    "timestamp": "$(date -u +%Y-%m-%dT%H:%M:%S.000Z)",
+    "footer": {
+        "text": "DevPocket API • $(basename "$(pwd)")"
+    },
+    "fields": [
+        {
+            "name": "⏰ Session Time",
+            "value": "$(date '+%H:%M:%S')",
+            "inline": true
+        },
+        {
+            "name": "📂 Project",
+            "value": "$(basename "$(pwd)")",
+            "inline": true
+        }
+    ]
+}]
+}
+EOF
+)
+
+curl -s -X POST "$DISCORD_WEBHOOK_URL" \
+    -H "Content-Type: application/json" \
+    -d "$payload" >/dev/null 2>&1
+
+if [[ $? -eq 0 ]]; then
+    echo "✅ Discord notification sent"
+else
+    echo "❌ Failed to send Discord notification"
+    exit 1
+fi