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

package/lib/result.js

@@ -0,0 +1,138 @@
+/**
+ * Result/Either Pattern Implementation
+ * Provides functional error handling without throwing exceptions
+ */
+
+/**
+ * Success result containing a value
+ */
+class Ok {
+    constructor(value) {
+        this.value = value;
+        this.isOk = true;
+        this.isError = false;
+    }
+
+    map(fn) {
+        try {
+            return new Ok(fn(this.value));
+        } catch (error) {
+            return new Err(error);
+        }
+    }
+
+    flatMap(fn) {
+        try {
+            return fn(this.value);
+        } catch (error) {
+            return new Err(error);
+        }
+    }
+
+    mapError() {
+        return this;
+    }
+
+    unwrap() {
+        return this.value;
+    }
+
+    unwrapOr() {
+        return this.value;
+    }
+
+    match(okFn, errFn) {
+        return okFn(this.value);
+    }
+}
+
+/**
+ * Error result containing an error
+ */
+class Err {
+    constructor(error) {
+        this.error = error;
+        this.isOk = false;
+        this.isError = true;
+    }
+
+    map() {
+        return this;
+    }
+
+    flatMap() {
+        return this;
+    }
+
+    mapError(fn) {
+        try {
+            return new Err(fn(this.error));
+        } catch (error) {
+            return new Err(error);
+        }
+    }
+
+    unwrap() {
+        throw new Error(`Called unwrap on an Err: ${this.error}`);
+    }
+
+    unwrapOr(defaultValue) {
+        return defaultValue;
+    }
+
+    match(okFn, errFn) {
+        return errFn(this.error);
+    }
+}
+
+/**
+ * Static factory methods for creating Results
+ */
+class Result {
+    static ok(value) {
+        return new Ok(value);
+    }
+
+    static err(error) {
+        return new Err(error);
+    }
+
+    /**
+     * Wraps a function that might throw in a Result
+     */
+    static try(fn) {
+        try {
+            return Result.ok(fn());
+        } catch (error) {
+            return Result.err(error);
+        }
+    }
+
+    /**
+     * Wraps an async function that might throw in a Result
+     */
+    static async tryAsync(fn) {
+        try {
+            const result = await fn();
+            return Result.ok(result);
+        } catch (error) {
+            return Result.err(error);
+        }
+    }
+
+    /**
+     * Combines multiple Results - returns Ok if all are Ok, Err if any are Err
+     */
+    static all(results) {
+        const values = [];
+        for (const result of results) {
+            if (result.isError) {
+                return result;
+            }
+            values.push(result.value);
+        }
+        return Result.ok(values);
+    }
+}
+
+module.exports = { Result, Ok, Err };

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;