@paulduvall/claude-dev-toolkit 0.0.1-alpha.7 → 0.0.1-alpha.8

package/lib/services/command-installer-service.js

@@ -0,0 +1,217 @@
+/**
+ * Command Installer Service
+ * Focused service for installing commands from the NPM package
+ */
+
+const fs = require('fs');
+const path = require('path');
+const FileSystemUtils = require('../utils/file-system-utils');
+const ClaudePathConfig = require('../utils/claude-path-config');
+
+class CommandInstallerService {
+    constructor(config = null) {
+        this.config = config || new ClaudePathConfig();
+        this.installedCount = 0;
+        this.skippedCount = 0;
+    }
+
+    /**
+     * Install commands based on options
+     */
+    async install(options = {}) {
+        // Reset counters
+        this.installedCount = 0;
+        this.skippedCount = 0;
+
+        // Ensure commands directory exists
+        FileSystemUtils.ensureDirectory(this.config.commandsDir);
+
+        // Get commands to install
+        const commandsToInstall = this.getCommandsToInstall(options);
+
+        // Install commands
+        const installResults = {
+            active: 0,
+            experimental: 0
+        };
+
+        for (const cmd of commandsToInstall) {
+            const sourcePath = path.join(cmd.source, cmd.file);
+            const destPath = path.join(this.config.commandsDir, cmd.file);
+            
+            if (FileSystemUtils.copyFile(sourcePath, destPath, 0o644)) {
+                this.installedCount++;
+                installResults[cmd.type]++;
+            } else {
+                console.error(`⚠️  Failed to install ${cmd.file}`);
+                this.skippedCount++;
+            }
+        }
+
+        return {
+            installedCount: this.installedCount,
+            skippedCount: this.skippedCount,
+            results: installResults,
+            commands: commandsToInstall
+        };
+    }
+
+    /**
+     * Get list of commands to install based on options
+     */
+    getCommandsToInstall(options) {
+        const commands = [];
+        
+        // Determine which command sets to install
+        const installActive = options.active || options.all || 
+                            (!options.active && !options.experiments && !options.all);
+        const installExperiments = options.experiments || options.all;
+
+        // Collect active commands
+        if (installActive) {
+            const activeCommands = this.getCommandsFromDirectory(
+                this.config.packageActiveCommandsDir, 
+                'active'
+            );
+            commands.push(...activeCommands);
+        }
+
+        // Collect experimental commands
+        if (installExperiments) {
+            const experimentalCommands = this.getCommandsFromDirectory(
+                this.config.packageExperimentalCommandsDir, 
+                'experimental'
+            );
+            commands.push(...experimentalCommands);
+        }
+
+        // Apply include/exclude filters
+        return this.applyFilters(commands, options);
+    }
+
+    /**
+     * Get commands from a specific directory
+     */
+    getCommandsFromDirectory(dirPath, type) {
+        if (!fs.existsSync(dirPath)) {
+            return [];
+        }
+
+        try {
+            return fs.readdirSync(dirPath)
+                .filter(f => f.endsWith('.md'))
+                .map(f => ({ 
+                    file: f, 
+                    source: dirPath, 
+                    type: type 
+                }));
+        } catch (error) {
+            console.warn(`⚠️ Warning: Could not read ${type} commands directory - ${error.message}`);
+            return [];
+        }
+    }
+
+    /**
+     * Apply include/exclude filters to command list
+     */
+    applyFilters(commands, options) {
+        let filteredCommands = commands;
+        
+        // Apply include filter
+        if (options.include) {
+            const patterns = Array.isArray(options.include) ? options.include : [options.include];
+            filteredCommands = filteredCommands.filter(cmd => 
+                patterns.some(pattern => this.matchesPattern(cmd.file, pattern))
+            );
+        }
+
+        // Apply exclude filter
+        if (options.exclude) {
+            const patterns = Array.isArray(options.exclude) ? options.exclude : [options.exclude];
+            filteredCommands = filteredCommands.filter(cmd => 
+                !patterns.some(pattern => this.matchesPattern(cmd.file, pattern))
+            );
+        }
+
+        return filteredCommands;
+    }
+
+    /**
+     * Check if a command matches a pattern
+     */
+    matchesPattern(filename, pattern) {
+        // Simple pattern matching with wildcard support
+        if (pattern.includes('*')) {
+            const regex = new RegExp(pattern.replace(/\*/g, '.*'));
+            return regex.test(filename);
+        }
+        return filename.includes(pattern);
+    }
+
+    /**
+     * Get preview of what would be installed (dry run)
+     */
+    getDryRunPreview(options) {
+        const commandsToInstall = this.getCommandsToInstall(options);
+        
+        const byType = {
+            active: commandsToInstall.filter(c => c.type === 'active'),
+            experimental: commandsToInstall.filter(c => c.type === 'experimental')
+        };
+
+        return {
+            total: commandsToInstall.length,
+            byType,
+            destination: this.config.commandsDir
+        };
+    }
+
+    /**
+     * Validate installation requirements
+     */
+    validateInstallation() {
+        const issues = [];
+        
+        // Check if package directories exist
+        if (!fs.existsSync(this.config.packageActiveCommandsDir)) {
+            issues.push('Active commands directory not found in package');
+        }
+        
+        if (!fs.existsSync(this.config.packageExperimentalCommandsDir)) {
+            issues.push('Experimental commands directory not found in package');
+        }
+
+        // Check if destination parent directory exists and is writable
+        const claudeDir = this.config.claudeDir;
+        try {
+            // Try to ensure the directory exists first
+            FileSystemUtils.ensureDirectory(claudeDir);
+            
+            // Then check if it's writable
+            if (fs.existsSync(claudeDir) && !FileSystemUtils.isWritable(claudeDir)) {
+                issues.push('Cannot write to Claude directory - check permissions');
+            }
+        } catch (error) {
+            // If we can't create the directory, that's a permission issue
+            issues.push(`Cannot create Claude directory: ${error.message}`);
+        }
+
+        return {
+            valid: issues.length === 0,
+            issues
+        };
+    }
+
+    /**
+     * Get installation statistics
+     */
+    getStats() {
+        return {
+            installed: this.installedCount,
+            skipped: this.skippedCount,
+            total: this.installedCount + this.skippedCount
+        };
+    }
+}
+
+module.exports = CommandInstallerService;

