@paulduvall/claude-dev-toolkit 0.0.1-alpha.1

package/lib/command-selector.js

@@ -0,0 +1,245 @@
+const path = require('path');
+
+/**
+ * Manages command selection and categorization
+ * Extracted from InteractiveSetupWizard for better separation of concerns
+ */
+class CommandSelector {
+    constructor() {
+        this.commandCategories = {
+            'planning': ['xplanning', 'xspec', 'xarchitecture'],
+            'development': ['xgit', 'xtest', 'xquality', 'xrefactor', 'xtdd'],
+            'security': ['xsecurity', 'xpolicy', 'xcompliance'],
+            'deployment': ['xrelease', 'xpipeline', 'xinfra'],
+            'documentation': ['xdocs']
+        };
+
+        this.presets = {
+            'developer': {
+                installationType: 'standard',
+                commandSets: ['development', 'planning'],
+                securityHooks: true,
+                template: 'basic'
+            },
+            'security-focused': {
+                installationType: 'full',
+                commandSets: ['security', 'development'],
+                securityHooks: true,
+                template: 'security-focused'
+            },
+            'minimal': {
+                installationType: 'minimal',
+                commandSets: [],
+                securityHooks: false,
+                template: 'basic'
+            }
+        };
+    }
+
+    /**
+     * Get available command categories
+     * @returns {Object} Command categories with commands
+     */
+    getCommandCategories() {
+        return this.commandCategories;
+    }
+
+    /**
+     * Get category names
+     * @returns {Array<string>} Category names
+     */
+    getCategoryNames() {
+        return Object.keys(this.commandCategories);
+    }
+
+    /**
+     * Get commands for a specific category
+     * @param {string} category - Category name
+     * @returns {Array<string>} Commands in category
+     */
+    getCommandsForCategory(category) {
+        return this.commandCategories[category] || [];
+    }
+
+    /**
+     * Select command sets based on categories
+     * @param {Array<string>} categories - Selected categories
+     * @returns {Object} Selection result with commands
+     */
+    selectCommandSets(categories) {
+        const validCategories = categories.filter(cat => 
+            this.commandCategories.hasOwnProperty(cat)
+        );
+
+        return {
+            selected: validCategories,
+            commands: validCategories.flatMap(cat => this.commandCategories[cat] || []),
+            invalid: categories.filter(cat => !this.commandCategories.hasOwnProperty(cat))
+        };
+    }
+
+    /**
+     * Get all available commands
+     * @returns {Array<string>} All commands across categories
+     */
+    getAllCommands() {
+        return Object.values(this.commandCategories).flat();
+    }
+
+    /**
+     * Get command count for each category
+     * @returns {Object} Category names mapped to command counts
+     */
+    getCategoryCommandCounts() {
+        const counts = {};
+        Object.entries(this.commandCategories).forEach(([category, commands]) => {
+            counts[category] = commands.length;
+        });
+        return counts;
+    }
+
+    /**
+     * Find category for a specific command
+     * @param {string} command - Command name
+     * @returns {string|null} Category name or null if not found
+     */
+    findCategoryForCommand(command) {
+        for (const [category, commands] of Object.entries(this.commandCategories)) {
+            if (commands.includes(command)) {
+                return category;
+            }
+        }
+        return null;
+    }
+
+    /**
+     * Get available presets
+     * @returns {Object} Available presets
+     */
+    getPresets() {
+        return this.presets;
+    }
+
+    /**
+     * Get preset names
+     * @returns {Array<string>} Preset names
+     */
+    getPresetNames() {
+        return Object.keys(this.presets);
+    }
+
+    /**
+     * Apply a preset configuration
+     * @param {string} presetName - Name of preset to apply
+     * @returns {Object|null} Preset configuration or null if not found
+     */
+    applyPreset(presetName) {
+        return this.presets[presetName] || null;
+    }
+
+    /**
+     * Validate command selection
+     * @param {Array<string>} commands - Commands to validate
+     * @returns {Object} Validation result
+     */
+    validateCommandSelection(commands) {
+        const allCommands = this.getAllCommands();
+        const valid = commands.filter(cmd => allCommands.includes(cmd));
+        const invalid = commands.filter(cmd => !allCommands.includes(cmd));
+
+        return {
+            valid: invalid.length === 0,
+            validCommands: valid,
+            invalidCommands: invalid,
+            errors: invalid.length > 0 ? [`Invalid commands: ${invalid.join(', ')}`] : []
+        };
+    }
+
+    /**
+     * Get command statistics
+     * @returns {Object} Statistics about commands and categories
+     */
+    getCommandStats() {
+        const totalCommands = this.getAllCommands().length;
+        const categoryCount = Object.keys(this.commandCategories).length;
+        const presetCount = Object.keys(this.presets).length;
+
+        return {
+            totalCommands,
+            categoryCount,
+            presetCount,
+            averageCommandsPerCategory: Math.round(totalCommands / categoryCount),
+            categoriesWithCounts: this.getCategoryCommandCounts()
+        };
+    }
+
+    /**
+     * Add new command category
+     * @param {string} category - Category name
+     * @param {Array<string>} commands - Commands in category
+     * @returns {boolean} Success status
+     */
+    addCommandCategory(category, commands) {
+        if (this.commandCategories.hasOwnProperty(category)) {
+            return false; // Category already exists
+        }
+
+        this.commandCategories[category] = [...commands];
+        return true;
+    }
+
+    /**
+     * Remove command category
+     * @param {string} category - Category name to remove
+     * @returns {boolean} Success status
+     */
+    removeCommandCategory(category) {
+        if (!this.commandCategories.hasOwnProperty(category)) {
+            return false; // Category doesn't exist
+        }
+
+        delete this.commandCategories[category];
+        return true;
+    }
+
+    /**
+     * Add command to existing category
+     * @param {string} category - Category name
+     * @param {string} command - Command to add
+     * @returns {boolean} Success status
+     */
+    addCommandToCategory(category, command) {
+        if (!this.commandCategories.hasOwnProperty(category)) {
+            return false; // Category doesn't exist
+        }
+
+        if (this.commandCategories[category].includes(command)) {
+            return false; // Command already exists in category
+        }
+
+        this.commandCategories[category].push(command);
+        return true;
+    }
+
+    /**
+     * Remove command from category
+     * @param {string} category - Category name
+     * @param {string} command - Command to remove
+     * @returns {boolean} Success status
+     */
+    removeCommandFromCategory(category, command) {
+        if (!this.commandCategories.hasOwnProperty(category)) {
+            return false; // Category doesn't exist
+        }
+
+        const index = this.commandCategories[category].indexOf(command);
+        if (index === -1) {
+            return false; // Command not in category
+        }
+
+        this.commandCategories[category].splice(index, 1);
+        return true;
+    }
+}
+
+module.exports = CommandSelector;

