claude-git-hooks 2.4.0 → 2.5.0

package/lib/utils/interactive-ui.js

@@ -0,0 +1,314 @@
+/**
+ * File: interactive-ui.js
+ * Purpose: Interactive UI helpers for command-line prompts
+ *
+ * Features:
+ * - PR preview with colored output
+ * - Confirmation prompts
+ * - Field editing
+ * - Keyboard navigation
+ */
+
+import readline from 'readline';
+import logger from './logger.js';
+
+/**
+ * Show PR preview in formatted box
+ * Why: Give user visual preview before creating PR
+ *
+ * @param {Object} prData - PR data to preview
+ * @param {string} prData.title - PR title
+ * @param {string} prData.body - PR description
+ * @param {string} prData.base - Base branch
+ * @param {string} prData.head - Head branch
+ * @param {Array<string>} prData.labels - Labels
+ * @param {Array<string>} prData.reviewers - Reviewers
+ */
+export const showPRPreview = (prData) => {
+    const { title, body, base, head, labels = [], reviewers = [] } = prData;
+
+    console.log('');
+    console.log('┌───────────────────────────────────────────────────────────────┐');
+    console.log(' PR Preview');
+    console.log('├───────────────────────────────────────────────────────────────┤');
+    console.log(` Title: ${truncate(title, 55)}`);
+    console.log(` From:  ${truncate(head, 55)}`);
+    console.log(` To:    ${truncate(base, 55)}`);
+
+    if (labels.length > 0) {
+        console.log(` Labels: ${truncate(labels.join(', '), 53)}`);
+    }
+
+    if (reviewers.length > 0) {
+        console.log(` Reviewers: ${truncate(reviewers.join(', '), 50)}`);
+    }
+
+    console.log('├───────────────────────────────────────────────────────────────┤');
+    console.log(' Description:');
+
+    // Show first 5 lines of body
+    const bodyLines = body.split('\n').slice(0, 5);
+    bodyLines.forEach(line => {
+        console.log(` ${truncate(line, 61)}`);
+    });
+
+    if (body.split('\n').length > 5) {
+        console.log(' ... (truncated)');
+    }
+
+    console.log('└───────────────────────────────────────────────────────────────┘');
+    console.log('');
+};
+
+/**
+ * Truncate string to fit in box
+ * @private
+ */
+const truncate = (str, maxLen) => {
+    const padded = str.padEnd(maxLen, ' ');
+    return padded.length > maxLen ? padded.substring(0, maxLen - 3) + '...' : padded;
+};
+
+/**
+ * Prompt user for confirmation with custom message
+ * Why: Get yes/no confirmation before destructive operations
+ *
+ * @param {string} message - Question to ask
+ * @param {boolean} defaultValue - Default if user presses Enter (default: true)
+ * @returns {Promise<boolean>} - True if confirmed, false otherwise
+ */
+export const promptConfirmation = async (message, defaultValue = true) => {
+    const rl = readline.createInterface({
+        input: process.stdin,
+        output: process.stdout
+    });
+
+    return new Promise((resolve) => {
+        const defaultText = defaultValue ? 'Y/n' : 'y/N';
+        const promptMessage = `${message} (${defaultText}): `;
+
+        rl.question(promptMessage, (answer) => {
+            rl.close();
+
+            const trimmed = answer.trim().toLowerCase();
+
+            // If empty, use default
+            if (!trimmed) {
+                logger.debug('interactive-ui - promptConfirmation', 'Using default', { defaultValue });
+                resolve(defaultValue);
+                return;
+            }
+
+            // Check yes/no
+            const isYes = ['y', 'yes', 'si', 's'].includes(trimmed);
+            const isNo = ['n', 'no'].includes(trimmed);
+
+            if (isYes) {
+                logger.debug('interactive-ui - promptConfirmation', 'User confirmed');
+                resolve(true);
+            } else if (isNo) {
+                logger.debug('interactive-ui - promptConfirmation', 'User declined');
+                resolve(false);
+            } else {
+                // Invalid input, use default
+                logger.debug('interactive-ui - promptConfirmation', 'Invalid input, using default', {
+                    answer: trimmed,
+                    defaultValue
+                });
+                resolve(defaultValue);
+            }
+        });
+    });
+};
+
+/**
+ * Prompt user to edit a field value
+ * Why: Allow user to modify PR fields before creation
+ *
+ * @param {string} fieldName - Name of field (e.g., "Title", "Description")
+ * @param {string} currentValue - Current value
+ * @returns {Promise<string>} - Updated value (or current if user skips)
+ */
+export const promptEditField = async (fieldName, currentValue) => {
+    const rl = readline.createInterface({
+        input: process.stdin,
+        output: process.stdout
+    });
+
+    return new Promise((resolve) => {
+        console.log(`\nCurrent ${fieldName}:`);
+        console.log(currentValue);
+        console.log('');
+
+        const promptMessage = `New ${fieldName} (press Enter to keep current): `;
+
+        rl.question(promptMessage, (answer) => {
+            rl.close();
+
+            const trimmed = answer.trim();
+
+            if (!trimmed) {
+                logger.debug('interactive-ui - promptEditField', 'Keeping current value', { fieldName });
+                resolve(currentValue);
+            } else {
+                logger.debug('interactive-ui - promptEditField', 'Updated value', { fieldName });
+                resolve(trimmed);
+            }
+        });
+    });
+};
+
+/**
+ * Show menu with options and get user choice
+ * Why: Present multiple options to user
+ *
+ * @param {string} message - Menu message
+ * @param {Array<{key: string, label: string}>} options - Menu options
+ * @param {string} defaultKey - Default option key if user presses Enter
+ * @returns {Promise<string>} - Selected option key
+ */
+export const promptMenu = async (message, options, defaultKey = null) => {
+    const rl = readline.createInterface({
+        input: process.stdin,
+        output: process.stdout
+    });
+
+    return new Promise((resolve) => {
+        console.log('');
+        console.log(message);
+        console.log('');
+
+        // Display options
+        options.forEach(opt => {
+            const isDefault = opt.key === defaultKey;
+            const marker = isDefault ? '→' : ' ';
+            console.log(`  ${marker} [${opt.key}] ${opt.label}`);
+        });
+
+        console.log('');
+
+        const defaultText = defaultKey ? ` (default: ${defaultKey})` : '';
+        const promptMessage = `Choose an option${defaultText}: `;
+
+        rl.question(promptMessage, (answer) => {
+            rl.close();
+
+            const trimmed = answer.trim().toLowerCase();
+
+            // If empty, use default
+            if (!trimmed && defaultKey) {
+                logger.debug('interactive-ui - promptMenu', 'Using default', { defaultKey });
+                resolve(defaultKey);
+                return;
+            }
+
+            // Check if valid option
+            const selectedOption = options.find(opt => opt.key.toLowerCase() === trimmed);
+
+            if (selectedOption) {
+                logger.debug('interactive-ui - promptMenu', 'Option selected', { key: selectedOption.key });
+                resolve(selectedOption.key);
+            } else {
+                // Invalid, use default or first option
+                const fallback = defaultKey || options[0]?.key;
+                logger.debug('interactive-ui - promptMenu', 'Invalid option, using fallback', {
+                    answer: trimmed,
+                    fallback
+                });
+                resolve(fallback);
+            }
+        });
+    });
+};
+
+/**
+ * Show loading spinner with message
+ * Why: Provide visual feedback during long operations
+ *
+ * @param {string} message - Loading message
+ * @returns {Function} - Stop function to clear spinner
+ */
+export const showSpinner = (message) => {
+    const frames = ['⠋', '⠙', '⠹', '⠸', '⠼', '⠴', '⠦', '⠧', '⠇', '⠏'];
+    let frameIndex = 0;
+    let isActive = true;
+
+    const interval = setInterval(() => {
+        if (!isActive) {
+            clearInterval(interval);
+            return;
+        }
+
+        const frame = frames[frameIndex];
+        process.stdout.write(`\r${frame} ${message}`);
+        frameIndex = (frameIndex + 1) % frames.length;
+    }, 80);
+
+    // Return stop function
+    return () => {
+        isActive = false;
+        clearInterval(interval);
+        process.stdout.write('\r'); // Clear line
+    };
+};
+
+/**
+ * Show success message with checkmark
+ * @param {string} message - Success message
+ */
+export const showSuccess = (message) => {
+    console.log(`✅ ${message}`);
+};
+
+/**
+ * Show error message with X mark
+ * @param {string} message - Error message
+ */
+export const showError = (message) => {
+    console.log(`❌ ${message}`);
+};
+
+/**
+ * Show warning message with warning sign
+ * @param {string} message - Warning message
+ */
+export const showWarning = (message) => {
+    console.log(`⚠️  ${message}`);
+};
+
+/**
+ * Show info message with info icon
+ * @param {string} message - Info message
+ */
+export const showInfo = (message) => {
+    console.log(`ℹ️  ${message}`);
+};
+
+/**
+ * Clear console screen
+ * Why: Clean slate for new UI sections
+ */
+export const clearScreen = () => {
+    console.clear();
+};
+
+/**
+ * Wait for user to press Enter
+ * Why: Pause before continuing
+ *
+ * @param {string} message - Message to show (default: "Press Enter to continue")
+ * @returns {Promise<void>}
+ */
+export const waitForEnter = async (message = 'Press Enter to continue') => {
+    const rl = readline.createInterface({
+        input: process.stdin,
+        output: process.stdout
+    });
+
+    return new Promise((resolve) => {
+        rl.question(`\n${message}... `, () => {
+            rl.close();
+            resolve();
+        });
+    });
+};

