@paulduvall/claude-dev-toolkit 0.0.1-alpha.2 → 0.0.1-alpha.21

package/templates/subagent-hooks.yaml

@@ -0,0 +1,188 @@
+# Claude Code Subagent-Hook Event Mapping Configuration
+# 
+# This file defines which subagents should be automatically invoked
+# during specific Claude Code events. Place this file at:
+# ~/.claude/subagent-hooks.yaml
+#
+# Format:
+#   event_name:
+#     - subagent-name
+#     - another-subagent
+#
+# Available events:
+#   - pre_write: Before any file write/edit operation
+#   - post_write: After successful file write/edit
+#   - pre_commit: Before git commit operations
+#   - post_commit: After successful git commit
+#   - pre_test: Before running tests
+#   - post_test: After test execution
+#   - on_error: When an error occurs
+#   - security_check: Security validation events
+#   - code_review: Code review triggers
+#   - deployment: Deployment-related events
+
+# File modification events
+pre_write:
+  - security-auditor        # Check for security issues before writing
+  - style-enforcer          # Ensure code style compliance
+  - license-compliance-guardian  # Verify license headers
+
+post_write:
+  - documentation-curator   # Update docs after code changes
+  - test-writer            # Generate/update tests for new code
+
+# Git workflow events  
+pre_commit:
+  - trunk-guardian         # Ensure branch policies are followed
+  - security-auditor       # Final security check before commit
+  - contract-tester        # Verify API contracts maintained
+
+post_commit:
+  - audit-trail-verifier   # Log changes for audit trail
+  - change-scoper         # Analyze change impact
+
+# Testing events
+pre_test:
+  - test-writer           # Ensure adequate test coverage
+  - environment-guardian  # Validate test environment
+
+post_test:
+  - performance-guardian  # Analyze performance results
+  - observability-engineer # Check monitoring coverage
+
+on_test_failure:
+  - debug-specialist      # Diagnose test failures
+  - test-writer          # Suggest test fixes
+
+# Build and deployment events
+pre_build:
+  - dependency-steward    # Check dependency versions
+  - sbom-provenance      # Generate software bill of materials
+
+pre_deployment:
+  - deployment-strategist # Plan deployment approach
+  - environment-guardian  # Validate target environment
+  - rollback-first-responder # Prepare rollback plan
+
+post_deployment:
+  - observability-engineer # Verify monitoring active
+  - performance-guardian   # Check performance metrics
+
+# Error handling events
+on_error:
+  - debug-specialist      # Analyze and diagnose errors
+  - rollback-first-responder # Prepare recovery plan
+
+on_security_violation:
+  - security-auditor      # Deep security analysis
+  - audit-trail-verifier  # Document violation
+
+# Code review events
+code_review:
+  - code-review-assistant # Automated review suggestions
+  - requirements-reviewer # Check requirements alignment
+  - api-guardian         # Verify API compatibility
+
+# Continuous improvement events
+daily_analysis:
+  - data-steward         # Data quality check
+  - performance-guardian # Performance trending
+  - dependency-steward   # Dependency updates
+
+weekly_review:
+  - product-owner-proxy  # Business alignment check
+  - workflow-coordinator # Process optimization
+
+# CI/CD pipeline events
+pipeline_failure:
+  - ci-pipeline-curator  # Diagnose pipeline issues
+  - debug-specialist     # Investigate failures
+
+pipeline_success:
+  - continuous-release-orchestrator # Plan next release
+  - audit-trail-verifier # Document successful build
+
+# Custom event examples (add your own)
+custom_security_scan:
+  - security-auditor
+  - license-compliance-guardian
+  - sbom-provenance
+
+custom_performance_check:
+  - performance-guardian
+  - observability-engineer
+  - debug-specialist
+
+# Priority configurations (optional)
+# Define execution order and blocking behavior
+priorities:
+  security-auditor:
+    priority: 1        # Execute first
+    blocking: true     # Block operation if issues found
+  
+  style-enforcer:
+    priority: 2
+    blocking: false    # Non-blocking, just warnings
+  
+  test-writer:
+    priority: 3
+    blocking: false
+  
+  documentation-curator:
+    priority: 4
+    blocking: false
+
+# Subagent configuration overrides (optional)
+# Override default subagent settings for specific events
+overrides:
+  pre_deployment:
+    deployment-strategist:
+      timeout: 300    # 5 minutes for deployment planning
+      tools: "Read, Grep, Glob, Bash"  # Restricted tools
+    
+    environment-guardian:
+      timeout: 120
+      require_approval: true  # Human approval needed
+
+  on_error:
+    debug-specialist:
+      timeout: 600    # 10 minutes for debugging
+      tools: "all"     # Full tool access for debugging
+
+# Event conditions (optional)
+# Define conditions for event triggering
+conditions:
+  pre_write:
+    file_patterns:
+      - "*.py"        # Only Python files
+      - "*.js"        # Only JavaScript files
+      - "*.ts"        # Only TypeScript files
+    
+    exclude_patterns:
+      - "*.test.*"    # Skip test files
+      - "*.spec.*"    # Skip spec files
+      - "__pycache__/*" # Skip cache directories
+
+  code_review:
+    branch_patterns:
+      - "feature/*"   # Feature branches
+      - "hotfix/*"    # Hotfix branches
+    
+    exclude_branches:
+      - "main"        # Skip main branch
+      - "develop"     # Skip develop branch
+
+# Notification settings (optional)
+notifications:
+  on_blocking_event:
+    log_level: "error"
+    alert_user: true
+  
+  on_security_violation:
+    log_level: "critical"
+    alert_user: true
+    notify_webhook: "${SECURITY_WEBHOOK_URL}"
+  
+  on_success:
+    log_level: "info"
+    alert_user: false