package/lib/config.js

@@ -0,0 +1,182 @@
+// Configuration management for Claude Dev Toolkit
+const path = require('path');
+const os = require('os');
+const fs = require('fs');
+
+/**
+ * Parse JSONC (JSON with Comments) format
+ * Handles comment key-value pairs and block comments
+ * @param {string} content - Raw JSONC content
+ * @returns {Object} - Parsed JSON object
+ * @throws {Error} - If JSON parsing fails
+ */
+function parseJSONC(content) {
+    const lines = content.split('\n');
+    const cleanedLines = [];
+    
+    for (const line of lines) {
+        // Skip lines that are comment key-value pairs like '"// comment": "value",'
+        if (line.trim().match(/^"\/\/[^"]*":\s*"[^"]*",?\s*$/)) {
+            continue;
+        }
+        // Skip pure comment lines
+        if (line.trim().startsWith('//')) {
+            continue;
+        }
+        cleanedLines.push(line);
+    }
+    
+    const cleanedContent = cleanedLines.join('\n')
+        .replace(/\/\*[\s\S]*?\*\//g, '') // Remove /* */ comments
+        .replace(/,(\s*[}\]])/g, '$1'); // Remove trailing commas
+    
+    return JSON.parse(cleanedContent);
+}
+
+/**
+ * Deep merge two objects, with second object taking precedence
+ * @param {Object} target - Target object to merge into
+ * @param {Object} source - Source object to merge from
+ * @returns {Object} - Merged object
+ */
+function deepMerge(target, source) {
+    const result = { ...target };
+    
+    for (const [key, value] of Object.entries(source)) {
+        if (value && typeof value === 'object' && !Array.isArray(value)) {
+            result[key] = deepMerge(result[key] || {}, value);
+        } else {
+            result[key] = value;
+        }
+    }
+    
+    return result;
+}
+
+/**
+ * Apply a configuration template to Claude Code settings
+ * Implements REQ-009: Configuration Template Application
+ * 
+ * @param {string} templatePath - Path to the template file
+ * @param {string} settingsPath - Path to the settings file to create/update  
+ * @returns {boolean} - True if successful, false otherwise
+ */
+function applyConfigurationTemplate(templatePath, settingsPath) {
+    try {
+        // Validate inputs
+        if (!templatePath || !settingsPath) {
+            return false;
+        }
+
+        // Check if template exists
+        if (!fs.existsSync(templatePath)) {
+            return false;
+        }
+
+        // Read and parse template (handle JSONC with comments)
+        const templateContent = fs.readFileSync(templatePath, 'utf8');
+        let templateData;
+        
+        try {
+            templateData = parseJSONC(templateContent);
+        } catch (parseError) {
+            // Invalid JSON/JSONC format
+            return false;
+        }
+
+        // Validate template data
+        if (!templateData || typeof templateData !== 'object') {
+            return false;
+        }
+
+        // Read existing settings if they exist
+        let existingSettings = {};
+        if (fs.existsSync(settingsPath)) {
+            try {
+                const existingContent = fs.readFileSync(settingsPath, 'utf8');
+                existingSettings = JSON.parse(existingContent);
+            } catch (parseError) {
+                // If existing settings are invalid, start fresh but log the issue
+                existingSettings = {};
+            }
+        }
+
+        // Deep merge template with existing settings (template takes precedence)
+        const mergedSettings = deepMerge(existingSettings, templateData);
+
+        // Ensure target directory exists with correct permissions
+        const settingsDir = path.dirname(settingsPath);
+        fs.mkdirSync(settingsDir, { recursive: true, mode: 0o755 });
+
+        // Write merged settings with formatted output
+        const settingsJson = JSON.stringify(mergedSettings, null, 2);
+        fs.writeFileSync(settingsPath, settingsJson, { mode: 0o644 });
+
+        // Verify file was created successfully
+        return fs.existsSync(settingsPath);
+
+    } catch (error) {
+        // Log error in development but don't expose details
+        if (process.env.NODE_ENV === 'development') {
+            console.error('Configuration template application error:', error);
+        }
+        return false;
+    }
+}
+
+/**
+ * Get available configuration templates
+ * @param {string} templatesDir - Directory containing templates
+ * @returns {Array} - List of available templates with metadata
+ */
+function getAvailableTemplates(templatesDir) {
+    try {
+        const templates = [];
+        const files = fs.readdirSync(templatesDir);
+        
+        for (const file of files) {
+            if (file.endsWith('.json')) {
+                const templatePath = path.join(templatesDir, file);
+                try {
+                    const content = fs.readFileSync(templatePath, 'utf8');
+                    const data = parseJSONC(content);
+                    
+                    templates.push({
+                        id: path.basename(file, '.json'),
+                        name: file,
+                        path: templatePath,
+                        description: data['// Description'] || `${file} template`,
+                        features: Object.keys(data).filter(key => !key.startsWith('//')).length
+                    });
+                } catch (error) {
+                    // Skip invalid templates
+                    continue;
+                }
+            }
+        }
+        
+        return templates;
+    } catch (error) {
+        return [];
+    }
+}
+
+module.exports = {
+    getConfigPath: () => {
+        return path.join(os.homedir(), '.claude', 'commands');
+    },
+    
+    defaultConfig: {
+        commandsPath: './commands',
+        hooksEnabled: true,
+        colorOutput: true
+    },
+
+    // REQ-009 Implementation
+    applyConfigurationTemplate,
+    getAvailableTemplates,
+    
+    // Utility functions (exposed for testing)
+    parseJSONC,
+    deepMerge
+};

