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

package/lib/utils/claude-path-config.js

@@ -0,0 +1,184 @@
+/**
+ * Claude Path Configuration
+ * Centralized path management for Claude Code directories
+ */
+
+const path = require('path');
+const os = require('os');
+
+class ClaudePathConfig {
+    constructor(homeDir = os.homedir()) {
+        this.homeDir = homeDir;
+    }
+
+    /**
+     * Main Claude directory
+     */
+    get claudeDir() {
+        return path.join(this.homeDir, '.claude');
+    }
+
+    /**
+     * Commands directory
+     */
+    get commandsDir() {
+        return path.join(this.claudeDir, 'commands');
+    }
+
+    /**
+     * Settings file path
+     */
+    get settingsPath() {
+        return path.join(this.claudeDir, 'settings.json');
+    }
+
+    /**
+     * Backups directory
+     */
+    get backupsDir() {
+        return path.join(this.claudeDir, 'backups');
+    }
+
+    /**
+     * Settings backups directory
+     */
+    get settingsBackupsDir() {
+        return path.join(this.backupsDir, 'settings');
+    }
+
+    /**
+     * Commands backups directory
+     */
+    get commandsBackupsDir() {
+        return path.join(this.backupsDir, 'commands');
+    }
+
+    /**
+     * Hooks directory
+     */
+    get hooksDir() {
+        return path.join(this.claudeDir, 'hooks');
+    }
+
+    /**
+     * Subagents directory
+     */
+    get subagentsDir() {
+        return path.join(this.claudeDir, 'subagents');
+    }
+
+    /**
+     * Templates directory (in package)
+     */
+    get templatesDir() {
+        return path.join(__dirname, '..', '..', 'templates');
+    }
+
+    /**
+     * Package commands directory (active)
+     */
+    get packageActiveCommandsDir() {
+        return path.join(__dirname, '..', '..', 'commands', 'active');
+    }
+
+    /**
+     * Package commands directory (experiments)
+     */
+    get packageExperimentalCommandsDir() {
+        return path.join(__dirname, '..', '..', 'commands', 'experiments');
+    }
+
+    /**
+     * Package hooks directory
+     */
+    get packageHooksDir() {
+        return path.join(__dirname, '..', '..', 'hooks');
+    }
+
+    /**
+     * Package subagents directory
+     */
+    get packageSubagentsDir() {
+        return path.join(__dirname, '..', '..', 'subagents');
+    }
+
+    /**
+     * Get all user directories that might need creation
+     */
+    getUserDirectories() {
+        return [
+            this.claudeDir,
+            this.commandsDir,
+            this.backupsDir,
+            this.settingsBackupsDir,
+            this.commandsBackupsDir,
+            this.hooksDir,
+            this.subagentsDir
+        ];
+    }
+
+    /**
+     * Get all package directories for validation
+     */
+    getPackageDirectories() {
+        return [
+            this.templatesDir,
+            this.packageActiveCommandsDir,
+            this.packageExperimentalCommandsDir,
+            this.packageHooksDir,
+            this.packageSubagentsDir
+        ];
+    }
+
+    /**
+     * Create a backup path with timestamp
+     */
+    createBackupPath(name, type = 'general') {
+        const timestamp = new Date().toISOString().replace(/[:.]/g, '-').split('.')[0];
+        const backupName = name || `backup-${timestamp}`;
+        
+        switch (type) {
+            case 'settings':
+                return path.join(this.settingsBackupsDir, `${backupName}.json`);
+            case 'commands':
+                return path.join(this.commandsBackupsDir, backupName);
+            default:
+                return path.join(this.backupsDir, backupName);
+        }
+    }
+
+    /**
+     * Resolve template path from name
+     */
+    resolveTemplatePath(templateName) {
+        const variations = [
+            templateName,
+            `${templateName}.json`,
+            `${templateName}-settings.json`
+        ];
+
+        // Common aliases
+        const aliases = {
+            'basic': 'basic-settings.json',
+            'comprehensive': 'comprehensive-settings.json',
+            'security': 'security-focused-settings.json',
+            'security-focused': 'security-focused-settings.json'
+        };
+
+        if (aliases[templateName]) {
+            variations.unshift(aliases[templateName]);
+        }
+
+        for (const variant of variations) {
+            const fullPath = path.join(this.templatesDir, variant);
+            const fs = require('fs');
+            if (fs.existsSync(fullPath)) {
+                return fullPath;
+            }
+        }
+
+        return null;
+    }
+}
+
+module.exports = ClaudePathConfig;