package/lib/package-manager-service.js

@@ -1,270 +0,0 @@
-/**
- * Package Manager Service
- * 
- * Handles cross-platform package manager operations and configurations.
- * Extracted from DependencyValidator as part of Phase 1 bloater refactoring.
- * 
- * Features:
- * - Multi-platform package manager support
- * - Package name mapping across different managers
- * - Command generation for install/check operations
- * - Platform-specific package manager detection
- */
-
-const { execSync } = require('child_process');
-const PlatformUtils = require('./platform-utils');
-
-class PackageManagerService {
-    constructor() {
-        this.platformUtils = new PlatformUtils();
-        this.config = {
-            packageManagers: this._createPackageManagersConfig(),
-            dependencyMappings: this._createDependencyMappings()
-        };
-    }
-    
-    /**
-     * Create package managers configuration by platform
-     * @returns {Object} Package managers by platform
-     * @private
-     */
-    _createPackageManagersConfig() {
-        return {
-            linux: [
-                { name: 'apt', install: 'sudo apt-get install {package}', check: 'dpkg -l {package}' },
-                { name: 'yum', install: 'sudo yum install {package}', check: 'rpm -q {package}' },
-                { name: 'dnf', install: 'sudo dnf install {package}', check: 'rpm -q {package}' },
-                { name: 'pacman', install: 'sudo pacman -S {package}', check: 'pacman -Q {package}' },
-                { name: 'snap', install: 'sudo snap install {package}', check: 'snap list {package}' }
-            ],
-            darwin: [
-                { name: 'brew', install: 'brew install {package}', check: 'brew list {package}' },
-                { name: 'port', install: 'sudo port install {package}', check: 'port installed {package}' },
-                { name: 'npm', install: 'npm install -g {package}', check: 'npm list -g {package}' }
-            ],
-            win32: [
-                { name: 'chocolatey', install: 'choco install {package}', check: 'choco list --local-only {package}' },
-                { name: 'winget', install: 'winget install {package}', check: 'winget list {package}' },
-                { name: 'npm', install: 'npm install -g {package}', check: 'npm list -g {package}' },
-                { name: 'scoop', install: 'scoop install {package}', check: 'scoop list {package}' }
-            ]
-        };
-    }
-    
-    /**
-     * Create dependency mappings for package managers
-     * @returns {Object} Dependency mappings by tool and platform
-     * @private
-     */
-    _createDependencyMappings() {
-        return {
-            git: {
-                linux: { apt: 'git', yum: 'git', dnf: 'git', pacman: 'git' },
-                darwin: { brew: 'git' },
-                win32: { chocolatey: 'git', winget: 'Git.Git' }
-            },
-            python: {
-                linux: { apt: 'python3', yum: 'python3', dnf: 'python3' },
-                darwin: { brew: 'python@3.11' },
-                win32: { chocolatey: 'python', winget: 'Python.Python.3' }
-            },
-            docker: {
-                linux: { apt: 'docker.io', snap: 'docker' },
-                darwin: { brew: 'docker' },
-                win32: { chocolatey: 'docker-desktop' }
-            }
-        };
-    }
-    
-    /**
-     * Get package managers for a specific platform
-     * @param {string} platform - Platform identifier (optional, defaults to current)
-     * @returns {Array<Object>} List of package managers for the platform
-     */
-    getPackageManagersForPlatform(platform = this.platformUtils.getCurrentPlatform()) {
-        return this.config.packageManagers[platform] || [];
-    }
-    
-    /**
-     * Get package name for a specific dependency and package manager
-     * @param {string} dependencyName - Name of the dependency
-     * @param {string} packageManagerName - Name of the package manager
-     * @param {string} platform - Platform identifier (optional, defaults to current)
-     * @returns {string} Mapped package name or original dependency name
-     */
-    getPackageName(dependencyName, packageManagerName, platform = this.platformUtils.getCurrentPlatform()) {
-        const dependencyMapping = this.config.dependencyMappings[dependencyName];
-        
-        if (dependencyMapping && dependencyMapping[platform] && dependencyMapping[platform][packageManagerName]) {
-            return dependencyMapping[platform][packageManagerName];
-        }
-        
-        return dependencyName;
-    }
-    
-    /**
-     * Generate install command for a package
-     * @param {string} dependencyName - Name of the dependency
-     * @param {string} packageManagerName - Name of the package manager
-     * @param {string} platform - Platform identifier (optional, defaults to current)
-     * @returns {string|null} Install command or null if package manager not found
-     */
-    generateInstallCommand(dependencyName, packageManagerName, platform = this.platformUtils.getCurrentPlatform()) {
-        const packageManagers = this.getPackageManagersForPlatform(platform);
-        const packageManager = packageManagers.find(pm => pm.name === packageManagerName);
-        
-        if (!packageManager) {
-            return null;
-        }
-        
-        const packageName = this.getPackageName(dependencyName, packageManagerName, platform);
-        return packageManager.install.replace('{package}', packageName);
-    }
-    
-    /**
-     * Generate check command for a package
-     * @param {string} dependencyName - Name of the dependency
-     * @param {string} packageManagerName - Name of the package manager
-     * @param {string} platform - Platform identifier (optional, defaults to current)
-     * @returns {string|null} Check command or null if package manager not found
-     */
-    generateCheckCommand(dependencyName, packageManagerName, platform = this.platformUtils.getCurrentPlatform()) {
-        const packageManagers = this.getPackageManagersForPlatform(platform);
-        const packageManager = packageManagers.find(pm => pm.name === packageManagerName);
-        
-        if (!packageManager) {
-            return null;
-        }
-        
-        const packageName = this.getPackageName(dependencyName, packageManagerName, platform);
-        return packageManager.check.replace('{package}', packageName);
-    }
-    
-    /**
-     * Check if a package manager is available on the system
-     * @param {string} packageManagerName - Name of the package manager
-     * @returns {boolean} True if package manager is available
-     */
-    isPackageManagerAvailable(packageManagerName) {
-        try {
-            const command = this.platformUtils.getPathCommand();
-            execSync(`${command} ${packageManagerName}`, {
-                encoding: 'utf8',
-                timeout: 3000,
-                stdio: 'pipe'
-            });
-            return true;
-        } catch (error) {
-            return false;
-        }
-    }
-    
-    /**
-     * Get available package managers for the current platform
-     * @param {string} platform - Platform identifier (optional, defaults to current)
-     * @returns {Array<Object>} List of available package managers
-     */
-    getAvailablePackageManagers(platform = this.platformUtils.getCurrentPlatform()) {
-        const allManagers = this.getPackageManagersForPlatform(platform);
-        return allManagers.filter(pm => this.isPackageManagerAvailable(pm.name));
-    }
-    
-    /**
-     * Get the best available package manager for a platform
-     * @param {string} platform - Platform identifier (optional, defaults to current)
-     * @returns {Object|null} Best available package manager or null
-     */
-    getBestAvailablePackageManager(platform = this.platformUtils.getCurrentPlatform()) {
-        const availableManagers = this.getAvailablePackageManagers(platform);
-        
-        // Return the first available manager (they're ordered by preference)
-        return availableManagers.length > 0 ? availableManagers[0] : null;
-    }
-    
-    /**
-     * Generate package manager options for installation instructions
-     * @param {string} dependencyName - Name of the dependency
-     * @param {string} platform - Platform identifier (optional, defaults to current)
-     * @returns {Array<Object>} List of package manager options
-     */
-    generatePackageManagerOptions(dependencyName, platform = this.platformUtils.getCurrentPlatform()) {
-        const packageManagers = this.getPackageManagersForPlatform(platform);
-        const options = [];
-        
-        for (const pm of packageManagers) {
-            const packageName = this.getPackageName(dependencyName, pm.name, platform);
-            const installCommand = pm.install.replace('{package}', packageName);
-            const checkCommand = pm.check.replace('{package}', packageName);
-            
-            options.push({
-                name: pm.name,
-                command: installCommand,
-                check: checkCommand,
-                packageName: packageName,
-                available: this.isPackageManagerAvailable(pm.name)
-            });
-        }
-        
-        return options;
-    }
-    
-    /**
-     * Check if a specific package is installed
-     * @param {string} dependencyName - Name of the dependency
-     * @param {string} packageManagerName - Name of the package manager
-     * @param {string} platform - Platform identifier (optional, defaults to current)
-     * @returns {boolean} True if package is installed
-     */
-    isPackageInstalled(dependencyName, packageManagerName, platform = this.platformUtils.getCurrentPlatform()) {
-        const checkCommand = this.generateCheckCommand(dependencyName, packageManagerName, platform);
-        
-        if (!checkCommand) {
-            return false;
-        }
-        
-        try {
-            execSync(checkCommand, {
-                encoding: 'utf8',
-                timeout: 5000,
-                stdio: 'pipe'
-            });
-            return true;
-        } catch (error) {
-            return false;
-        }
-    }
-    
-    /**
-     * Execute a package manager command safely
-     * @param {string} command - Command to execute
-     * @param {Object} options - Execution options
-     * @returns {Object} Execution result
-     */
-    executePackageManagerCommand(command, options = {}) {
-        const defaultOptions = {
-            encoding: 'utf8',
-            timeout: 30000, // 30 seconds for package operations
-            stdio: 'pipe'
-        };
-        
-        const execOptions = { ...defaultOptions, ...options };
-        
-        try {
-            const output = execSync(command, execOptions);
-            return {
-                success: true,
-                output: output.toString(),
-                command: command
-            };
-        } catch (error) {
-            return {
-                success: false,
-                error: error.message,
-                command: command,
-                exitCode: error.status
-            };
-        }
-    }
-}
-
-module.exports = PackageManagerService;

