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

package/bin/claude-commands

@@ -129,4 +129,24 @@ program
         }
     });
 
+program
+    .command('subagents')
+    .description('Manage AI subagents for Claude Code')
+    .option('-l, --list', 'List available subagents')
+    .option('-i, --install', 'Install subagents to Claude Code')
+    .action((options) => {
+        const subagents = require('../lib/subagents');
+        subagents.handleCommand(options);
+    });
+
+program
+    .command('config')
+    .description('Manage Claude Code configuration templates')
+    .option('-l, --list', 'List available configuration templates')
+    .option('-t, --template <name>', 'Apply configuration template')
+    .action((options) => {
+        const config = require('../lib/config');
+        config.handleCommand(options);
+    });
+
 program.parse(process.argv);

package/lib/config.js

@@ -145,7 +145,7 @@ function getAvailableTemplates(templatesDir) {
                         id: path.basename(file, '.json'),
                         name: file,
                         path: templatePath,
-                        description: data['// Description'] || `${file} template`,
+                        description: getTemplateDescription(file, data),
                         features: Object.keys(data).filter(key => !key.startsWith('//')).length
                     });
                 } catch (error) {
@@ -161,6 +161,184 @@ function getAvailableTemplates(templatesDir) {
     }
 }
 
+/**
+ * Get human-readable description for a template
+ * @param {string} filename - Template filename
+ * @param {Object} data - Parsed template data
+ * @returns {string} - Human-readable description
+ */
+function getTemplateDescription(filename, data) {
+    // Check for explicit description in template
+    if (data['// Description']) {
+        return data['// Description'];
+    }
+    
+    // Generate description based on filename
+    const basename = path.basename(filename, '.json');
+    switch (basename) {
+        case 'basic-settings':
+            return 'Minimal configuration for getting started with Claude Code';
+        case 'comprehensive-settings':
+            return 'Full-featured configuration with all available options';
+        case 'security-focused-settings':
+            return 'Security-enhanced configuration with additional protections';
+        default:
+            return `Configuration template: ${basename}`;
+    }
+}
+
+/**
+ * GREEN PHASE: Config Command CLI Handler
+ * Implements claude-commands config feature requirements
+ */
+class ConfigManager {
+    constructor() {
+        this.templatesDir = path.join(__dirname, '..', 'templates');
+        this.claudeDir = path.join(os.homedir(), '.claude');
+        this.settingsPath = path.join(this.claudeDir, 'settings.json');
+    }
+
+    // REQ-CONFIG-001: List Templates
+    listTemplates() {
+        console.log('📋 Available Configuration Templates:\n');
+        
+        try {
+            if (!fs.existsSync(this.templatesDir)) {
+                console.log('❌ Templates directory not found');
+                return;
+            }
+
+            const templates = getAvailableTemplates(this.templatesDir);
+
+            if (templates.length === 0) {
+                console.log('No configuration templates found');
+                return;
+            }
+
+            templates.forEach(template => {
+                console.log(`  📄 ${template.name}`);
+                console.log(`     ${template.description}`);
+            });
+
+            console.log(`\n💡 Usage: claude-commands config --template <name>`);
+        } catch (error) {
+            console.error('❌ Error listing templates:', error.message);
+        }
+    }
+
+    // REQ-CONFIG-002: Apply Template
+    applyTemplate(templateName) {
+        try {
+            // Validate template exists
+            const templatePath = path.join(this.templatesDir, templateName);
+            if (!fs.existsSync(templatePath)) {
+                this.handleTemplateNotFound(templateName);
+                return false;
+            }
+
+            // Ensure Claude directory exists
+            this.ensureClaudeDirectory();
+
+            // Backup existing settings if present
+            this.backupExistingSettings();
+
+            // Apply template using existing function
+            const success = applyConfigurationTemplate(templatePath, this.settingsPath);
+            
+            if (success) {
+                console.log(`✅ Successfully applied template '${templateName}'`);
+                console.log(`📝 Configuration saved to: ${this.settingsPath}`);
+                return true;
+            } else {
+                console.error(`❌ Failed to apply template '${templateName}'`);
+                return false;
+            }
+        } catch (error) {
+            console.error('❌ Error applying template:', error.message);
+            return false;
+        }
+    }
+
+    // Helper method for template not found error
+    handleTemplateNotFound(templateName) {
+        console.error(`❌ Template '${templateName}' not found.`);
+        this.listTemplates();
+    }
+
+    // Helper method to ensure Claude directory exists
+    ensureClaudeDirectory() {
+        if (!fs.existsSync(this.claudeDir)) {
+            fs.mkdirSync(this.claudeDir, { recursive: true });
+            console.log(`📁 Created directory: ${this.claudeDir}`);
+        }
+    }
+
+    // Helper method to backup existing settings
+    backupExistingSettings() {
+        if (fs.existsSync(this.settingsPath)) {
+            const backupPath = this.createBackup();
+            console.log(`💾 Backed up existing settings to: ${backupPath}`);
+        }
+    }
+
+    // REQ-CONFIG-002: Backup functionality
+    createBackup() {
+        const timestamp = new Date().toISOString()
+            .replace(/[:.]/g, '-')
+            .replace('T', '-')
+            .split('.')[0]; // YYYY-MM-DD-HHMMSS format
+        
+        const backupPath = `${this.settingsPath}.backup.${timestamp}`;
+        fs.copyFileSync(this.settingsPath, backupPath);
+        return backupPath;
+    }
+
+    // REQ-CONFIG-003: Show Help
+    showHelp() {
+        console.log('🔧 Claude Commands Config Tool\n');
+        console.log('Usage:');
+        console.log('  claude-commands config [options]\n');
+        console.log('Options:');
+        console.log('  -l, --list                List available configuration templates');
+        console.log('  -t, --template <name>     Apply configuration template');
+        console.log('  -h, --help                Show this help message\n');
+        console.log('Examples:');
+        console.log('  claude-commands config --list                          # Show available templates');
+        console.log('  claude-commands config --template basic-settings.json  # Apply basic template');
+        console.log('  claude-commands config --help                          # Show this help\n');
+        console.log('Description:');
+        console.log('  Manage Claude Code configuration templates. Templates are applied');
+        console.log('  to ~/.claude/settings.json with automatic backup of existing settings.');
+    }
+
+    // Main command handler
+    handleCommand(options) {
+        // REQ-CONFIG-003: Show help when no options or explicit help
+        if (!options.list && !options.template) {
+            this.showHelp();
+            return;
+        }
+
+        // REQ-CONFIG-001: List templates
+        if (options.list) {
+            this.listTemplates();
+            return;
+        }
+
+        // REQ-CONFIG-002: Apply template
+        if (options.template) {
+            const success = this.applyTemplate(options.template);
+            if (!success) {
+                process.exit(1);
+            }
+            return;
+        }
+    }
+}
+
+// Create config manager instance
+const configManager = new ConfigManager();
+
 module.exports = {
     getConfigPath: () => {
         return path.join(os.homedir(), '.claude', 'commands');
@@ -172,11 +350,16 @@ module.exports = {
         colorOutput: true
     },
 
-    // REQ-009 Implementation
+    // REQ-009 Implementation (existing)
     applyConfigurationTemplate,
     getAvailableTemplates,
     
     // Utility functions (exposed for testing)
     parseJSONC,
-    deepMerge
+    deepMerge,
+    getTemplateDescription,
+
+    // CLI command handler (new)
+    handleCommand: (options) => configManager.handleCommand(options),
+    ConfigManager
 };

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/subagent-formatter.js

@@ -0,0 +1,278 @@
+/**
+ * Subagent Output Formatter
+ * Handles all console output formatting for subagent operations
+ * Separates display logic from business logic
+ */
+
+/**
+ * Emoji and message constants for consistent formatting
+ */
+const DISPLAY_CONSTANTS = {
+    EMOJIS: {
+        ROBOT: '🤖',
+        SUCCESS: '✅',
+        ERROR: '❌',
+        FOLDER: '📁',
+        ROCKET: '🚀',
+        PARTY: '🎉',
+        CHART: '📊'
+    },
+    MESSAGES: {
+        NO_SUBAGENTS: 'No subagents directory found in package or no subagent files available',
+        NO_SUBAGENTS_INSTALL: 'No subagents directory found in package or no subagent files to install',
+        INSTALL_FAILED: 'Failed to install',
+        INSTALL_SUCCESS: 'Successfully installed',
+        CREATE_DIR_FAILED: 'Failed to create directory'
+    }
+};
+
+/**
+ * Formatter for subagent listing operations
+ */
+class SubagentListFormatter {
+    /**
+     * Format the header for subagent listing
+     */
+    static formatHeader() {
+        return `${DISPLAY_CONSTANTS.EMOJIS.ROBOT} Available Subagents:\n`;
+    }
+
+    /**
+     * Format the no subagents found message
+     */
+    static formatNoSubagents() {
+        return `${DISPLAY_CONSTANTS.EMOJIS.ERROR} ${DISPLAY_CONSTANTS.MESSAGES.NO_SUBAGENTS}`;
+    }
+
+    /**
+     * Format a single subagent item
+     * @param {string} name - Subagent name
+     * @param {number} index - Index in the list
+     */
+    static formatSubagentItem(name, index) {
+        return `  ${index + 1}. ${name}`;
+    }
+
+    /**
+     * Format the summary footer
+     * @param {number} count - Number of subagents
+     */
+    static formatSummary(count) {
+        return `\n${DISPLAY_CONSTANTS.EMOJIS.CHART} ${count} subagents available`;
+    }
+
+    /**
+     * Format complete subagent list
+     * @param {string[]} subagents - Array of subagent names
+     */
+    static formatList(subagents) {
+        if (subagents.length === 0) {
+            return [
+                this.formatHeader(),
+                this.formatNoSubagents()
+            ];
+        }
+
+        const lines = [this.formatHeader()];
+        
+        subagents.forEach((name, index) => {
+            lines.push(this.formatSubagentItem(name, index));
+        });
+        
+        lines.push(this.formatSummary(subagents.length));
+        
+        return lines;
+    }
+}
+
+/**
+ * Formatter for subagent installation operations
+ */
+class SubagentInstallFormatter {
+    /**
+     * Format installation header
+     */
+    static formatHeader() {
+        return `${DISPLAY_CONSTANTS.EMOJIS.ROCKET} Installing AI Subagents...\n`;
+    }
+
+    /**
+     * Format no subagents to install message
+     */
+    static formatNoSubagents() {
+        return `${DISPLAY_CONSTANTS.EMOJIS.ERROR} ${DISPLAY_CONSTANTS.MESSAGES.NO_SUBAGENTS_INSTALL}`;
+    }
+
+    /**
+     * Format directory creation message
+     * @param {string} path - Directory path that was created
+     */
+    static formatDirectoryCreated(path) {
+        return `${DISPLAY_CONSTANTS.EMOJIS.FOLDER} Created directory: ${path}`;
+    }
+
+    /**
+     * Format successful installation of a single file
+     * @param {string} filename - Name of the installed file
+     */
+    static formatInstallSuccess(filename) {
+        return `  ${DISPLAY_CONSTANTS.EMOJIS.SUCCESS} ${filename}`;
+    }
+
+    /**
+     * Format failed installation of a single file
+     * @param {string} filename - Name of the file that failed to install
+     * @param {string} error - Error message
+     */
+    static formatInstallError(filename, error) {
+        return `  ${DISPLAY_CONSTANTS.EMOJIS.ERROR} ${DISPLAY_CONSTANTS.MESSAGES.INSTALL_FAILED} ${filename}: ${error}`;
+    }
+
+    /**
+     * Format installation summary
+     * @param {Object} summary - Installation summary object
+     * @param {number} summary.installed - Number of successfully installed files
+     * @param {number} summary.failed - Number of failed installations
+     * @param {string} summary.path - Installation path
+     */
+    static formatSummary(summary) {
+        const lines = [
+            `\n${DISPLAY_CONSTANTS.EMOJIS.PARTY} Installation Summary:`,
+            `  ${DISPLAY_CONSTANTS.MESSAGES.INSTALL_SUCCESS}: ${summary.installed} subagents`
+        ];
+
+        if (summary.failed > 0) {
+            lines.push(`  ${DISPLAY_CONSTANTS.MESSAGES.INSTALL_FAILED}: ${summary.failed} subagents`);
+        }
+
+        lines.push(`  Installation path: ${summary.path}`);
+
+        return lines;
+    }
+
+    /**
+     * Format directory creation error
+     * @param {string} error - Error message
+     */
+    static formatDirectoryError(error) {
+        return `${DISPLAY_CONSTANTS.EMOJIS.ERROR} ${DISPLAY_CONSTANTS.MESSAGES.CREATE_DIR_FAILED}: ${error}`;
+    }
+}
+
+/**
+ * Formatter for help text
+ */
+class SubagentHelpFormatter {
+    /**
+     * Format complete help text
+     * @param {number} subagentCount - Number of available subagents
+     */
+    static formatHelp(subagentCount) {
+        return [
+            `${DISPLAY_CONSTANTS.EMOJIS.ROBOT} Claude Commands - Subagents Management\n`,
+            'Usage:',
+            '  claude-commands subagents [options]\n',
+            'Options:',
+            '  -l, --list     List available AI subagents from package',
+            '  -i, --install  Install all subagents to Claude Code (~/.claude/subagents/)',
+            '  -h, --help     Show this help message\n',
+            'Examples:',
+            '  claude-commands subagents --list     # Show available subagents',
+            '  claude-commands subagents --install  # Install all subagents',
+            '  claude-commands subagents --help     # Show this help\n',
+            'Description:',
+            '  Manage AI subagents for Claude Code. Subagents are specialized AI',
+            '  assistants that help with specific development tasks like security',
+            '  auditing, code review, documentation, and more.\n',
+            `Package Status: ${subagentCount} subagents available`
+        ];
+    }
+}
+
+/**
+ * Main formatter class that orchestrates all formatting operations
+ */
+class SubagentFormatter {
+    /**
+     * Display formatted subagent list
+     * @param {string[]} subagents - Array of subagent names
+     */
+    static displayList(subagents) {
+        const lines = SubagentListFormatter.formatList(subagents);
+        console.log(lines.join('\n'));
+    }
+
+    /**
+     * Display installation progress and results
+     * @param {Object} params - Installation parameters
+     * @param {string[]} params.subagents - Subagents to install
+     * @param {function} params.onProgress - Progress callback (filename, success, error)
+     * @param {function} params.onDirectoryCreated - Directory creation callback (path)
+     * @param {Object} params.summary - Final summary
+     */
+    static displayInstallation({ subagents, onProgress, onDirectoryCreated, summary }) {
+        console.log(SubagentInstallFormatter.formatHeader());
+
+        if (subagents.length === 0) {
+            console.log(SubagentInstallFormatter.formatNoSubagents());
+            return;
+        }
+
+        // Directory creation feedback
+        if (onDirectoryCreated) {
+            onDirectoryCreated((path) => {
+                console.log(SubagentInstallFormatter.formatDirectoryCreated(path));
+            });
+        }
+
+        // Progress feedback
+        if (onProgress) {
+            onProgress((filename, success, error) => {
+                if (success) {
+                    console.log(SubagentInstallFormatter.formatInstallSuccess(filename));
+                } else {
+                    console.log(SubagentInstallFormatter.formatInstallError(filename, error));
+                }
+            });
+        }
+
+        // Final summary
+        if (summary) {
+            const summaryLines = SubagentInstallFormatter.formatSummary(summary);
+            console.log(summaryLines.join('\n'));
+        }
+    }
+
+    /**
+     * Display help text
+     * @param {number} subagentCount - Number of available subagents
+     */
+    static displayHelp(subagentCount) {
+        const helpLines = SubagentHelpFormatter.formatHelp(subagentCount);
+        console.log(helpLines.join('\n'));
+    }
+
+    /**
+     * Display error message
+     * @param {string} error - Error message
+     */
+    static displayError(error) {
+        console.error(`${DISPLAY_CONSTANTS.EMOJIS.ERROR} ${error}`);
+    }
+
+    /**
+     * Display directory creation error
+     * @param {string} error - Error message
+     */
+    static displayDirectoryError(error) {
+        console.error(SubagentInstallFormatter.formatDirectoryError(error));
+    }
+}
+
+module.exports = {
+    SubagentFormatter,
+    SubagentListFormatter,
+    SubagentInstallFormatter,
+    SubagentHelpFormatter,
+    DISPLAY_CONSTANTS
+};