package/lib/utils/file-system-utils.js

@@ -0,0 +1,152 @@
+/**
+ * File System Utilities
+ * Extracted common file system operations used across commands
+ */
+
+const fs = require('fs');
+const path = require('path');
+const os = require('os');
+
+class FileSystemUtils {
+    /**
+     * Format file size for human-readable display
+     */
+    static formatSize(bytes) {
+        const units = ['B', 'KB', 'MB', 'GB'];
+        let size = bytes;
+        let unitIndex = 0;
+        
+        while (size >= 1024 && unitIndex < units.length - 1) {
+            size /= 1024;
+            unitIndex++;
+        }
+        
+        return `${size.toFixed(2)} ${units[unitIndex]}`;
+    }
+
+    /**
+     * Calculate directory size recursively
+     */
+    static getDirectorySize(dirPath) {
+        let size = 0;
+        
+        try {
+            const entries = fs.readdirSync(dirPath);
+            entries.forEach(entry => {
+                const fullPath = path.join(dirPath, entry);
+                const stats = fs.statSync(fullPath);
+                
+                if (stats.isDirectory()) {
+                    size += this.getDirectorySize(fullPath);
+                } else {
+                    size += stats.size;
+                }
+            });
+        } catch (error) {
+            // Ignore errors and return partial size
+        }
+        
+        return size;
+    }
+
+    /**
+     * Ensure directory exists with proper permissions
+     */
+    static ensureDirectory(dirPath, mode = 0o755) {
+        if (!fs.existsSync(dirPath)) {
+            fs.mkdirSync(dirPath, { recursive: true, mode });
+        }
+    }
+
+    /**
+     * Copy file with error handling
+     */
+    static copyFile(source, destination, mode = 0o644) {
+        try {
+            fs.copyFileSync(source, destination);
+            fs.chmodSync(destination, mode);
+            return true;
+        } catch (error) {
+            return false;
+        }
+    }
+
+    /**
+     * Check if path exists and is readable
+     */
+    static isReadable(filePath) {
+        try {
+            fs.accessSync(filePath, fs.constants.R_OK);
+            return true;
+        } catch (error) {
+            return false;
+        }
+    }
+
+    /**
+     * Check if path exists and is writable
+     */
+    static isWritable(filePath) {
+        try {
+            fs.accessSync(filePath, fs.constants.W_OK);
+            return true;
+        } catch (error) {
+            return false;
+        }
+    }
+
+    /**
+     * Get file stats safely
+     */
+    static getStats(filePath) {
+        try {
+            return fs.statSync(filePath);
+        } catch (error) {
+            return null;
+        }
+    }
+
+    /**
+     * Read file safely with encoding
+     */
+    static readFile(filePath, encoding = 'utf8') {
+        try {
+            return fs.readFileSync(filePath, encoding);
+        } catch (error) {
+            return null;
+        }
+    }
+
+    /**
+     * Write file safely with mode
+     */
+    static writeFile(filePath, content, mode = 0o644) {
+        try {
+            fs.writeFileSync(filePath, content, { mode });
+            return true;
+        } catch (error) {
+            return false;
+        }
+    }
+
+    /**
+     * Remove file or directory safely
+     */
+    static remove(targetPath) {
+        try {
+            if (fs.existsSync(targetPath)) {
+                const stats = fs.statSync(targetPath);
+                if (stats.isDirectory()) {
+                    fs.rmSync(targetPath, { recursive: true, force: true });
+                } else {
+                    fs.unlinkSync(targetPath);
+                }
+            }
+            return true;
+        } catch (error) {
+            return false;
+        }
+    }
+}
+
+module.exports = FileSystemUtils;

package/lib/utils.js

@@ -1,15 +1,19 @@
 // Utility functions for Claude Dev Toolkit
 const path = require('path');
 const fs = require('fs');
+const FileSystemUtils = require('./utils/file-system-utils');
 
 module.exports = {
+    // Keep backward compatibility
     ensureDirectory: (dirPath) => {
-        if (!fs.existsSync(dirPath)) {
-            fs.mkdirSync(dirPath, { recursive: true });
-        }
+        FileSystemUtils.ensureDirectory(dirPath);
     },
     
     isValidCommand: (commandName) => {
         return /^[a-z][a-z0-9-]*$/.test(commandName);
-    }
+    },
+
+    // Export new utilities for migration
+    FileSystemUtils,
+    ClaudePathConfig: require('./utils/claude-path-config')
 };