@zenuml/core 3.32.6 → 3.33.0

package/.claude/hooks/README.md

@@ -0,0 +1,270 @@
+# Claude Code Hooks
+
+This directory contains battle-tested hooks that enhance your Claude Code development experience with automated security scanning, intelligent context injection, and pleasant audio feedback.
+
+## Architecture
+
+```
+Claude Code Lifecycle
+        │
+        ├── PreToolUse ──────► Security Scanner
+        │                      ├── Context Injector (Gemini)
+        │                      └── Context Injector (Subagents)
+        │
+        ├── Tool Execution
+        │
+        ├── PostToolUse
+        │
+        ├── Notification ────────► Audio Feedback
+        │
+        └── Stop/SubagentStop ───► Completion Sound
+```
+
+These hooks execute at specific points in Claude Code's lifecycle, providing deterministic control over AI behavior.
+
+## Available Hooks
+
+### 1. Gemini Context Injector (`gemini-context-injector.sh`)
+
+**Purpose**: Automatically includes your project documentation and assistant rules when starting new Gemini consultation sessions, ensuring the AI has complete context about your codebase and project standards.
+
+**Trigger**: `PreToolUse` for `mcp__gemini__consult_gemini`
+
+**Features**:
+- Detects new Gemini consultation sessions (no session_id)
+- Automatically attaches two key files:
+  - `docs/ai-context/project-structure.md` - Complete project structure and tech stack
+  - `MCP-ASSISTANT-RULES.md` - Project-specific coding standards and guidelines
+- Preserves existing file attachments
+- Session-aware (only injects on new sessions)
+- Logs all injection events for debugging
+- Fails gracefully if either file is missing
+- Handles partial availability (will attach whichever files exist)
+
+**Customization**: 
+- Copy `docs/MCP-ASSISTANT-RULES.md` template to your project root
+- Customize it with your project-specific standards, principles, and constraints
+- The hook will automatically include it in Gemini consultations
+
+### 2. MCP Security Scanner (`mcp-security-scan.sh`)
+
+**Purpose**: Prevents accidental exposure of secrets, API keys, and sensitive data when using MCP servers like Gemini or Context7.
+
+**Trigger**: `PreToolUse` for all MCP tools (`mcp__.*`)
+
+**Features**:
+- Pattern-based detection for API keys, passwords, and secrets
+- Scans code context, problem descriptions, and attached files
+- File content scanning with size limits
+- Configurable pattern matching via `config/sensitive-patterns.json`
+- Whitelisting for placeholder values
+- Command injection protection for Context7
+- Comprehensive logging of security events to `.claude/logs/`
+
+**Customization**: Edit `config/sensitive-patterns.json` to:
+- Add custom API key patterns
+- Modify credential detection rules
+- Update sensitive file patterns
+- Extend the whitelist for your placeholders
+
+### 3. Subagent Context Injector (`subagent-context-injector.sh`)
+
+**Purpose**: Automatically includes core project documentation in all sub-agent Task prompts, ensuring consistent context across multi-agent workflows.
+
+**Trigger**: `PreToolUse` for `Task` tool
+
+**Features**:
+- Intercepts all Task tool calls before execution
+- Prepends references to three core documentation files:
+  - `docs/CLAUDE.md` - Project overview, coding standards, AI instructions
+  - `docs/ai-context/project-structure.md` - Complete file tree and tech stack
+  - `docs/ai-context/docs-overview.md` - Documentation architecture
+- Passes through non-Task tools unchanged
+- Preserves original task prompt by prepending context
+- Enables consistent knowledge across all sub-agents
+- Eliminates need for manual context inclusion in Task prompts
+
+**Benefits**:
+- Every sub-agent starts with the same foundational knowledge
+- No manual context specification needed in each Task prompt
+- Token-efficient through @ references instead of content duplication
+- Update context in one place, affects all sub-agents
+- Clean operation with simple pass-through for non-Task tools
+
+### 4. Notification System (`notify.sh`)
+
+**Purpose**: Provides pleasant audio feedback when Claude Code needs your attention or completes tasks.
+
+**Triggers**: 
+- `Notification` events (all notifications including input needed)
+- `Stop` events (main task completion)
+
+**Features**:
+- Cross-platform audio support (macOS, Linux, Windows)
+- Non-blocking audio playback (runs in background)
+- Multiple audio playback fallbacks
+- Pleasant notification sounds
+- Two notification types:
+  - `input`: When Claude needs user input
+  - `complete`: When Claude completes tasks
+
+## Installation
+
+1. **Copy the hooks to your project**:
+   ```bash
+   cp -r hooks your-project/.claude/
+   ```
+
+2. **Configure hooks in your project**:
+   ```bash
+   cp hooks/setup/settings.json.template your-project/.claude/settings.json
+   ```
+   Then edit the WORKSPACE path in the settings file.
+
+3. **Test the hooks**:
+   ```bash
+   # Test notification
+   .claude/hooks/notify.sh input
+   .claude/hooks/notify.sh complete
+   
+   # View logs
+   tail -f .claude/logs/context-injection.log
+   tail -f .claude/logs/security-scan.log
+   ```
+
+## Hook Configuration
+
+Add to your Claude Code `settings.json`:
+
+```json
+{
+  "hooks": {
+    "PreToolUse": [
+      {
+        "matcher": "mcp__gemini__consult_gemini",
+        "hooks": [
+          {
+            "type": "command",
+            "command": "${WORKSPACE}/.claude/hooks/gemini-context-injector.sh"
+          }
+        ]
+      },
+      {
+        "matcher": "mcp__.*",
+        "hooks": [
+          {
+            "type": "command",
+            "command": "${WORKSPACE}/.claude/hooks/mcp-security-scan.sh"
+          }
+        ]
+      },
+      {
+        "matcher": "Task",
+        "hooks": [
+          {
+            "type": "command",
+            "command": "${WORKSPACE}/.claude/hooks/subagent-context-injector.sh"
+          }
+        ]
+      }
+    ],
+    "Notification": [
+      {
+        "matcher": ".*",
+        "hooks": [
+          {
+            "type": "command",
+            "command": "${WORKSPACE}/.claude/hooks/notify.sh input"
+          }
+        ]
+      }
+    ],
+    "Stop": [
+      {
+        "matcher": ".*",
+        "hooks": [
+          {
+            "type": "command",
+            "command": "${WORKSPACE}/.claude/hooks/notify.sh complete"
+          }
+        ]
+      }
+    ]
+  }
+}
+```
+
+See `hooks/setup/settings.json.template` for the complete configuration including all hooks and MCP servers.
+
+## Security Model
+
+1. **Execution Context**: Hooks run with full user permissions
+2. **Blocking Behavior**: Exit code 2 blocks tool execution
+3. **Data Flow**: Hooks can modify tool inputs via JSON transformation
+4. **Isolation**: Each hook runs in its own process
+5. **Logging**: All security events logged to `.claude/logs/`
+
+## Integration with MCP Servers
+
+The hooks system complements MCP server integrations:
+
+- **Gemini Consultation**: Context injector ensures both project structure and MCP assistant rules are included
+- **Context7 Documentation**: Security scanner protects library ID inputs
+- **All MCP Tools**: Universal security scanning before external calls
+
+## Best Practices
+
+1. **Hook Design**:
+   - Fail gracefully - never break the main workflow
+   - Log important events for debugging
+   - Use exit codes appropriately (0=success, 2=block)
+   - Keep execution time minimal
+
+2. **Security**:
+   - Regularly update sensitive patterns
+   - Review security logs periodically
+   - Test hooks in safe environments first
+   - Never log sensitive data in hooks
+
+3. **Configuration**:
+   - Use `${WORKSPACE}` variable for portability
+   - Keep hooks executable (`chmod +x`)
+   - Version control hook configurations
+   - Document custom modifications
+
+## Troubleshooting
+
+### Hooks not executing
+- Check file permissions: `chmod +x *.sh`
+- Verify paths in settings.json
+- Check Claude Code logs for errors
+
+### Security scanner too restrictive
+- Review patterns in `config/sensitive-patterns.json`
+- Add legitimate patterns to the whitelist
+- Check logs for what triggered the block
+
+### No sound playing
+- Verify sound files exist in `sounds/` directory
+- Test audio playback: `.claude/hooks/notify.sh input`
+- Check system audio settings
+- Ensure you have an audio player installed (afplay, paplay, aplay, pw-play, play, ffplay, or PowerShell on Windows)
+
+## Hook Setup Command
+
+For comprehensive setup verification and testing, use:
+
+```
+/hook-setup
+```
+
+This command uses multi-agent orchestration to verify installation, check configuration, and run comprehensive tests. See [hook-setup.md](setup/hook-setup.md) for details.
+
+## Extension Points
+
+The kit is designed for extensibility:
+
+1. **Custom Hooks**: Add new scripts following the existing patterns
+2. **Event Handlers**: Configure hooks for any Claude Code event
+3. **Pattern Updates**: Modify security patterns for your needs
+4. **Sound Customization**: Replace audio files with your preferences