package/lib/utils/mcp-setup.js

@@ -0,0 +1,342 @@
+/**
+ * File: mcp-setup.js
+ * Purpose: Automated GitHub MCP setup for Claude CLI
+ *
+ * Features:
+ * - Auto-detect existing configuration
+ * - Read token from Claude Desktop config
+ * - Interactive token prompt if needed
+ * - Configure Claude CLI MCP
+ * - Set environment variables
+ * - Verify configuration
+ */
+
+import { execSync } from 'child_process';
+import fs from 'fs';
+import path from 'path';
+import os from 'os';
+import logger from './logger.js';
+import { promptConfirmation, promptEditField, showSuccess, showError, showInfo, showWarning } from './interactive-ui.js';
+import { getClaudeCommand } from './claude-client.js';
+import { approveGitHubMcpPermissions, executeMcpCommand } from './github-client.js';
+
+/**
+ * Check if GitHub MCP is already configured in Claude CLI
+ * Why: Avoid duplicate configuration
+ *
+ * @returns {boolean} - True if configured
+ */
+export const isGitHubMCPConfigured = () => {
+    try {
+        const { command, args } = getClaudeCommand();
+        const fullCommand = `${command} ${args.join(' ')} mcp list`;
+        const mcpList = execSync(fullCommand, { encoding: 'utf8', stdio: ['pipe', 'pipe', 'ignore'] });
+        return mcpList.toLowerCase().includes('github');
+    } catch (error) {
+        logger.debug('mcp-setup - isGitHubMCPConfigured', 'Failed to check MCP list', { error: error.message });
+        return false;
+    }
+};
+
+/**
+ * Find GitHub token in Claude Desktop config
+ * Why: Reuse existing token instead of asking user
+ *
+ * @returns {Object|null} - { token, configPath } or null if not found
+ */
+export const findGitHubTokenInDesktopConfig = () => {
+    const possibleConfigPaths = [
+        // Linux/macOS standard path
+        path.join(os.homedir(), '.config', 'Claude', 'claude_desktop_config.json'),
+        // Windows native path
+        path.join(os.homedir(), 'AppData', 'Roaming', 'Claude', 'claude_desktop_config.json'),
+        // WSL accessing Windows path - try multiple user names
+        '/mnt/c/Users/' + os.userInfo().username + '/AppData/Roaming/Claude/claude_desktop_config.json',
+    ];
+
+    // Add additional Windows paths by checking if we're in WSL
+    if (process.platform === 'linux' && fs.existsSync('/mnt/c')) {
+        // We're in WSL, try to find all Windows user directories
+        try {
+            const usersDir = '/mnt/c/Users';
+            if (fs.existsSync(usersDir)) {
+                const users = fs.readdirSync(usersDir);
+                for (const user of users) {
+                    const configPath = `/mnt/c/Users/${user}/AppData/Roaming/Claude/claude_desktop_config.json`;
+                    if (!possibleConfigPaths.includes(configPath)) {
+                        possibleConfigPaths.push(configPath);
+                    }
+                }
+            }
+        } catch (error) {
+            logger.debug('mcp-setup - findGitHubTokenInDesktopConfig', 'Failed to scan /mnt/c/Users', {
+                error: error.message
+            });
+        }
+    }
+
+    for (const configPath of possibleConfigPaths) {
+        try {
+            if (fs.existsSync(configPath)) {
+                const config = JSON.parse(fs.readFileSync(configPath, 'utf8'));
+                const token = config.mcpServers?.github?.env?.GITHUB_PERSONAL_ACCESS_TOKEN;
+
+                if (token) {
+                    logger.debug('mcp-setup - findGitHubTokenInDesktopConfig', 'Found token', { configPath });
+                    return { token, configPath };
+                }
+            }
+        } catch (error) {
+            logger.debug('mcp-setup - findGitHubTokenInDesktopConfig', 'Failed to read config', {
+                configPath,
+                error: error.message
+            });
+        }
+    }
+
+    return null;
+};
+
+/**
+ * Add GitHub MCP to Claude CLI
+ * Why: Configure MCP server for PR creation
+ *
+ * @param {boolean} replace - Replace existing configuration
+ * @returns {Promise<boolean>} - True if successful
+ */
+export const addGitHubMCP = async (replace = false) => {
+    try {
+        const { command, args } = getClaudeCommand();
+
+        // Remove existing if replacing
+        if (replace) {
+            try {
+                const removeCmd = `${command} ${args.join(' ')} mcp remove github`;
+                execSync(removeCmd, { stdio: 'ignore' });
+                logger.debug('mcp-setup - addGitHubMCP', 'Removed existing GitHub MCP');
+            } catch (error) {
+                // Ignore errors, may not have remove command
+                logger.debug('mcp-setup - addGitHubMCP', 'Failed to remove (may not exist)', { error: error.message });
+            }
+        }
+
+        // Add GitHub MCP
+        // Use -- to separate claude options from npx arguments
+        const mcpCommand = `${command} ${args.join(' ')} mcp add github npx -- -y @modelcontextprotocol/server-github`;
+        logger.debug('mcp-setup - addGitHubMCP', 'Running MCP add command', { mcpCommand });
+
+        execSync(mcpCommand, { stdio: 'inherit' });
+
+        logger.debug('mcp-setup - addGitHubMCP', 'Successfully added GitHub MCP');
+        return true;
+
+    } catch (error) {
+        logger.error('mcp-setup - addGitHubMCP', 'Failed to add GitHub MCP', error);
+        return false;
+    }
+};
+
+/**
+ * Set environment variable in shell RC files
+ * Why: Persist GitHub token across sessions
+ *
+ * @param {string} token - GitHub Personal Access Token
+ * @returns {boolean} - True if set in at least one file
+ */
+export const setEnvironmentVariable = (token) => {
+    const envVarLine = `export GITHUB_PERSONAL_ACCESS_TOKEN="${token}"`;
+    const shellRcFiles = [
+        path.join(os.homedir(), '.bashrc'),
+        path.join(os.homedir(), '.bash_profile'),
+        path.join(os.homedir(), '.zshrc')
+    ];
+
+    let envVarSet = false;
+
+    for (const rcFile of shellRcFiles) {
+        try {
+            if (fs.existsSync(rcFile)) {
+                const content = fs.readFileSync(rcFile, 'utf8');
+
+                // Check if already present
+                if (content.includes('GITHUB_PERSONAL_ACCESS_TOKEN')) {
+                    logger.debug('mcp-setup - setEnvironmentVariable', 'Already present', { rcFile });
+                    showInfo(`Environment variable already in ${path.basename(rcFile)}`);
+                    envVarSet = true;
+                    continue;
+                }
+
+                // Add to file
+                fs.appendFileSync(rcFile, `\n# GitHub MCP token for Claude CLI\n${envVarLine}\n`);
+                showSuccess(`Added environment variable to ${path.basename(rcFile)}`);
+                logger.debug('mcp-setup - setEnvironmentVariable', 'Added to file', { rcFile });
+                envVarSet = true;
+            }
+        } catch (error) {
+            logger.debug('mcp-setup - setEnvironmentVariable', 'Failed to update file', {
+                rcFile,
+                error: error.message
+            });
+        }
+    }
+
+    if (!envVarSet) {
+        showWarning('Could not find shell RC file (.bashrc, .bash_profile, .zshrc)');
+        console.log('');
+        console.log('Please add this line to your shell configuration manually:');
+        console.log(`  ${envVarLine}`);
+    }
+
+    // Set for current session
+    process.env.GITHUB_PERSONAL_ACCESS_TOKEN = token;
+
+    return envVarSet;
+};
+
+/**
+ * Setup GitHub MCP for Claude CLI
+ * Why: Automate MCP configuration to enable create-pr functionality
+ *
+ * Interactive setup process:
+ * 1. Check if GitHub MCP already configured
+ * 2. Try to read GitHub token from Claude Desktop config
+ * 3. If not found, prompt user for token
+ * 4. Run: claude mcp add github npx -y @modelcontextprotocol/server-github
+ * 5. Configure environment variable for token
+ * 6. Verify configuration
+ *
+ * @returns {Promise<void>}
+ */
+export const setupGitHubMCP = async () => {
+    try {
+        console.log('');
+        showInfo('GitHub MCP Setup for Claude CLI');
+        console.log('');
+
+        // Step 1: Check if already configured
+        console.log('🔍 Checking current MCP configuration...');
+
+        let mcpList = '';
+        try {
+            const { command, args } = getClaudeCommand();
+            const fullCommand = `${command} ${args.join(' ')} mcp list`;
+            mcpList = execSync(fullCommand, { encoding: 'utf8', stdio: ['pipe', 'pipe', 'ignore'] });
+        } catch (error) {
+            showError('Failed to run "claude mcp list". Is Claude CLI installed?');
+            console.error('Make sure Claude CLI is installed: npm install -g @anthropic-ai/claude-cli');
+            console.error('Error:', error.message);
+            process.exit(1);
+        }
+
+        const hasGitHub = isGitHubMCPConfigured();
+        if (hasGitHub) {
+            showSuccess('GitHub MCP is already configured!');
+            console.log('');
+            console.log(mcpList);
+
+            const reconfigure = await promptConfirmation('Do you want to reconfigure it?', false);
+            if (!reconfigure) {
+                showInfo('Setup cancelled. Your existing configuration is unchanged.');
+                return;
+            }
+        }
+
+        // Step 2: Try to read token from Claude Desktop config
+        console.log('');
+        console.log('🔑 Looking for GitHub token...');
+
+        let githubToken = null;
+        const tokenInfo = findGitHubTokenInDesktopConfig();
+
+        if (tokenInfo) {
+            githubToken = tokenInfo.token;
+            showSuccess('Found GitHub token in Claude Desktop config');
+            console.log(`  Location: ${tokenInfo.configPath}`);
+        }
+
+        // Step 3: If not found, prompt user
+        if (!githubToken) {
+            showWarning('No GitHub token found in Claude Desktop config');
+            console.log('');
+            console.log('You need a GitHub Personal Access Token with these permissions:');
+            console.log('  - repo (Full control of private repositories)');
+            console.log('  - read:org (Read org and team membership)');
+            console.log('');
+            console.log('Create one at: https://github.com/settings/tokens/new');
+            console.log('');
+
+            githubToken = await promptEditField('GitHub Personal Access Token', '');
+
+            if (!githubToken || githubToken.trim() === '') {
+                showError('GitHub token is required. Setup cancelled.');
+                process.exit(1);
+            }
+        }
+
+        // Step 4: Add GitHub MCP to Claude CLI
+        console.log('');
+        console.log('⚙️  Configuring GitHub MCP for Claude CLI...');
+
+        const added = await addGitHubMCP(hasGitHub);
+        if (!added) {
+            showError('Failed to add GitHub MCP');
+            process.exit(1);
+        }
+
+        showSuccess('GitHub MCP added to Claude CLI');
+
+        // Step 5: Configure environment variable
+        console.log('');
+        console.log('🔧 Setting up environment variable...');
+
+        setEnvironmentVariable(githubToken);
+
+        // Step 6: Approve MCP permissions
+        console.log('');
+        console.log('🔐 Approving MCP permissions...');
+
+        const permResult = await approveGitHubMcpPermissions();
+        if (permResult.success) {
+            showSuccess('MCP permissions approved');
+        } else {
+            showWarning('Some permissions may need manual approval');
+            console.log('  Run: claude mcp approve github --all');
+        }
+
+        // Step 7: Verify configuration
+        console.log('');
+        console.log('✅ Verifying configuration...');
+
+        try {
+            const { command, args } = getClaudeCommand();
+            const fullCommand = `${command} ${args.join(' ')} mcp list`;
+            const verifyList = execSync(fullCommand, { encoding: 'utf8' });
+            if (verifyList.toLowerCase().includes('github')) {
+                showSuccess('GitHub MCP is configured and ready!');
+                console.log('');
+                console.log(verifyList);
+            } else {
+                showWarning('Configuration completed but GitHub MCP not showing in list');
+                console.log('You may need to restart your terminal');
+            }
+        } catch (error) {
+            showWarning('Could not verify configuration');
+            logger.debug('mcp-setup - setupGitHubMCP', 'Verification failed', { error: error.message });
+        }
+
+        // Final instructions
+        console.log('');
+        showSuccess('Setup complete!');
+        console.log('');
+        console.log('Next steps:');
+        console.log('  1. Restart your terminal (or run: source ~/.bashrc)');
+        console.log('  2. Verify with: claude mcp list');
+        console.log('  3. Try creating a PR: claude-hooks create-pr develop');
+        console.log('');
+
+    } catch (error) {
+        showError('Error during MCP setup: ' + error.message);
+        console.error(error);
+        throw error;
+    }
+};