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

package/lib/services/backup-list-service.js

@@ -0,0 +1,226 @@
+/**
+ * Backup List Service
+ * Service for listing and managing backup inventory
+ */
+
+const path = require('path');
+const fs = require('fs');
+const FileSystemUtils = require('../utils/file-system-utils');
+const ClaudePathConfig = require('../utils/claude-path-config');
+
+class BackupListService {
+    constructor(config = null) {
+        this.config = config || new ClaudePathConfig();
+    }
+
+    /**
+     * List all available backups
+     */
+    async list() {
+        if (!fs.existsSync(this.config.backupsDir)) {
+            return [];
+        }
+
+        const backups = [];
+        
+        try {
+            const entries = fs.readdirSync(this.config.backupsDir);
+            
+            for (const entry of entries) {
+                const fullPath = path.join(this.config.backupsDir, entry);
+                const stats = FileSystemUtils.getStats(fullPath);
+                
+                if (!stats) continue;
+
+                // Compressed backups
+                if (entry.endsWith('.tar.gz')) {
+                    const name = entry.replace('.tar.gz', '');
+                    backups.push({
+                        name,
+                        type: 'compressed',
+                        size: stats.size,
+                        modified: stats.mtime,
+                        path: fullPath
+                    });
+                }
+                // Directory backups
+                else if (stats.isDirectory() && !entry.startsWith('.')) {
+                    const metadata = await this.readBackupMetadata(fullPath);
+                    
+                    backups.push({
+                        name: entry,
+                        type: 'directory',
+                        size: FileSystemUtils.getDirectorySize(fullPath),
+                        modified: stats.mtime,
+                        path: fullPath,
+                        metadata
+                    });
+                }
+            }
+
+            // Sort by modification time (newest first)
+            backups.sort((a, b) => b.modified - a.modified);
+
+            return backups;
+        } catch (error) {
+            throw new Error(`Failed to list backups: ${error.message}`);
+        }
+    }
+
+    /**
+     * Display backups in user-friendly format
+     */
+    async display() {
+        console.log('📦 Available Backups:\n');
+
+        const backups = await this.list();
+
+        if (backups.length === 0) {
+            console.log('No backups found');
+            return [];
+        }
+
+        backups.forEach(backup => {
+            const date = backup.modified.toLocaleString();
+            const size = FileSystemUtils.formatSize(backup.size);
+            const type = backup.type === 'compressed' ? '📦' : '📁';
+            
+            console.log(`${type} ${backup.name}`);
+            console.log(`   Date: ${date}`);
+            console.log(`   Size: ${size}`);
+            
+            if (backup.metadata) {
+                console.log(`   Files: ${backup.metadata.totalFiles}`);
+                if (backup.metadata.components) {
+                    const components = Object.keys(backup.metadata.components).filter(k => backup.metadata.components[k]);
+                    if (components.length > 0) {
+                        console.log(`   Contains: ${components.join(', ')}`);
+                    }
+                }
+            }
+            console.log('');
+        });
+
+        console.log(`Total: ${backups.length} backup(s)`);
+        console.log('\n💡 To restore a backup, run:');
+        console.log('   claude-commands restore <backup-name>');
+
+        return backups;
+    }
+
+    /**
+     * Find a specific backup by name
+     */
+    async findBackup(name) {
+        const backups = await this.list();
+        return backups.find(backup => backup.name === name);
+    }
+
+    /**
+     * Get backup details
+     */
+    async getBackupDetails(name) {
+        const backup = await this.findBackup(name);
+        
+        if (!backup) {
+            throw new Error(`Backup '${name}' not found`);
+        }
+
+        const details = {
+            ...backup,
+            exists: fs.existsSync(backup.path),
+            readable: FileSystemUtils.isReadable(backup.path)
+        };
+
+        // Add component details if metadata available
+        if (backup.metadata && backup.metadata.components) {
+            details.components = backup.metadata.components;
+        }
+
+        return details;
+    }
+
+    /**
+     * Read backup metadata if available
+     */
+    async readBackupMetadata(backupPath) {
+        const metadataPath = path.join(backupPath, 'backup-metadata.json');
+        
+        if (!FileSystemUtils.isReadable(metadataPath)) {
+            return null;
+        }
+
+        try {
+            const content = FileSystemUtils.readFile(metadataPath);
+            return JSON.parse(content);
+        } catch (error) {
+            // Return null for invalid metadata
+            return null;
+        }
+    }
+
+    /**
+     * Clean up old backups (keep only N most recent)
+     */
+    async cleanup(keepCount = 10) {
+        const backups = await this.list();
+        
+        if (backups.length <= keepCount) {
+            return { cleaned: 0, kept: backups.length };
+        }
+
+        const toRemove = backups.slice(keepCount);
+        let cleanedCount = 0;
+
+        for (const backup of toRemove) {
+            try {
+                if (FileSystemUtils.remove(backup.path)) {
+                    cleanedCount++;
+                }
+            } catch (error) {
+                console.warn(`⚠️ Warning: Could not remove backup ${backup.name} - ${error.message}`);
+            }
+        }
+
+        return {
+            cleaned: cleanedCount,
+            kept: backups.length - cleanedCount
+        };
+    }
+
+    /**
+     * Get backup statistics
+     */
+    async getStats() {
+        const backups = await this.list();
+        
+        let totalSize = 0;
+        let oldestDate = null;
+        let newestDate = null;
+        const types = { compressed: 0, directory: 0 };
+
+        backups.forEach(backup => {
+            totalSize += backup.size;
+            types[backup.type]++;
+            
+            if (!oldestDate || backup.modified < oldestDate) {
+                oldestDate = backup.modified;
+            }
+            if (!newestDate || backup.modified > newestDate) {
+                newestDate = backup.modified;
+            }
+        });
+
+        return {
+            count: backups.length,
+            totalSize,
+            formattedSize: FileSystemUtils.formatSize(totalSize),
+            types,
+            oldestDate,
+            newestDate,
+            averageSize: backups.length > 0 ? totalSize / backups.length : 0
+        };
+    }
+}
+
+module.exports = BackupListService;