package/.claude/hooks/config/sensitive-patterns.json

@@ -0,0 +1,86 @@
+{
+  "patterns": {
+    "api_keys": [],
+    "credentials": [
+      "password\\s*[:=]\\s*[\"']?[^\\s\"']+[\"']?",
+      "passwd\\s*[:=]\\s*[\"']?[^\\s\"']+[\"']?",
+      "secret\\s*[:=]\\s*[\"']?[^\\s\"']+[\"']?",
+      "private[_-]?key\\s*[:=]\\s*[\"']?[^\\s\"']+[\"']?",
+      "access[_-]?key\\s*[:=]\\s*[\"']?[^\\s\"']+[\"']?",
+      "auth[_-]?token\\s*[:=]\\s*[\"']?[^\\s\"']+[\"']?",
+      "api[_-]?key\\s*[:=]\\s*[\"']?[^\\s\"']+[\"']?",
+      "client[_-]?secret\\s*[:=]\\s*[\"']?[^\\s\"']+[\"']?"
+    ],
+    "sensitive_files": [
+      ".env",
+      ".env.local",
+      ".env.production",
+      ".env.development",
+      ".env.staging",
+      "credentials.json",
+      "google-credentials.json",
+      "service-account.json",
+      "private.key",
+      "id_rsa",
+      "id_ed25519",
+      "id_dsa",
+      "id_ecdsa",
+      ".pem",
+      ".key",
+      ".p12",
+      ".pfx",
+      "keystore",
+      ".jks"
+    ],
+    "regex_patterns": [
+      "sk-[a-zA-Z0-9]{32,}",
+      "sk-proj-[a-zA-Z0-9]{32,}",
+      "AIza[0-9A-Za-z\\-_]{35}",
+      "gsk_[a-zA-Z0-9]{32,}",
+      "AKIA[0-9A-Z]{16}",
+      "aws_secret_access_key\\s*=\\s*[a-zA-Z0-9/+=]{40}",
+      "(postgres|postgresql|mysql|mongodb|redis)://[^:]+:[^@]+@[^/]+",
+      "-----BEGIN.*(RSA|DSA|EC|OPENSSH|PGP).*PRIVATE KEY-----",
+      "Bearer\\s+[a-zA-Z0-9\\-_]+\\.[a-zA-Z0-9\\-_]+\\.[a-zA-Z0-9\\-_]+",
+      "[A-Z_]+(KEY|TOKEN|SECRET|PASSWORD|PASSWD)\\s*=\\s*[\"']?[^\\s\"']+[\"']?",
+      "(api[_-]?key|access[_-]?token|auth[_-]?token)\\s*[:=]\\s*[\"']?[a-zA-Z0-9_\\-]{20,}[\"']?",
+      "(password|secret|key)\\s*[:=]\\s*[\"']?[A-Za-z0-9+/]{40,}={0,2}[\"']?",
+      "ghp_[a-zA-Z0-9]{36}",
+      "gho_[a-zA-Z0-9]{36}",
+      "github_pat_[a-zA-Z0-9]{22}_[a-zA-Z0-9]{59}",
+      "glpat-[a-zA-Z0-9\\-_]{20}",
+      "xoxb-[0-9]{10,13}-[0-9]{10,13}-[a-zA-Z0-9]{24}",
+      "sq0atp-[0-9A-Za-z\\-_]{22}",
+      "sq0csp-[0-9A-Za-z\\-_]{43}",
+      "SK[a-z0-9]{32}"
+    ]
+  },
+  "whitelist": {
+    "allowed_mentions": [
+      "GOOGLE_API_KEY=your_google_api_key_here",
+      "GROQ_API_KEY=your_groq_api_key_here",
+      "OPENAI_API_KEY=your_openai_api_key_here",
+      "GEMINI_API_KEY=your_gemini_api_key_here",
+      "AWS_ACCESS_KEY_ID=your_access_key_here",
+      "api_key=settings.api_key",
+      "api_key=process.env.API_KEY",
+      "api_key=YOUR_API_KEY",
+      "password=your_password_here",
+      "password=<your_password>",
+      "password=${PASSWORD}",
+      "token=your_token_here",
+      "token=<auth_token>",
+      "secret=your_secret_here",
+      "Bearer YOUR_TOKEN_HERE",
+      "Bearer <token>",
+      "postgres://user:password@localhost",
+      "mysql://root:password@localhost",
+      "mongodb://user:password@localhost",
+      "redis://user:password@localhost",
+      "connection_string = \"your_connection_string_here\"",
+      "API_KEY=<your_api_key>",
+      "SECRET_KEY=<your_secret_key>",
+      "DATABASE_URL=<your_database_url>"
+    ]
+  }
+}

