claude-git-hooks 2.9.1 → 2.10.0

package/lib/commands/analyze-diff.js

@@ -0,0 +1,262 @@
+/**
+ * File: analyze-diff.js
+ * Purpose: Analyze differences between branches and generate PR info
+ */
+
+import { execSync } from 'child_process';
+import fs from 'fs';
+import { executeClaudeWithRetry, extractJSON } from '../utils/claude-client.js';
+import { loadPrompt } from '../utils/prompt-builder.js';
+import { getConfig } from '../config.js';
+import {
+    colors,
+    error,
+    success,
+    info,
+    warning,
+    checkGitRepo
+} from './helpers.js';
+
+/**
+ * Analyze-diff command
+ * @param {Array<string>} args - Command arguments
+ */
+export async function runAnalyzeDiff(args) {
+    if (!checkGitRepo()) {
+        error('You are not in a Git repository.');
+        return;
+    }
+
+    // Load configuration
+    const config = await getConfig();
+
+    const currentBranch = execSync('git branch --show-current', { encoding: 'utf8' }).trim();
+
+    if (!currentBranch) {
+        error('You are not in a valid branch.');
+        return;
+    }
+
+    // Update remote references
+    execSync('git fetch', { stdio: 'ignore' });
+
+    let baseBranch, compareWith, contextDescription;
+
+    if (args[0]) {
+        // Case with argument: compare current branch vs origin/specified-branch
+        const targetBranch = args[0];
+        baseBranch = `origin/${targetBranch}`;
+        compareWith = `${baseBranch}...HEAD`;
+        contextDescription = `${currentBranch} vs ${baseBranch}`;
+
+        // Check that the origin branch exists
+        try {
+            execSync(`git rev-parse --verify ${baseBranch}`, { stdio: 'ignore' });
+        } catch (e) {
+            error(`Branch ${baseBranch} does not exist.`);
+            return;
+        }
+    } else {
+        // Case without argument: compare current branch vs origin/current-branch
+        baseBranch = `origin/${currentBranch}`;
+        compareWith = `${baseBranch}...HEAD`;
+        contextDescription = `${currentBranch} vs ${baseBranch}`;
+
+        // Check that the origin branch exists
+        try {
+            execSync(`git rev-parse --verify ${baseBranch}`, { stdio: 'ignore' });
+        } catch (e) {
+            // Try fallback to origin/develop
+            baseBranch = 'origin/develop';
+            compareWith = `${baseBranch}...HEAD`;
+            contextDescription = `${currentBranch} vs ${baseBranch} (fallback)`;
+
+            try {
+                execSync(`git rev-parse --verify ${baseBranch}`, { stdio: 'ignore' });
+                warning(`Branch origin/${currentBranch} does not exist. Using ${baseBranch} as fallback.`);
+            } catch (e2) {
+                // Try fallback to origin/main
+                baseBranch = 'origin/main';
+                compareWith = `${baseBranch}...HEAD`;
+                contextDescription = `${currentBranch} vs ${baseBranch} (fallback)`;
+
+                try {
+                    execSync(`git rev-parse --verify ${baseBranch}`, { stdio: 'ignore' });
+                    warning(`No origin/develop branch. Using ${baseBranch} as fallback.`);
+                } catch (e3) {
+                    error('Could not find a valid comparison branch (tried origin/current, origin/develop, origin/main).');
+                    return;
+                }
+            }
+        }
+    }
+
+    info(`Analyzing: ${contextDescription}...`);
+
+    // Get modified files
+    let diffFiles;
+    try {
+        diffFiles = execSync(`git diff ${compareWith} --name-only`, { encoding: 'utf8' }).trim();
+
+        if (!diffFiles) {
+            // Check if there are staged or unstaged changes
+            const stagedFiles = execSync('git diff --cached --name-only', { encoding: 'utf8' }).trim();
+            const unstagedFiles = execSync('git diff --name-only', { encoding: 'utf8' }).trim();
+
+            if (stagedFiles || unstagedFiles) {
+                warning('No differences with remote, but you have uncommitted local changes.');
+                console.log('Staged changes:', stagedFiles || 'none');
+                console.log('Unstaged changes:', unstagedFiles || 'none');
+            } else {
+                success('✅ No differences. Your branch is synchronized.');
+            }
+            return;
+        }
+    } catch (e) {
+        error('Error getting differences: ' + e.message);
+        return;
+    }
+
+    // Get the complete diff
+    let fullDiff, commits;
+    try {
+        fullDiff = execSync(`git diff ${compareWith}`, { encoding: 'utf8' });
+        commits = execSync(`git log ${baseBranch}..HEAD --oneline`, { encoding: 'utf8' }).trim();
+    } catch (e) {
+        error('Error getting diff or commits: ' + e.message);
+        return;
+    }
+
+    // Check if subagents should be used
+    const useSubagents = config.subagents.enabled;
+    const subagentModel = config.subagents.model;
+    let subagentBatchSize = config.subagents.batchSize;
+    // Validate batch size (must be >= 1)
+    if (subagentBatchSize < 1) {
+        subagentBatchSize = 1;
+    }
+    const subagentInstruction = useSubagents
+        ? `\n\nIMPORTANT PARALLEL PROCESSING: If analyzing 3+ files, process them in batches of ${subagentBatchSize}. For EACH batch, create that many subagents in parallel using Task tool (send single message with multiple Task calls). Each subagent analyzes one file and provides insights. After ALL batches complete, consolidate into SINGLE JSON with ONE cohesive PR title/description. Model: ${subagentModel}. Example: 4 files with BATCH_SIZE=1 → 4 sequential batches of 1 subagent each. Example: 4 files with BATCH_SIZE=3 → batch 1 has 3 parallel subagents (files 1-3), batch 2 has 1 subagent (file 4).\n`
+        : '';
+
+    // Truncate full diff if too large
+    const truncatedDiff = fullDiff.length > 50000
+        ? fullDiff.substring(0, 50000) + '\n... (truncated diff)'
+        : fullDiff;
+
+    // Load prompt from template
+    const prompt = await loadPrompt('ANALYZE_DIFF.md', {
+        CONTEXT_DESCRIPTION: contextDescription,
+        SUBAGENT_INSTRUCTION: subagentInstruction,
+        COMMITS: commits,
+        DIFF_FILES: diffFiles,
+        FULL_DIFF: truncatedDiff
+    });
+
+    info('Sending to Claude for analysis...');
+    const startTime = Date.now();
+
+    // Prepare telemetry context
+    const filesChanged = diffFiles.split('\n').length;
+    const telemetryContext = {
+        fileCount: filesChanged,
+        batchSize: filesChanged,
+        totalBatches: 1,
+        model: subagentModel || 'sonnet',
+        hook: 'analyze-diff'
+    };
+
+    try {
+        // Use cross-platform executeClaudeWithRetry from claude-client.js with telemetry
+        const response = await executeClaudeWithRetry(prompt, {
+            timeout: 180000, // 3 minutes for diff analysis
+            telemetryContext
+        });
+
+        // Extract JSON from response using claude-client utility
+        const result = extractJSON(response);
+
+        // Show the results
+        console.log('');
+        console.log('════════════════════════════════════════════════════════════════');
+        console.log('                      DIFFERENCES ANALYSIS                      ');
+        console.log('════════════════════════════════════════════════════════════════');
+        console.log('');
+
+        console.log(`🔍 ${colors.blue}Context:${colors.reset} ${contextDescription}`);
+        console.log(`📊 ${colors.blue}Changed Files:${colors.reset} ${filesChanged}`);
+        console.log('');
+
+        console.log(`📝 ${colors.green}Pull Request Title:${colors.reset}`);
+        console.log(`   ${result.prTitle}`);
+        console.log('');
+
+        console.log(`🌿 ${colors.green}Suggested branch name:${colors.reset}`);
+        console.log(`   ${result.suggestedBranchName}`);
+        console.log('');
+
+        console.log(`📋 ${colors.green}Type of change:${colors.reset} ${result.changeType}`);
+
+        if (result.breakingChanges) {
+            console.log(`⚠️  ${colors.yellow}Breaking Changes: SÍ${colors.reset}`);
+        }
+
+        console.log('');
+        console.log(`📄 ${colors.green}Pull Request Description:${colors.reset}`);
+        console.log('───────────────────────────────────────────────────────────────');
+        console.log(result.prDescription);
+        console.log('───────────────────────────────────────────────────────────────');
+
+        if (result.testingNotes) {
+            console.log('');
+            console.log(`🧪 ${colors.green}Testing notes:${colors.reset}`);
+            console.log(result.testingNotes);
+        }
+
+        // Save the results in a file with context
+        const outputData = {
+            ...result,
+            context: {
+                currentBranch,
+                baseBranch,
+                contextDescription,
+                filesChanged,
+                timestamp: new Date().toISOString()
+            }
+        };
+
+        // Ensure .claude/out directory exists
+        const outputDir = '.claude/out';
+        if (!fs.existsSync(outputDir)) {
+            fs.mkdirSync(outputDir, { recursive: true });
+        }
+
+        const outputFile = '.claude/out/pr-analysis.json';
+        fs.writeFileSync(outputFile, JSON.stringify(outputData, null, 2));
+
+        const elapsed = Date.now() - startTime;
+        const seconds = Math.floor(elapsed / 1000);
+        const ms = elapsed % 1000;
+        console.log('');
+        console.log(`${colors.blue}⏱️  Analysis completed in ${seconds}.${ms}s${colors.reset}`);
+        info(`Results saved in ${outputFile}`);
+
+        // Contextual suggestions
+        console.log('');
+        if (!args[0] && contextDescription.includes('local changes without push')) {
+            // Case of local changes without push
+            console.log(`💡 ${colors.yellow}To create new branch with these changes:${colors.reset}`);
+            console.log(`   git checkout -b ${result.suggestedBranchName}`);
+            console.log(`   git push -u origin ${result.suggestedBranchName}`);
+        } else if (currentBranch !== result.suggestedBranchName) {
+            // Normal case of comparison between branches
+            console.log(`💡 ${colors.yellow}For renaming your current branch:${colors.reset}`);
+            console.log(`   git branch -m ${result.suggestedBranchName}`);
+        }
+
+        console.log(`💡 ${colors.yellow}Tip:${colors.reset} Use this information to create your PR on GitHub.`);
+
+    } catch (e) {
+        error('Error executing Claude: ' + e.message);
+    }
+}