package/lib/services/logger-service.js

@@ -0,0 +1,201 @@
+/**
+ * Centralized Logger Service
+ * Provides consistent logging across the entire application with context support
+ */
+
+class LoggerService {
+    constructor(options = {}) {
+        this.options = {
+            timestamp: options.timestamp ?? true,
+            context: options.context ?? true,
+            colors: options.colors ?? true,
+            level: options.level ?? 'info' // debug, info, warn, error
+        };
+        this.contextData = {};
+    }
+
+    /**
+     * Set persistent context data for all log messages
+     */
+    setContext(context) {
+        this.contextData = { ...this.contextData, ...context };
+    }
+
+    /**
+     * Clear all context data
+     */
+    clearContext() {
+        this.contextData = {};
+    }
+
+    /**
+     * Success message logging
+     */
+    success(message, context = {}) {
+        this._log('success', '✅', message, context);
+    }
+
+    /**
+     * Information message logging
+     */
+    info(message, context = {}) {
+        this._log('info', 'ℹ️', message, context);
+    }
+
+    /**
+     * Warning message logging
+     */
+    warn(message, context = {}) {
+        this._log('warn', '⚠️', message, context);
+    }
+
+    /**
+     * Error message logging
+     */
+    error(message, error = null, context = {}) {
+        const errorContext = error ? { error: this._serializeError(error), ...context } : context;
+        this._log('error', '❌', message, errorContext);
+    }
+
+    /**
+     * Debug message logging
+     */
+    debug(message, context = {}) {
+        if (this.options.level === 'debug') {
+            this._log('debug', '🔍', message, context);
+        }
+    }
+
+    /**
+     * Step progress logging
+     */
+    step(message, context = {}) {
+        this._log('step', '🔄', message, context);
+    }
+
+    /**
+     * Completion logging
+     */
+    complete(message, context = {}) {
+        this._log('complete', '🎉', message, context);
+    }
+
+    /**
+     * Progress logging with metrics
+     */
+    progress(message, current, total, context = {}) {
+        const progressContext = { current, total, percentage: Math.round((current / total) * 100), ...context };
+        this._log('progress', '📊', message, progressContext);
+    }
+
+    /**
+     * Internal logging method
+     */
+    _log(level, icon, message, context = {}) {
+        const timestamp = this.options.timestamp ? `[${new Date().toISOString()}]` : '';
+        const fullContext = { ...this.contextData, ...context };
+        
+        let logMessage = `${timestamp} ${icon} ${message}`;
+        
+        // Add context if enabled and present
+        if (this.options.context && Object.keys(fullContext).length > 0) {
+            const contextStr = this._formatContext(fullContext);
+            if (contextStr) {
+                logMessage += ` ${contextStr}`;
+            }
+        }
+
+        // Route to appropriate console method
+        switch (level) {
+            case 'error':
+                console.error(logMessage);
+                break;
+            case 'warn':
+                console.warn(logMessage);
+                break;
+            case 'debug':
+                console.debug(logMessage);
+                break;
+            default:
+                console.log(logMessage);
+        }
+    }
+
+    /**
+     * Format context data for display
+     */
+    _formatContext(context) {
+        try {
+            // Filter out complex objects and functions
+            const filteredContext = {};
+            for (const [key, value] of Object.entries(context)) {
+                if (value !== null && value !== undefined) {
+                    if (typeof value === 'object' && !Array.isArray(value)) {
+                        // Include only simple object properties
+                        if (Object.keys(value).length < 5) {
+                            filteredContext[key] = value;
+                        } else {
+                            filteredContext[key] = `[Object with ${Object.keys(value).length} keys]`;
+                        }
+                    } else if (typeof value !== 'function') {
+                        filteredContext[key] = value;
+                    }
+                }
+            }
+
+            if (Object.keys(filteredContext).length === 0) {
+                return '';
+            }
+
+            return JSON.stringify(filteredContext);
+        } catch (error) {
+            return `[Context formatting error: ${error.message}]`;
+        }
+    }
+
+    /**
+     * Serialize error objects for logging
+     */
+    _serializeError(error) {
+        if (!error) return null;
+        
+        return {
+            name: error.name,
+            message: error.message,
+            code: error.code,
+            stack: error.stack?.split('\n').slice(0, 3).join('\n') // First 3 lines of stack
+        };
+    }
+
+    /**
+     * Create a scoped logger with persistent context
+     */
+    scope(scopeName, context = {}) {
+        const scopedLogger = new LoggerService(this.options);
+        scopedLogger.setContext({ scope: scopeName, ...this.contextData, ...context });
+        return scopedLogger;
+    }
+
+    /**
+     * Performance timing utilities
+     */
+    time(label) {
+        console.time(`⏱️  ${label}`);
+    }
+
+    timeEnd(label) {
+        console.timeEnd(`⏱️  ${label}`);
+    }
+
+    /**
+     * Table logging for structured data
+     */
+    table(data, message = '') {
+        if (message) {
+            this.info(message);
+        }
+        console.table(data);
+    }
+}
+
+module.exports = LoggerService;