package/.claude/hooks/gemini-context-injector.sh

@@ -0,0 +1,129 @@
+#!/bin/bash
+# Gemini Context Injector Hook
+# Automatically adds project context files to new Gemini consultation sessions:
+# - docs/ai-context/project-structure.md
+# - MCP-ASSISTANT-RULES.md
+#
+# This hook enhances Gemini consultations by automatically including your project's
+# structure documentation and assistant rules, ensuring the AI has complete context.
+
+set -euo pipefail
+
+SCRIPT_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
+PROJECT_ROOT="$(cd "$SCRIPT_DIR/../.." && pwd)"
+PROJECT_STRUCTURE_FILE="$PROJECT_ROOT/docs/ai-context/project-structure.md"
+MCP_RULES_FILE="$PROJECT_ROOT/MCP-ASSISTANT-RULES.md"
+LOG_FILE="$SCRIPT_DIR/../logs/context-injection.log"
+
+# Ensure log directory exists
+mkdir -p "$(dirname "$LOG_FILE")"
+
+# Read input from stdin
+INPUT_JSON=$(cat)
+
+# Function to log injection events
+log_injection_event() {
+    local event_type="$1"
+    local details="$2"
+    local timestamp=$(date -u +"%Y-%m-%dT%H:%M:%SZ")
+    echo "{\"timestamp\": \"$timestamp\", \"event\": \"$event_type\", \"details\": \"$details\"}" >> "$LOG_FILE"
+}
+
+# Main logic
+main() {
+    # Extract tool information from stdin
+    local tool_name=$(echo "$INPUT_JSON" | jq -r '.tool_name // ""')
+    
+    # Only process Gemini consultation requests
+    if [[ "$tool_name" != "mcp__gemini__consult_gemini" ]]; then
+        echo '{"continue": true}'
+        exit 0
+    fi
+    
+    # Extract tool arguments
+    local tool_args=$(echo "$INPUT_JSON" | jq -r '.tool_input // "{}"')
+    
+    # Check if this is a new session (no session_id provided)
+    local session_id=$(echo "$tool_args" | jq -r '.session_id // ""' 2>/dev/null || echo "")
+    
+    if [[ -z "$session_id" || "$session_id" == "null" ]]; then
+        log_injection_event "new_session_detected" "preparing_context_injection"
+        
+        # Check if required files exist
+        local missing_files=""
+        if [[ ! -f "$PROJECT_STRUCTURE_FILE" ]]; then
+            missing_files="$missing_files project_structure.md"
+        fi
+        if [[ ! -f "$MCP_RULES_FILE" ]]; then
+            missing_files="$missing_files MCP-ASSISTANT-RULES.md"
+        fi
+        
+        # If either file is missing, log warning but continue
+        if [[ -n "$missing_files" ]]; then
+            log_injection_event "warning" "missing_files:$missing_files"
+        fi
+        
+        # If both files are missing, exit early
+        if [[ ! -f "$PROJECT_STRUCTURE_FILE" ]] && [[ ! -f "$MCP_RULES_FILE" ]]; then
+            echo '{"continue": true}'
+            exit 0
+        fi
+        
+        # Extract current attached_files if any
+        local current_files=$(echo "$tool_args" | jq -c '.attached_files // []' 2>/dev/null || echo "[]")
+        
+        # Check if files are already included
+        local has_project_structure=$(echo "$current_files" | jq -e ".[] | select(. == \"$PROJECT_STRUCTURE_FILE\")" > /dev/null 2>&1 && echo "true" || echo "false")
+        local has_mcp_rules=$(echo "$current_files" | jq -e ".[] | select(. == \"$MCP_RULES_FILE\")" > /dev/null 2>&1 && echo "true" || echo "false")
+        
+        # If both files exist and are already included, skip
+        if [[ -f "$PROJECT_STRUCTURE_FILE" ]] && [[ "$has_project_structure" == "true" ]] && \
+           [[ -f "$MCP_RULES_FILE" ]] && [[ "$has_mcp_rules" == "true" ]]; then
+            log_injection_event "skipped" "all_required_files_already_included"
+            echo '{"continue": true}'
+            exit 0
+        fi
+        
+        # Add missing files to attached_files
+        local modified_args="$tool_args"
+        local files_added=""
+        
+        if [[ -f "$PROJECT_STRUCTURE_FILE" ]] && [[ "$has_project_structure" == "false" ]]; then
+            modified_args=$(echo "$modified_args" | jq --arg file "$PROJECT_STRUCTURE_FILE" '
+                .attached_files = ((.attached_files // []) + [$file])
+            ' 2>/dev/null)
+            files_added="$files_added project_structure.md"
+        fi
+        
+        if [[ -f "$MCP_RULES_FILE" ]] && [[ "$has_mcp_rules" == "false" ]]; then
+            modified_args=$(echo "$modified_args" | jq --arg file "$MCP_RULES_FILE" '
+                .attached_files = ((.attached_files // []) + [$file])
+            ' 2>/dev/null)
+            files_added="$files_added MCP-ASSISTANT-RULES.md"
+        fi
+        
+        if [[ -n "$modified_args" ]] && [[ "$modified_args" != "$tool_args" ]]; then
+            log_injection_event "context_injected" "added_files:$files_added"
+            
+            # Update the input JSON with modified tool_input
+            local output_json=$(echo "$INPUT_JSON" | jq --argjson new_args "$modified_args" '.tool_input = $new_args')
+            
+            # Return the modified input to stdout
+            echo "$output_json"
+            exit 0
+        else
+            log_injection_event "error" "failed_to_modify_arguments"
+            # Continue without modification on error
+            echo '{"continue": true}'
+            exit 0
+        fi
+    else
+        log_injection_event "existing_session" "session_id:$session_id"
+        # For existing sessions, continue without modification
+        echo '{"continue": true}'
+        exit 0
+    fi
+}
+
+# Run main function
+main

package/.claude/hooks/mcp-security-scan.sh

@@ -0,0 +1,147 @@
+#!/bin/bash
+# MCP Security Scanner Hook
+# Scans MCP requests for sensitive data before sending to external services
+#
+# This hook protects against accidental exposure of secrets, API keys, and other
+# sensitive information when using MCP servers like Gemini or Context7.
+
+set -euo pipefail
+
+SCRIPT_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
+PATTERNS_FILE="$SCRIPT_DIR/config/sensitive-patterns.json"
+LOG_FILE="$SCRIPT_DIR/../logs/security-scan.log"
+
+# Ensure log directory exists
+mkdir -p "$(dirname "$LOG_FILE")"
+
+# Read input from stdin
+INPUT_JSON=$(cat)
+
+# Function to log security events
+log_security_event() {
+    local event_type="$1"
+    local details="$2"
+    local tool_name="${3:-unknown}"
+    local timestamp=$(date -u +"%Y-%m-%dT%H:%M:%SZ")
+    echo "{\"timestamp\": \"$timestamp\", \"tool\": \"$tool_name\", \"event\": \"$event_type\", \"details\": \"$details\"}" >> "$LOG_FILE"
+}
+
+# Function to check if content matches sensitive patterns
+check_sensitive_content() {
+    local content="$1"
+    local pattern_type="$2"
+    
+    # Get patterns from JSON config
+    local patterns=$(jq -r ".patterns.$pattern_type[]" "$PATTERNS_FILE" 2>/dev/null || echo "")
+    
+    for pattern in $patterns; do
+        if echo "$content" | grep -qiE "$pattern"; then
+            # Check whitelist
+            local whitelisted=false
+            local whitelist_patterns=$(jq -r '.whitelist.allowed_mentions[]' "$PATTERNS_FILE" 2>/dev/null || echo "")
+            
+            for whitelist in $whitelist_patterns; do
+                if echo "$content" | grep -qF "$whitelist"; then
+                    whitelisted=true
+                    break
+                fi
+            done
+            
+            if [[ "$whitelisted" == "false" ]]; then
+                return 0  # Found sensitive data
+            fi
+        fi
+    done
+    
+    return 1  # No sensitive data found
+}
+
+# Function to scan file content
+scan_file_content() {
+    local file_path="$1"
+    
+    # Check if file name itself is sensitive
+    local filename=$(basename "$file_path")
+    if check_sensitive_content "$filename" "sensitive_files"; then
+        return 0  # Sensitive file
+    fi
+    
+    # Don't scan files that don't exist or are too large
+    if [[ ! -f "$file_path" ]] || [[ $(stat -f%z "$file_path" 2>/dev/null || stat -c%s "$file_path" 2>/dev/null || echo "999999999") -gt 1048576 ]]; then
+        return 1
+    fi
+    
+    # Read and scan file content
+    local content=$(cat "$file_path" 2>/dev/null || echo "")
+    
+    # Check all pattern types
+    for pattern_type in api_keys credentials regex_patterns; do
+        if check_sensitive_content "$content" "$pattern_type"; then
+            return 0  # Found sensitive data
+        fi
+    done
+    
+    return 1
+}
+
+# Main scanning logic
+main() {
+    # Extract tool information from stdin
+    local tool_name=$(echo "$INPUT_JSON" | jq -r '.tool_name // ""')
+    local tool_args=$(echo "$INPUT_JSON" | jq -r '.tool_input // "{}"')
+    
+    log_security_event "scan_started" "$tool_name" "$tool_name"
+    
+    # Check code_context for sensitive data
+    local code_context=$(echo "$tool_args" | jq -r '.code_context // ""' 2>/dev/null || echo "")
+    if [[ -n "$code_context" ]]; then
+        for pattern_type in api_keys credentials regex_patterns; do
+            if check_sensitive_content "$code_context" "$pattern_type"; then
+                log_security_event "blocked" "sensitive_data_in_code_context" "$tool_name"
+                echo '{"decision": "block", "reason": "Security Alert: Detected sensitive data in code_context. Found patterns matching actual credentials (API keys, passwords, or secrets with values). For discussions about security topics, use placeholders like YOUR_API_KEY, <password>, or example values instead of real credentials."}'
+                exit 2
+            fi
+        done
+    fi
+    
+    # Check problem_description for sensitive data
+    local problem_desc=$(echo "$tool_args" | jq -r '.problem_description // ""' 2>/dev/null || echo "")
+    if [[ -n "$problem_desc" ]]; then
+        for pattern_type in api_keys credentials regex_patterns; do
+            if check_sensitive_content "$problem_desc" "$pattern_type"; then
+                log_security_event "blocked" "sensitive_data_in_problem_description" "$tool_name"
+                echo '{"decision": "block", "reason": "Security Alert: Detected sensitive data in problem description. Found patterns matching actual credentials (API keys, passwords, connection strings, or tokens with values). For security discussions, use placeholders: YOUR_API_KEY, <password>, postgres://user:password@localhost, or example-token-here."}'
+                exit 2
+            fi
+        done
+    fi
+    
+    # Check attached files
+    local attached_files=$(echo "$tool_args" | jq -r '.attached_files[]?' 2>/dev/null || echo "")
+    for file in $attached_files; do
+        if scan_file_content "$file"; then
+            log_security_event "blocked" "sensitive_file_attached:$file" "$tool_name"
+            echo "{\"decision\": \"block\", \"reason\": \"Security Alert: Detected sensitive content in attached file $file. Found credentials, private keys, or environment files. Remove actual secrets and use placeholders like YOUR_SECRET_HERE or example values for demonstrations.\"}"
+            exit 2
+        fi
+    done
+    
+    # Check specific question for Context7
+    if [[ "$tool_name" == "mcp__context7__get-library-docs" ]]; then
+        local library_id=$(echo "$tool_args" | jq -r '.context7CompatibleLibraryID // ""' 2>/dev/null || echo "")
+        # Basic check to prevent injection attacks
+        if echo "$library_id" | grep -qE '(\$|`|;|&&|\|\||>|<)'; then
+            log_security_event "blocked" "suspicious_library_id" "$tool_name"
+            echo '{"decision": "block", "reason": "Security Alert: Detected suspicious characters in library ID that could indicate command injection. Please use only alphanumeric characters, hyphens, underscores, and forward slashes."}'
+            exit 2
+        fi
+    fi
+    
+    log_security_event "scan_completed" "no_sensitive_data_found" "$tool_name"
+    
+    # All checks passed, allow the tool to continue
+    # No output needed when allowing - just exit 0
+}
+
+# Run main function
+main