@paulduvall/claude-dev-toolkit 0.0.1-alpha.11 → 0.0.1-alpha.13

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.