package/lib/commands/create-pr.js

@@ -0,0 +1,374 @@
+/**
+ * File: create-pr.js
+ * Purpose: Create pull request with auto-generated metadata and reviewers
+ */
+
+import { execSync } from 'child_process';
+import fs from 'fs';
+import path from 'path';
+import { executeClaudeWithRetry, extractJSON } from '../utils/claude-client.js';
+import { loadPrompt } from '../utils/prompt-builder.js';
+import { getConfig } from '../config.js';
+import { getOrPromptTaskId, formatWithTaskId } from '../utils/task-id.js';
+import { getReviewersForFiles } from '../utils/github-client.js';
+import { showPRPreview, promptMenu, showSuccess, showError, showInfo, showWarning } from '../utils/interactive-ui.js';
+import logger from '../utils/logger.js';
+import {
+    error,
+    checkGitRepo
+} from './helpers.js';
+
+/**
+ * Create PR command (v2.5.0+ - Octokit-based)
+ * @param {Array<string>} args - Command arguments
+ */
+export async function runCreatePr(args) {
+    logger.debug('create-pr', 'Starting create-pr command', { args });
+
+    if (!checkGitRepo()) {
+        error('You are not in a Git repository.');
+        logger.debug('create-pr', 'Not in a git repository, exiting');
+        return;
+    }
+
+    try {
+        // Load configuration
+        logger.debug('create-pr', 'Loading configuration');
+        const config = await getConfig();
+        logger.debug('create-pr', 'Configuration loaded', {
+            preset: config.preset,
+            githubEnabled: config.github?.enabled,
+            defaultBase: config.github?.pr?.defaultBase
+        });
+
+        // Import GitHub API module
+        logger.debug('create-pr', 'Importing GitHub API modules');
+        const { createPullRequest, GitHubAPIError, validateToken, findExistingPR } = await import('../utils/github-api.js');
+        const { parseGitHubRepo } = await import('../utils/github-client.js');
+
+        showInfo('🚀 Creating Pull Request...');
+        console.log('');
+
+        // Step 1: Validate GitHub token
+        logger.debug('create-pr', 'Step 1: Validating GitHub token');
+        const tokenValidation = await validateToken();
+        if (!tokenValidation.valid) {
+            logger.error('create-pr', 'GitHub authentication failed', { error: tokenValidation.error });
+            showError('GitHub authentication failed');
+            console.log('');
+            console.log('Please configure your GitHub token:');
+            console.log('  Option 1: Set GITHUB_TOKEN environment variable');
+            console.log('  Option 2: Add token to .claude/settings.local.json:');
+            console.log('            { "githubToken": "ghp_your_token_here" }');
+            console.log('  Option 3: Run: claude-hooks setup-github');
+            console.log('');
+            process.exit(1);
+        }
+
+        logger.debug('create-pr', 'Token validation successful', {
+            user: tokenValidation.user,
+            hasRepoScope: tokenValidation.hasRepoScope,
+            scopes: tokenValidation.scopes
+        });
+
+        showSuccess(`Authenticated as: ${tokenValidation.user}`);
+        if (!tokenValidation.hasRepoScope) {
+            showWarning('Token may lack "repo" scope - PR creation might fail');
+        }
+
+        // Step 2: Get or prompt for task-id (with config for pattern)
+        logger.debug('create-pr', 'Step 2: Getting or prompting for task-id');
+        const taskId = await getOrPromptTaskId({
+            prompt: true,      // DO prompt for PRs (unlike commit messages)
+            required: false,   // Allow skipping
+            config: config     // Pass config for custom pattern
+        });
+        logger.debug('create-pr', 'Task ID determined', { taskId });
+
+        // Step 3: Parse arguments and determine base branch
+        logger.debug('create-pr', 'Step 3: Parsing arguments and determining base branch', { args });
+        let baseBranchArg = args[0];
+        if (baseBranchArg && /^[A-Z]{2,10}-\d+$/i.test(baseBranchArg)) {
+            baseBranchArg = args[1];
+        }
+        const baseBranch = baseBranchArg || config.github?.pr?.defaultBase || 'develop';
+        logger.debug('create-pr', 'Base branch determined', { baseBranch, fromConfig: !baseBranchArg });
+
+        // Step 4: Get current branch and repo info
+        logger.debug('create-pr', 'Step 4: Getting current branch and repo info');
+        const currentBranch = execSync('git branch --show-current', { encoding: 'utf8' }).trim();
+        if (!currentBranch) {
+            logger.error('create-pr', 'Could not determine current branch');
+            error('Could not determine current branch');
+            return;
+        }
+
+        const repoInfo = parseGitHubRepo();
+        logger.debug('create-pr', 'Repository and branch info', {
+            owner: repoInfo.owner,
+            repo: repoInfo.repo,
+            currentBranch,
+            baseBranch
+        });
+
+        showInfo(`Repository: ${repoInfo.fullName}`);
+        showInfo(`Branch: ${currentBranch} → ${baseBranch}`);
+
+        // Step 5: Check for existing PR
+        logger.debug('create-pr', 'Step 5: Checking for existing PR');
+        const existingPR = await findExistingPR({
+            owner: repoInfo.owner,
+            repo: repoInfo.repo,
+            head: currentBranch,
+            base: baseBranch
+        });
+
+        if (existingPR) {
+            logger.debug('create-pr', 'Existing PR found, exiting', {
+                prNumber: existingPR.number,
+                prUrl: existingPR.html_url
+            });
+            showWarning(`A PR already exists for this branch: #${existingPR.number}`);
+            console.log(`  ${existingPR.html_url}`);
+            console.log('');
+            return;
+        }
+
+        logger.debug('create-pr', 'No existing PR found, continuing');
+
+        // Step 6: Update remote and check for differences
+        logger.debug('create-pr', 'Step 6: Fetching latest changes from remote');
+        execSync('git fetch', { stdio: 'ignore' });
+        const compareWith = `origin/${baseBranch}...HEAD`;
+
+        try {
+            execSync(`git rev-parse --verify origin/${baseBranch}`, { stdio: 'ignore' });
+        } catch (e) {
+            error(`Base branch origin/${baseBranch} does not exist`);
+            return;
+        }
+
+        let diffFiles;
+        try {
+            diffFiles = execSync(`git diff ${compareWith} --name-only`, { encoding: 'utf8' }).trim();
+            if (!diffFiles) {
+                showWarning('No differences with remote branch. Nothing to create a PR for.');
+                return;
+            }
+        } catch (e) {
+            error('Error getting differences: ' + e.message);
+            return;
+        }
+
+        const filesArray = diffFiles.split('\n').filter(f => f.trim());
+        logger.debug('create-pr', 'Modified files detected', {
+            fileCount: filesArray.length,
+            files: filesArray
+        });
+        showInfo(`Found ${filesArray.length} modified file(s)`);
+
+        // Step 7: Generate PR metadata with Claude (reuse analyze-diff logic)
+        logger.debug('create-pr', 'Step 7: Generating PR metadata with Claude');
+        let fullDiff, commits;
+        try {
+            fullDiff = execSync(`git diff ${compareWith}`, { encoding: 'utf8' });
+            commits = execSync(`git log origin/${baseBranch}..HEAD --oneline`, { encoding: 'utf8' }).trim();
+        } catch (e) {
+            error('Error getting diff or commits: ' + e.message);
+            return;
+        }
+
+        const truncatedDiff = fullDiff.length > 50000
+            ? fullDiff.substring(0, 50000) + '\n... (truncated)'
+            : fullDiff;
+
+        const contextDescription = `${currentBranch} vs origin/${baseBranch}`;
+        const prompt = await loadPrompt('ANALYZE_DIFF.md', {
+            CONTEXT_DESCRIPTION: contextDescription,
+            SUBAGENT_INSTRUCTION: '',
+            COMMITS: commits,
+            DIFF_FILES: diffFiles,
+            FULL_DIFF: truncatedDiff
+        });
+
+        showInfo('Generating PR metadata with Claude...');
+        logger.debug('create-pr', 'Calling Claude with prompt', { promptLength: prompt.length });
+
+        // Prepare telemetry context for create-pr
+        const telemetryContext = {
+            fileCount: filesArray.length,
+            batchSize: filesArray.length,
+            totalBatches: 1,
+            model: 'sonnet', // create-pr always uses main model
+            hook: 'create-pr'
+        };
+
+        const response = await executeClaudeWithRetry(prompt, {
+            timeout: 180000,
+            telemetryContext
+        });
+        logger.debug('create-pr', 'Claude response received', { responseLength: response.length });
+
+        const analysisResult = extractJSON(response);
+        logger.debug('create-pr', 'Analysis result extracted', {
+            hasResult: !!analysisResult,
+            hasPrTitle: !!analysisResult?.prTitle
+        });
+
+        if (!analysisResult || !analysisResult.prTitle) {
+            logger.error('create-pr', 'Failed to generate PR metadata from analysis', { analysisResult });
+            error('Failed to generate PR metadata from analysis');
+            return;
+        }
+
+        // Step 8: Prepare PR data
+        logger.debug('create-pr', 'Step 8: Preparing PR data');
+        let prTitle = analysisResult.prTitle;
+        if (taskId) {
+            prTitle = formatWithTaskId(prTitle, taskId);
+            logger.debug('create-pr', 'Task ID added to title', { prTitle });
+        }
+
+        const prBody = analysisResult.prDescription || analysisResult.description || '';
+        logger.debug('create-pr', 'PR title and body prepared', {
+            titleLength: prTitle.length,
+            bodyLength: prBody.length
+        });
+
+        // Step 9: Get labels from preset
+        logger.debug('create-pr', 'Step 9: Getting labels from preset');
+        let labels = [];
+        if (config.preset && config.github?.pr?.labelRules) {
+            labels = config.github.pr.labelRules[config.preset] || [];
+        }
+        if (analysisResult.breakingChanges) {
+            labels.push('breaking-change');
+        }
+        logger.debug('create-pr', 'Labels determined', { labels, preset: config.preset });
+
+        // Step 10: Get reviewers from CODEOWNERS and config
+        logger.debug('create-pr', 'Step 10: Getting reviewers from CODEOWNERS and config');
+        const reviewers = await getReviewersForFiles(filesArray, config.github?.pr);
+        logger.debug('create-pr', 'Reviewers determined', { reviewers, sources: 'CODEOWNERS + config' });
+
+        // Step 11: Show PR preview
+        const prData = {
+            title: prTitle,
+            body: prBody,
+            head: currentBranch,
+            base: baseBranch,
+            labels,
+            reviewers
+        };
+
+        showPRPreview(prData);
+
+        // Step 12: Prompt for confirmation
+        const action = await promptMenu(
+            'What would you like to do?',
+            [
+                { key: 'c', label: 'Create PR' },
+                { key: 'x', label: 'Cancel' }
+            ],
+            'c'
+        );
+
+        if (action === 'x') {
+            showInfo('PR creation cancelled');
+
+            // Save metadata for later use
+            const outputDir = '.claude/out';
+            if (!fs.existsSync(outputDir)) {
+                fs.mkdirSync(outputDir, { recursive: true });
+            }
+            const outputFile = path.join(outputDir, 'pr-metadata.json');
+            fs.writeFileSync(outputFile, JSON.stringify(prData, null, 2));
+            showInfo(`PR metadata saved to ${outputFile}`);
+            return;
+        }
+
+        // Step 13: Create PR via Octokit
+        logger.debug('create-pr', 'Step 13: Creating PR via Octokit');
+        showInfo('Creating pull request on GitHub...');
+
+        try {
+            logger.debug('create-pr', 'Calling createPullRequest API', {
+                owner: repoInfo.owner,
+                repo: repoInfo.repo,
+                head: prData.head,
+                base: prData.base
+            });
+
+            const result = await createPullRequest({
+                owner: repoInfo.owner,
+                repo: repoInfo.repo,
+                title: prData.title,
+                body: prData.body,
+                head: prData.head,
+                base: prData.base,
+                draft: false,
+                labels: prData.labels,
+                reviewers: prData.reviewers
+            });
+
+            logger.debug('create-pr', 'PR created successfully', {
+                prNumber: result.number,
+                prUrl: result.html_url
+            });
+
+            console.log('');
+            showSuccess('Pull request created successfully!');
+            console.log('');
+            console.log(`  PR #${result.number}: ${result.html_url}`);
+            console.log('');
+
+            if (result.reviewers.length > 0) {
+                showInfo(`Reviewers requested: ${result.reviewers.join(', ')}`);
+            }
+            if (result.labels.length > 0) {
+                showInfo(`Labels added: ${result.labels.join(', ')}`);
+            }
+
+        } catch (apiError) {
+            logger.error('create-pr', 'Failed to create pull request', apiError);
+            showError('Failed to create pull request');
+            console.error('');
+            console.error(`  ${apiError.message}`);
+
+            if (apiError.context?.suggestion) {
+                console.error('');
+                console.error(`  💡 ${apiError.context.suggestion}`);
+            }
+            console.error('');
+
+            // Save PR metadata for manual creation or retry
+            const outputDir = '.claude/out';
+            if (!fs.existsSync(outputDir)) {
+                fs.mkdirSync(outputDir, { recursive: true });
+            }
+            const outputFile = path.join(outputDir, 'pr-metadata.json');
+            fs.writeFileSync(outputFile, JSON.stringify({
+                ...prData,
+                error: apiError.message,
+                timestamp: new Date().toISOString()
+            }, null, 2));
+
+            logger.debug('create-pr', 'PR metadata saved', { outputFile });
+            showInfo(`PR metadata saved to ${outputFile}`);
+            showInfo('You can create the PR manually using this data');
+
+            process.exit(1);
+        }
+
+    } catch (err) {
+        logger.error('create-pr', 'Error creating PR', err);
+        showError('Error creating PR: ' + err.message);
+
+        if (err.context) {
+            logger.debug('create-pr', 'Error context', err.context);
+            console.error('Context:', JSON.stringify(err.context, null, 2));
+        }
+
+        process.exit(1);
+    }
+}