package/subagents/debug-context.md

@@ -1,197 +0,0 @@
-# Debug Context Management System
-
-## Overview
-This system enables the Debug Specialist sub-agent to maintain persistent debugging context across multiple interactions, building comprehensive understanding of complex issues.
-
-## Context Structure
-
-### Debug Session Context
-```json
-{
-  "session_id": "debug_session_[timestamp]",
-  "issue_summary": "Brief description of the main problem",
-  "status": "active|investigating|resolved|escalated",
-  "priority": "low|medium|high|critical",
-  "created_at": "ISO timestamp",
-  "updated_at": "ISO timestamp",
-  "context": {
-    "error_details": {
-      "primary_error": "Main error message",
-      "secondary_errors": ["Related error messages"],
-      "stack_traces": ["Full stack trace data"],
-      "error_frequency": "once|intermittent|frequent|constant",
-      "reproduction_steps": ["Step-by-step reproduction"]
-    },
-    "environment": {
-      "os": "Operating system details",
-      "language_version": "Programming language version",
-      "dependencies": ["Package versions and details"],
-      "configuration": ["Relevant config settings"],
-      "deployment_context": "local|staging|production"
-    },
-    "codebase_state": {
-      "recent_changes": ["Recent commits or modifications"],
-      "affected_files": ["Files related to the issue"],
-      "test_status": "passing|failing|mixed",
-      "last_working_state": "Known good configuration"
-    },
-    "investigation_history": [
-      {
-        "timestamp": "ISO timestamp",
-        "action": "hypothesis_formed|test_executed|solution_attempted",
-        "details": "What was done or discovered",
-        "result": "success|failure|partial|inconclusive",
-        "notes": "Additional observations"
-      }
-    ],
-    "hypotheses": [
-      {
-        "theory": "Potential root cause explanation",
-        "confidence": "low|medium|high",
-        "status": "untested|testing|confirmed|rejected",
-        "evidence": ["Supporting or contradicting evidence"],
-        "test_plan": ["Steps to validate this hypothesis"]
-      }
-    ],
-    "solutions_attempted": [
-      {
-        "approach": "Description of solution attempted",
-        "implementation": "Code changes or actions taken",
-        "result": "resolved|partial_fix|no_change|made_worse",
-        "rollback_info": "How to undo if needed",
-        "learned": "Key insights from this attempt"
-      }
-    ]
-  }
-}
-```
-
-## Context Operations
-
-### Initialize Debug Session
-```markdown
-# Debug Session: [Issue Summary]
-**Session ID**: debug_session_[timestamp]
-**Status**: Active
-**Priority**: [Based on impact assessment]
-
-## Current Understanding
-- **Primary Issue**: [Main problem description]
-- **Environment**: [Key environment details]
-- **Recent Changes**: [What changed recently]
-
-## Investigation Plan
-1. [Initial hypothesis or investigation step]
-2. [Next planned action]
-3. [Validation approach]
-
-*This is a persistent debugging session. Context will be maintained across interactions.*
-```
-
-### Update Context During Investigation
-```markdown
-## Investigation Update - [Timestamp]
-
-**Action Taken**: [What was investigated or attempted]
-**Result**: [Outcome of the action]
-**New Evidence**: [What was discovered]
-
-### Updated Hypotheses
-- **Theory A**: [Status and confidence level]
-- **Theory B**: [New theory based on evidence]
-
-### Next Steps
-1. [Immediate next action]
-2. [Follow-up investigation]
-```
-
-### Context Retrieval Prompts
-When the debug sub-agent is invoked, it should check for existing context:
-
-```markdown
-**Context Check**: Is this related to an existing debug session?
-- Check for similar error patterns
-- Look for related file paths or components
-- Match against recent debugging history
-
-**If Related**: Load existing context and continue investigation
-**If New**: Initialize new debug session with context tracking
-```
-
-## Context Persistence Strategies
-
-### File-Based Context Storage
-- Store context in `/debug-sessions/` directory
-- Use session IDs for file naming
-- JSON format for structured data
-- Markdown summaries for human readability
-
-### Cross-Session Learning
-- Maintain database of resolved issues
-- Pattern recognition for similar problems
-- Solution effectiveness tracking
-- Environmental correlation analysis
-
-### Context Sharing
-- Share context with other sub-agents when relevant
-- Security Analyst: For security-related debugging
-- Code Quality Reviewer: For quality-related issues
-- Architecture Consultant: For systemic problems
-
-## Usage Patterns
-
-### New Debug Session
-```
-@debug-specialist I'm getting a "ModuleNotFoundError" in my Flask app
-→ Creates new debug session
-→ Initializes context tracking
-→ Begins systematic investigation
-```
-
-### Continuing Existing Session
-```
-@debug-specialist Update on the Flask ModuleNotFoundError - tried your suggestion but still failing
-→ Loads existing session context
-→ Updates investigation history
-→ Adjusts hypotheses based on new information
-```
-
-### Complex Multi-Day Debugging
-```
-Day 1: Initial investigation and hypothesis formation
-Day 2: Environment analysis and dependency checking  
-Day 3: Solution implementation and validation
-→ All context preserved across days
-→ Investigation history maintained
-→ Learning captured for future similar issues
-```
-
-## Integration with Slash Commands
-
-### From /xdebug
-When `/xdebug` delegates to debug-specialist:
-- Include current error details in context initialization
-- Transfer any preliminary analysis done
-- Set appropriate priority based on error severity
-
-### Context Handoff
-```markdown
-**Debugging Handoff from /xdebug**
-- **Error**: [Error details]
-- **Preliminary Analysis**: [Any initial findings]
-- **User Request**: [What user specifically asked for]
-- **Context Priority**: [Suggested session priority]
-
-*Continuing with Debug Specialist sub-agent for persistent context and deep analysis...*
-```
-
-## Benefits of Persistent Context
-
-1. **Avoid Repetition**: Don't re-investigate known facts
-2. **Build Understanding**: Accumulate knowledge over time
-3. **Pattern Recognition**: Identify recurring issues
-4. **Solution Tracking**: Remember what works and what doesn't
-5. **Learning**: Improve debugging effectiveness over time
-6. **Collaboration**: Share context with team members and other agents
-
-This context management system transforms debugging from isolated problem-solving into systematic investigation with memory and learning capabilities.