package/lib/services/backup-service.js

@@ -0,0 +1,230 @@
+/**
+ * Backup Service
+ * Focused service for creating backups of Claude Code configuration
+ */
+
+const path = require('path');
+const fs = require('fs');
+const FileSystemUtils = require('../utils/file-system-utils');
+const ClaudePathConfig = require('../utils/claude-path-config');
+
+class BackupService {
+    constructor(config = null) {
+        this.config = config || new ClaudePathConfig();
+        this.backedUpCount = 0;
+    }
+
+    /**
+     * Create a complete backup
+     */
+    async create(name = null) {
+        const timestamp = new Date().toISOString().replace(/[:.]/g, '-').split('.')[0];
+        const backupName = name || `backup-${timestamp}`;
+        const backupPath = path.join(this.config.backupsDir, backupName);
+
+        // Ensure backup directory exists
+        FileSystemUtils.ensureDirectory(this.config.backupsDir);
+
+        // Check if backup already exists
+        if (fs.existsSync(backupPath)) {
+            throw new Error(`Backup '${backupName}' already exists`);
+        }
+
+        // Create backup directory
+        FileSystemUtils.ensureDirectory(backupPath);
+
+        // Reset counter
+        this.backedUpCount = 0;
+
+        // Backup components
+        const components = {};
+        let totalFiles = 0;
+        let totalSize = 0;
+
+        // Backup settings
+        if (FileSystemUtils.isReadable(this.config.settingsPath)) {
+            await this.backupSettings(backupPath);
+            components.settings = true;
+            totalFiles++;
+            const stats = FileSystemUtils.getStats(this.config.settingsPath);
+            if (stats) totalSize += stats.size;
+        }
+
+        // Backup commands
+        const commandsResult = await this.backupCommands(backupPath);
+        if (commandsResult.count > 0) {
+            components.commands = true;
+            totalFiles += commandsResult.count;
+            totalSize += commandsResult.size;
+        }
+
+        // Backup hooks
+        const hooksResult = await this.backupHooks(backupPath);
+        if (hooksResult.count > 0) {
+            components.hooks = true;
+            totalFiles += hooksResult.count;
+            totalSize += hooksResult.size;
+        }
+
+        // Create metadata
+        const metadata = this.createMetadata(backupName, components, totalFiles, totalSize);
+        await this.saveMetadata(backupPath, metadata);
+
+        return {
+            name: backupName,
+            path: backupPath,
+            components,
+            totalFiles,
+            totalSize,
+            metadata
+        };
+    }
+
+    /**
+     * Backup settings.json file
+     */
+    async backupSettings(backupPath) {
+        if (!FileSystemUtils.isReadable(this.config.settingsPath)) {
+            return false;
+        }
+
+        const destPath = path.join(backupPath, 'settings.json');
+        const success = FileSystemUtils.copyFile(this.config.settingsPath, destPath);
+        
+        if (success) {
+            this.backedUpCount++;
+            console.log('✅ Backed up settings.json');
+        }
+
+        return success;
+    }
+
+    /**
+     * Backup commands directory
+     */
+    async backupCommands(backupPath) {
+        if (!fs.existsSync(this.config.commandsDir)) {
+            return { count: 0, size: 0 };
+        }
+
+        const commandsBackupDir = path.join(backupPath, 'commands');
+        FileSystemUtils.ensureDirectory(commandsBackupDir);
+
+        let count = 0;
+        let size = 0;
+
+        try {
+            const files = fs.readdirSync(this.config.commandsDir);
+            
+            for (const file of files) {
+                if (file.endsWith('.md')) {
+                    const sourcePath = path.join(this.config.commandsDir, file);
+                    const destPath = path.join(commandsBackupDir, file);
+                    
+                    if (FileSystemUtils.copyFile(sourcePath, destPath)) {
+                        count++;
+                        const stats = FileSystemUtils.getStats(sourcePath);
+                        if (stats) size += stats.size;
+                        this.backedUpCount++;
+                    }
+                }
+            }
+
+            if (count > 0) {
+                console.log(`✅ Backed up ${count} commands`);
+            }
+        } catch (error) {
+            console.warn(`⚠️ Warning: Could not backup commands - ${error.message}`);
+        }
+
+        return { count, size };
+    }
+
+    /**
+     * Backup hooks directory
+     */
+    async backupHooks(backupPath) {
+        const hooksDir = this.config.hooksDir;
+        
+        if (!fs.existsSync(hooksDir)) {
+            return { count: 0, size: 0 };
+        }
+
+        const hooksBackupDir = path.join(backupPath, 'hooks');
+        FileSystemUtils.ensureDirectory(hooksBackupDir);
+
+        let count = 0;
+        let size = 0;
+
+        try {
+            const files = fs.readdirSync(hooksDir);
+            
+            for (const file of files) {
+                const sourcePath = path.join(hooksDir, file);
+                const stats = FileSystemUtils.getStats(sourcePath);
+                
+                if (stats && stats.isFile()) {
+                    const destPath = path.join(hooksBackupDir, file);
+                    
+                    if (FileSystemUtils.copyFile(sourcePath, destPath)) {
+                        count++;
+                        size += stats.size;
+                        this.backedUpCount++;
+                    }
+                }
+            }
+
+            if (count > 0) {
+                console.log(`✅ Backed up ${count} hooks`);
+            }
+        } catch (error) {
+            console.warn(`⚠️ Warning: Could not backup hooks - ${error.message}`);
+        }
+
+        return { count, size };
+    }
+
+    /**
+     * Create backup metadata
+     */
+    createMetadata(name, components, totalFiles, totalSize) {
+        return {
+            name,
+            timestamp: new Date().toISOString(),
+            components,
+            totalFiles,
+            totalSize,
+            claudeVersion: this.getClaudeVersion(),
+            system: {
+                platform: require('os').platform(),
+                arch: require('os').arch(),
+                nodeVersion: process.version
+            }
+        };
+    }
+
+    /**
+     * Save metadata to backup directory
+     */
+    async saveMetadata(backupPath, metadata) {
+        const metadataPath = path.join(backupPath, 'backup-metadata.json');
+        const content = JSON.stringify(metadata, null, 2);
+        
+        return FileSystemUtils.writeFile(metadataPath, content);
+    }
+
+    /**
+     * Get Claude Code version
+     */
+    getClaudeVersion() {
+        try {
+            const packagePath = path.join(__dirname, '..', '..', 'package.json');
+            const packageData = JSON.parse(FileSystemUtils.readFile(packagePath) || '{}');
+            return packageData.version || 'unknown';
+        } catch (error) {
+            return 'unknown';
+        }
+    }
+}
+
+module.exports = BackupService;

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;