package/lib/commands/debug.js

@@ -0,0 +1,52 @@
+/**
+ * File: debug.js
+ * Purpose: Debug mode management command
+ */
+
+import { getConfig } from '../config.js';
+import {
+    colors,
+    error,
+    info,
+    updateConfig
+} from './helpers.js';
+
+/**
+ * Sets debug mode
+ * Why: Enables detailed logging for troubleshooting
+ * @param {string} value - 'true', 'false', or 'status'
+ */
+export async function runSetDebug(value) {
+    if (!value) {
+        error('Please specify a value: claude-hooks --debug <true|false|status>');
+        return;
+    }
+
+    const normalizedValue = value.toLowerCase();
+
+    // Handle status check
+    if (normalizedValue === 'status') {
+        try {
+            const config = await getConfig();
+            const isEnabled = config.system.debug || false;
+            console.log('');
+            info(`Debug mode: ${isEnabled ? colors.green + 'enabled' + colors.reset : colors.red + 'disabled' + colors.reset}`);
+            console.log('');
+        } catch (err) {
+            error(`Failed to check debug status: ${err.message}`);
+        }
+        return;
+    }
+
+    // Validate and convert to boolean
+    if (normalizedValue !== 'true' && normalizedValue !== 'false') {
+        error('Invalid value. Use: true, false, or status');
+        return;
+    }
+
+    const debugValue = normalizedValue === 'true';
+
+    await updateConfig('system.debug', debugValue, {
+        successMessage: (val) => `Debug mode ${val ? 'enabled' : 'disabled'}`
+    });
+}