package/lib/context-utils.js

@@ -0,0 +1,80 @@
+/**
+ * Context Utilities
+ * 
+ * Shared context creation patterns to eliminate duplication and provide
+ * consistent context objects across the application.
+ * 
+ * Features:
+ * - Standardized context object creation
+ * - Context validation and enhancement
+ * - Operation context tracking
+ * - Context-aware processing patterns
+ */
+
+class ContextUtils {
+    constructor() {
+        this.config = {
+            contextTypes: {
+                VALIDATION: 'validation',
+                OPERATION: 'operation',
+                ERROR_HANDLING: 'error_handling',
+                INSTALLATION: 'installation',
+                SYSTEM: 'system'
+            },
+            operationTypes: {
+                COMMAND_INSTALLATION: 'command_installation',
+                DEPENDENCY_CHECK: 'dependency_check',
+                PERMISSION_CHECK: 'permission_check',
+                SYSTEM_VALIDATION: 'system_validation',
+                CONFIGURATION: 'configuration'
+            }
+        };
+    }
+    
+    /**
+     * Create base context object with common properties
+     * @param {string} type - Context type
+     * @param {Object} data - Context data
+     * @param {Object} options - Additional options
+     * @returns {Object} Base context object
+     */
+    createBaseContext(type, data = {}, options = {}) {
+        return {
+            type,
+            timestamp: new Date().toISOString(),
+            id: this._generateContextId(),
+            data,
+            metadata: {
+                version: '1.0.0',
+                source: 'context-utils',
+                ...options.metadata
+            },
+            ...options
+        };
+    }
+    
+    /**
+     * Create operation context for tracking operations
+     * @param {string} operation - Operation name
+     * @param {Object} parameters - Operation parameters
+     * @param {Object} environment - Environment information
+     * @returns {Object} Operation context
+     */
+    createOperationContext(operation, parameters = {}, environment = {}) {
+        return this.createBaseContext(this.config.contextTypes.OPERATION, {
+            operation,
+            parameters,
+            environment: {
+                platform: process.platform,
+                nodeVersion: process.version,
+                workingDirectory: process.cwd(),
+                ...environment
+            },
+            status: 'initialized',
+            startTime: new Date().toISOString(),
+            progress: {
+                current: 0,
+                total: 1,
+                steps: []
+            }
+        });\n    }\n    \n    /**\n     * Create validation context for input validation\n     * @param {*} input - Input to validate\n     * @param {Object} rules - Validation rules\n     * @param {Object} options - Validation options\n     * @returns {Object} Validation context\n     */\n    createValidationContext(input, rules = {}, options = {}) {\n        return this.createBaseContext(this.config.contextTypes.VALIDATION, {\n            input,\n            rules,\n            options: {\n                strict: false,\n                allowEmpty: false,\n                transformInput: false,\n                ...options\n            },\n            results: {\n                valid: null,\n                errors: [],\n                warnings: [],\n                transformed: null\n            }\n        });\n    }\n    \n    /**\n     * Create error handling context\n     * @param {Error} error - Error to handle\n     * @param {Object} operation - Operation context where error occurred\n     * @param {Object} recovery - Recovery options\n     * @returns {Object} Error handling context\n     */\n    createErrorHandlingContext(error, operation = {}, recovery = {}) {\n        return this.createBaseContext(this.config.contextTypes.ERROR_HANDLING, {\n            error: {\n                original: error,\n                code: error?.code,\n                message: error?.message,\n                type: error?.constructor?.name,\n                stack: error?.stack\n            },\n            operation,\n            recovery: {\n                attempted: false,\n                strategies: [],\n                successful: false,\n                ...recovery\n            },\n            handling: {\n                strategy: null,\n                handled: false,\n                escalated: false\n            }\n        });\n    }\n    \n    /**\n     * Create installation context for tracking installations\n     * @param {string} target - Installation target (command, dependency, etc.)\n     * @param {Object} configuration - Installation configuration\n     * @param {Object} environment - Environment details\n     * @returns {Object} Installation context\n     */\n    createInstallationContext(target, configuration = {}, environment = {}) {\n        return this.createBaseContext(this.config.contextTypes.INSTALLATION, {\n            target,\n            configuration,\n            environment: {\n                platform: process.platform,\n                arch: process.arch,\n                userHome: require('os').homedir(),\n                ...environment\n            },\n            installation: {\n                phase: 'preparation',\n                steps: [],\n                backup: null,\n                rollback: null\n            },\n            validation: {\n                preInstall: null,\n                postInstall: null\n            }\n        });\n    }\n    \n    /**\n     * Create system context for system operations\n     * @param {Object} systemInfo - System information\n     * @param {Object} requirements - System requirements\n     * @returns {Object} System context\n     */\n    createSystemContext(systemInfo = {}, requirements = {}) {\n        const os = require('os');\n        \n        return this.createBaseContext(this.config.contextTypes.SYSTEM, {\n            system: {\n                platform: process.platform,\n                arch: process.arch,\n                nodeVersion: process.version,\n                totalMemory: os.totalmem(),\n                freeMemory: os.freemem(),\n                homeDir: os.homedir(),\n                tempDir: os.tmpdir(),\n                ...systemInfo\n            },\n            requirements,\n            compatibility: {\n                checked: false,\n                compatible: null,\n                issues: []\n            }\n        });\n    }\n    \n    /**\n     * Enhance existing context with additional data\n     * @param {Object} context - Existing context to enhance\n     * @param {Object} enhancement - Enhancement data\n     * @returns {Object} Enhanced context\n     */\n    enhanceContext(context, enhancement) {\n        if (!context || typeof context !== 'object') {\n            throw new Error('Context must be a valid object');\n        }\n        \n        return {\n            ...context,\n            ...enhancement,\n            metadata: {\n                ...context.metadata,\n                ...enhancement.metadata,\n                enhanced: true,\n                enhancedAt: new Date().toISOString()\n            }\n        };\n    }\n    \n    /**\n     * Update operation context progress\n     * @param {Object} context - Operation context to update\n     * @param {number} current - Current step\n     * @param {number} total - Total steps (optional)\n     * @param {string} step - Current step description\n     * @returns {Object} Updated context\n     */\n    updateOperationProgress(context, current, total = null, step = null) {\n        if (!this.isOperationContext(context)) {\n            throw new Error('Context must be an operation context');\n        }\n        \n        const updatedContext = { ...context };\n        updatedContext.data.progress.current = current;\n        \n        if (total !== null) {\n            updatedContext.data.progress.total = total;\n        }\n        \n        if (step !== null) {\n            updatedContext.data.progress.steps.push({\n                step,\n                timestamp: new Date().toISOString(),\n                index: current\n            });\n        }\n        \n        // Update status based on progress\n        if (current >= updatedContext.data.progress.total) {\n            updatedContext.data.status = 'completed';\n            updatedContext.data.endTime = new Date().toISOString();\n        } else {\n            updatedContext.data.status = 'in_progress';\n        }\n        \n        return updatedContext;\n    }\n    \n    /**\n     * Mark operation context as failed\n     * @param {Object} context - Operation context to mark as failed\n     * @param {Error} error - Error that caused failure\n     * @returns {Object} Updated context\n     */\n    markOperationFailed(context, error) {\n        if (!this.isOperationContext(context)) {\n            throw new Error('Context must be an operation context');\n        }\n        \n        return {\n            ...context,\n            data: {\n                ...context.data,\n                status: 'failed',\n                endTime: new Date().toISOString(),\n                error: {\n                    code: error?.code,\n                    message: error?.message,\n                    type: error?.constructor?.name\n                }\n            }\n        };\n    }\n    \n    /**\n     * Check if context is of specific type\n     * @param {Object} context - Context to check\n     * @param {string} type - Expected type\n     * @returns {boolean} True if context is of expected type\n     */\n    isContextType(context, type) {\n        return context && context.type === type;\n    }\n    \n    /**\n     * Check if context is an operation context\n     * @param {Object} context - Context to check\n     * @returns {boolean} True if operation context\n     */\n    isOperationContext(context) {\n        return this.isContextType(context, this.config.contextTypes.OPERATION);\n    }\n    \n    /**\n     * Check if context is a validation context\n     * @param {Object} context - Context to check\n     * @returns {boolean} True if validation context\n     */\n    isValidationContext(context) {\n        return this.isContextType(context, this.config.contextTypes.VALIDATION);\n    }\n    \n    /**\n     * Extract summary information from context\n     * @param {Object} context - Context to summarize\n     * @returns {Object} Context summary\n     */\n    getContextSummary(context) {\n        if (!context || typeof context !== 'object') {\n            return { valid: false, error: 'Invalid context' };\n        }\n        \n        const summary = {\n            type: context.type,\n            id: context.id,\n            timestamp: context.timestamp,\n            valid: true\n        };\n        \n        // Add type-specific summary information\n        if (this.isOperationContext(context)) {\n            summary.operation = {\n                name: context.data?.operation,\n                status: context.data?.status,\n                progress: `${context.data?.progress?.current || 0}/${context.data?.progress?.total || 1}`\n            };\n        } else if (this.isValidationContext(context)) {\n            summary.validation = {\n                valid: context.data?.results?.valid,\n                errors: context.data?.results?.errors?.length || 0,\n                warnings: context.data?.results?.warnings?.length || 0\n            };\n        }\n        \n        return summary;\n    }\n    \n    /**\n     * Generate unique context ID\n     * @returns {string} Unique context ID\n     * @private\n     */\n    _generateContextId() {\n        return `ctx_${Date.now()}_${Math.random().toString(36).substring(2, 9)}`;\n    }\n}\n\nmodule.exports = ContextUtils;