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

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;

package/lib/services/package-manager-service.js

@@ -0,0 +1,319 @@
+/**
+ * Package Manager Service
+ * Handles package manager detection, validation, and instruction generation
+ */
+
+const { execSync } = require('child_process');
+const { PACKAGE_MANAGERS } = require('../config/constants');
+
+class PackageManagerService {
+    constructor() {
+        this.packageManagers = PACKAGE_MANAGERS;
+        this.detectedManagers = null;
+    }
+
+    /**
+     * Detect available package managers on the system
+     * @returns {Array} Available package managers
+     */
+    detectAvailablePackageManagers() {
+        if (this.detectedManagers) {
+            return this.detectedManagers;
+        }
+
+        const available = [];
+        
+        Object.keys(this.packageManagers).forEach(manager => {
+            if (this.isPackageManagerAvailable(manager)) {
+                const managerInfo = this.packageManagers[manager];
+                available.push({
+                    name: manager,
+                    displayName: managerInfo.name,
+                    version: this.getPackageManagerVersion(manager),
+                    installCommand: managerInfo.install,
+                    globalInstallCommand: managerInfo.globalInstall,
+                    updateCommand: managerInfo.update
+                });
+            }
+        });
+
+        this.detectedManagers = available;
+        return available;
+    }
+
+    /**
+     * Check if a package manager is available on the system
+     * @param {string} manager - Package manager name
+     * @returns {boolean} Is available
+     */
+    isPackageManagerAvailable(manager) {
+        const managerInfo = this.packageManagers[manager];
+        if (!managerInfo || !managerInfo.checkCommand) {
+            return false;
+        }
+
+        // Check platform compatibility
+        if (managerInfo.platforms && !managerInfo.platforms.includes(process.platform)) {
+            return false;
+        }
+
+        try {
+            execSync(managerInfo.checkCommand, { 
+                stdio: 'pipe', 
+                timeout: 5000,
+                encoding: 'utf8'
+            });
+            return true;
+        } catch (error) {
+            return false;
+        }
+    }
+
+    /**
+     * Get version of a package manager
+     * @param {string} manager - Package manager name
+     * @returns {string|null} Version string or null if not available
+     */
+    getPackageManagerVersion(manager) {
+        const managerInfo = this.packageManagers[manager];
+        if (!managerInfo || !managerInfo.checkCommand) {
+            return null;
+        }
+
+        try {
+            const output = execSync(managerInfo.checkCommand, { 
+                stdio: 'pipe', 
+                timeout: 5000,
+                encoding: 'utf8'
+            });
+            return output.trim();
+        } catch (error) {
+            return null;
+        }
+    }
+
+    /**
+     * Get recommended package manager for platform
+     * @param {string} platform - Target platform
+     * @returns {string} Recommended package manager name
+     */
+    getRecommendedPackageManager(platform = process.platform) {
+        const platformRecommendations = {
+            linux: 'apt',
+            darwin: 'brew',
+            win32: 'npm'
+        };
+
+        const recommended = platformRecommendations[platform] || 'npm';
+        
+        // Check if recommended manager is available
+        if (this.isPackageManagerAvailable(recommended)) {
+            return recommended;
+        }
+
+        // Fall back to any available manager
+        const available = this.detectAvailablePackageManagers();
+        return available.length > 0 ? available[0].name : 'npm';
+    }
+
+    /**
+     * Generate installation instructions for multiple package managers
+     * @param {string} packageName - Package to install
+     * @param {Object} options - Installation options
+     * @returns {Array} Installation instructions for different package managers
+     */
+    generateInstallationInstructions(packageName, options = {}) {
+        const instructions = [];
+        const availableManagers = this.detectAvailablePackageManagers();
+        
+        if (availableManagers.length === 0) {
+            return [{
+                manager: 'none',
+                error: 'No package managers detected on this system',
+                installUrl: this.packageManagers.npm.installUrl
+            }];
+        }
+
+        availableManagers.forEach(manager => {
+            const instruction = this._generateManagerInstruction(manager, packageName, options);
+            if (instruction) {
+                instructions.push(instruction);
+            }
+        });
+
+        // Sort by recommendation (recommended first)
+        const recommended = this.getRecommendedPackageManager();
+        instructions.sort((a, b) => {
+            if (a.manager === recommended) return -1;
+            if (b.manager === recommended) return 1;
+            return 0;
+        });
+
+        return instructions;
+    }
+
+    /**
+     * Generate instruction for specific package manager
+     * @param {Object} manager - Manager information
+     * @param {string} packageName - Package to install
+     * @param {Object} options - Installation options
+     * @returns {Object} Installation instruction
+     * @private
+     */
+    _generateManagerInstruction(manager, packageName, options) {
+        const command = options.global ? 
+            manager.globalInstallCommand || manager.installCommand : 
+            manager.installCommand;
+
+        const version = options.version ? `@${options.version}` : '';
+        const fullPackageName = `${packageName}${version}`;
+        
+        return {
+            manager: manager.name,
+            displayName: manager.displayName,
+            command: `${command} ${fullPackageName}`,
+            version: manager.version,
+            global: options.global || false,
+            recommended: manager.name === this.getRecommendedPackageManager(),
+            notes: this._getManagerSpecificNotes(manager.name, options)
+        };
+    }
+
+    /**
+     * Get manager-specific installation notes
+     * @param {string} managerName - Package manager name
+     * @param {Object} options - Installation options
+     * @returns {Array} Installation notes
+     * @private
+     */
+    _getManagerSpecificNotes(managerName, options) {
+        const notes = [];
+        
+        switch (managerName) {
+            case 'npm':
+                if (options.global) {
+                    notes.push('Global installation may require administrator privileges');
+                }
+                notes.push('Use "npm list" to verify installation');
+                break;
+                
+            case 'yarn':
+                if (options.global) {
+                    notes.push('Yarn global installation location may not be in PATH');
+                }
+                notes.push('Yarn provides faster and more reliable dependency resolution');
+                break;
+                
+            case 'pnpm':
+                notes.push('pnpm saves disk space by using a content-addressable store');
+                if (options.global) {
+                    notes.push('pnpm global packages are stored in a separate location');
+                }
+                break;
+                
+            case 'brew':
+                notes.push('Homebrew automatically handles dependencies');
+                notes.push('Update Homebrew regularly: brew update && brew upgrade');
+                break;
+                
+            case 'apt':
+                notes.push('May require "sudo" for system-wide installation');
+                notes.push('Update package lists first: sudo apt update');
+                break;
+                
+            case 'chocolatey':
+                notes.push('Run PowerShell as Administrator');
+                notes.push('Chocolatey packages are community maintained');
+                break;
+                
+            case 'winget':
+                notes.push('winget is the official Windows package manager');
+                notes.push('Available on Windows 10 1709+ and Windows 11');
+                break;
+        }
+        
+        return notes;
+    }
+
+    /**
+     * Validate package manager installation
+     * @param {string} manager - Package manager name
+     * @returns {Object} Validation result
+     */
+    validatePackageManager(manager) {
+        const managerInfo = this.packageManagers[manager];
+        
+        if (!managerInfo) {
+            return {
+                valid: false,
+                error: `Unknown package manager: ${manager}`,
+                suggestions: ['Use npm, yarn, or pnpm for Node.js packages']
+            };
+        }
+
+        // Check platform compatibility
+        if (managerInfo.platforms && !managerInfo.platforms.includes(process.platform)) {
+            return {
+                valid: false,
+                error: `${managerInfo.name} is not available on ${process.platform}`,
+                suggestions: [
+                    `Try ${this.getRecommendedPackageManager()} instead`,
+                    `Install ${managerInfo.name} from ${managerInfo.installUrl || 'official website'}`
+                ]
+            };
+        }
+
+        // Check if manager is available
+        if (!this.isPackageManagerAvailable(manager)) {
+            return {
+                valid: false,
+                error: `${managerInfo.name} is not installed or not in PATH`,
+                installUrl: managerInfo.installUrl,
+                suggestions: [
+                    `Install ${managerInfo.name} from ${managerInfo.installUrl || 'official website'}`,
+                    `Add ${managerInfo.name} to your system PATH`,
+                    `Use alternative package manager: ${this.getRecommendedPackageManager()}`
+                ]
+            };
+        }
+
+        return {
+            valid: true,
+            manager: managerInfo.name,
+            version: this.getPackageManagerVersion(manager),
+            commands: {
+                install: managerInfo.install,
+                globalInstall: managerInfo.globalInstall,
+                update: managerInfo.update
+            }
+        };
+    }
+
+    /**
+     * Get installation command for specific package and manager
+     * @param {string} manager - Package manager name
+     * @param {string} packageName - Package to install
+     * @param {Object} options - Installation options
+     * @returns {string|null} Installation command
+     */
+    getInstallCommand(manager, packageName, options = {}) {
+        const managerInfo = this.packageManagers[manager];
+        if (!managerInfo) return null;
+
+        const baseCommand = options.global ? 
+            managerInfo.globalInstall || managerInfo.install : 
+            managerInfo.install;
+
+        const version = options.version ? `@${options.version}` : '';
+        return `${baseCommand} ${packageName}${version}`;
+    }
+
+    /**
+     * Clear detected managers cache
+     */
+    clearCache() {
+        this.detectedManagers = null;
+    }
+}
+
+module.exports = PackageManagerService;