claude-git-hooks 2.9.1 → 2.11.0

package/lib/commands/migrate-config.js

@@ -0,0 +1,103 @@
+/**
+ * File: migrate-config.js
+ * Purpose: Migrate legacy config.json to v2.8.0 format
+ *
+ * DEPRECATED: Will be removed in v3.0.0 (most users will have migrated by then)
+ */
+
+import fs from 'fs';
+import path from 'path';
+import {
+    error,
+    success,
+    info,
+    warning
+} from './helpers.js';
+import { extractLegacySettings } from './install.js';
+
+/**
+ * Migrates legacy config.json to v2.8.0 format (Manual command)
+ * Why: Simplifies configuration, reduces redundancy
+ */
+export async function runMigrateConfig() {
+    const claudeDir = '.claude';
+    const configPath = path.join(claudeDir, 'config.json');
+
+    if (!fs.existsSync(configPath)) {
+        info('ℹ️  No config file found. Nothing to migrate.');
+        console.log('\n💡 To create a new config:');
+        console.log('  1. Run: claude-hooks install --force');
+        console.log('  2. Or copy from: .claude/config_example/config.example.json');
+        return;
+    }
+
+    try {
+        const rawConfig = JSON.parse(fs.readFileSync(configPath, 'utf8'));
+
+        // Check if already in v2.8.0 format
+        if (rawConfig.version === '2.8.0') {
+            success('✅ Config is already in v2.8.0 format.');
+            return;
+        }
+
+        info('📦 Starting config migration to v2.8.0...');
+
+        // Create backup in config_old/
+        const configOldDir = path.join(claudeDir, 'config_old');
+        if (!fs.existsSync(configOldDir)) {
+            fs.mkdirSync(configOldDir, { recursive: true });
+        }
+        const backupPath = path.join(configOldDir, `config.json.${Date.now()}`);
+        fs.copyFileSync(configPath, backupPath);
+        success(`Backup created: ${backupPath}`);
+
+        // Extract only allowed parameters
+        const allowedOverrides = extractLegacySettings(rawConfig);
+
+        // Check for advanced params
+        const hasAdvancedParams = allowedOverrides.analysis?.ignoreExtensions ||
+                                  allowedOverrides.commitMessage?.taskIdPattern ||
+                                  allowedOverrides.subagents?.model;
+
+        // Build new config
+        const newConfig = {
+            version: '2.8.0',
+            preset: rawConfig.preset || 'default'
+        };
+
+        // Only add overrides if there are any
+        if (Object.keys(allowedOverrides).length > 0) {
+            newConfig.overrides = allowedOverrides;
+        }
+
+        // Show diff
+        console.log('\n📝 Migration preview:');
+        console.log(`  Old format: ${Object.keys(rawConfig).length} top-level keys`);
+        console.log(`  New format: ${Object.keys(newConfig).length} top-level keys`);
+        if (Object.keys(allowedOverrides).length > 0) {
+            console.log(`  Preserved: ${Object.keys(allowedOverrides).length} override sections`);
+        }
+
+        // Write new config
+        fs.writeFileSync(configPath, JSON.stringify(newConfig, null, 4));
+        success('✅ Config migrated to v2.8.0 successfully!');
+
+        if (hasAdvancedParams) {
+            warning('⚠️  Advanced parameters detected and preserved');
+            info('📖 See .claude/config.advanced.example.json for documentation');
+        }
+
+        console.log(`\n✨ New config:`);
+        console.log(JSON.stringify(newConfig, null, 2));
+        console.log(`\n💾 Old config backed up to: ${backupPath}`);
+        console.log('\n💡 Many parameters are now hardcoded with sensible defaults');
+        console.log('   See CHANGELOG.md for full list of changes');
+
+    } catch (err) {
+        error(`Failed to migrate config: ${err.message}`);
+        console.log('\n💡 Manual migration:');
+        console.log('  1. Backup your current config');
+        console.log('  2. See .claude/config.example.json for new format');
+        console.log('  3. Copy minimal example and customize');
+    }
+}

package/lib/commands/presets.js

@@ -0,0 +1,101 @@
+/**
+ * File: presets.js
+ * Purpose: Preset management commands (list, set, current)
+ */
+
+import { listPresets } from '../utils/preset-loader.js';
+import { getConfig } from '../config.js';
+import {
+    colors,
+    error,
+    success,
+    info,
+    warning,
+    updateConfig
+} from './helpers.js';
+
+/**
+ * Shows all available presets
+ */
+export async function runShowPresets() {
+    try {
+        const presets = await listPresets();
+
+        if (presets.length === 0) {
+            warning('No presets found');
+            return;
+        }
+
+        console.log('');
+        info('Available presets:');
+        console.log('');
+
+        presets.forEach(preset => {
+            console.log(`  ${colors.green}${preset.name}${colors.reset}`);
+            console.log(`    ${preset.displayName}`);
+            console.log(`    ${colors.blue}${preset.description}${colors.reset}`);
+            console.log('');
+        });
+
+        info('To set a preset: claude-hooks --set-preset <name>');
+        info('To see current preset: claude-hooks preset current');
+        console.log('');
+    } catch (err) {
+        error(`Failed to list presets: ${err.message}`);
+    }
+}
+
+/**
+ * Sets the active preset
+ * Why: Configures tech-stack specific analysis settings
+ * @param {string} presetName - Name of preset to activate
+ */
+export async function runSetPreset(presetName) {
+    if (!presetName) {
+        error('Please specify a preset name: claude-hooks --set-preset <name>');
+        return;
+    }
+
+    await updateConfig('preset', presetName, {
+        validator: async (name) => {
+            const presets = await listPresets();
+            const preset = presets.find(p => p.name === name);
+            if (!preset) {
+                error(`Preset "${name}" not found`);
+                info('Available presets:');
+                presets.forEach(p => console.log(`  - ${p.name}`));
+                throw new Error(`Invalid preset: ${name}`);
+            }
+            return preset;
+        },
+        successMessage: async (name) => {
+            const presets = await listPresets();
+            const preset = presets.find(p => p.name === name);
+            return `Preset '${preset.displayName}' activated`;
+        }
+    });
+}
+
+/**
+ * Shows the current active preset
+ */
+export async function runCurrentPreset() {
+    try {
+        const config = await getConfig();
+        const presetName = config.preset || 'default';
+
+        const presets = await listPresets();
+        const preset = presets.find(p => p.name === presetName);
+
+        if (preset) {
+            console.log('');
+            success(`Current preset: ${preset.displayName} (${preset.name})`);
+            console.log(`  ${colors.blue}${preset.description}${colors.reset}`);
+            console.log('');
+        } else {
+            warning(`Current preset "${presetName}" not found`);
+        }
+    } catch (err) {
+        error(`Failed to get current preset: ${err.message}`);
+    }
+}

package/lib/commands/setup-github.js

@@ -0,0 +1,93 @@
+/**
+ * File: setup-github.js
+ * Purpose: Interactive GitHub authentication setup command
+ *
+ * Handles:
+ * - Checking existing token
+ * - Prompting user for new token
+ * - Validating token format and permissions
+ * - Saving token to .claude/settings.local.json
+ */
+
+import { validateToken, saveGitHubToken, validateTokenFormat } from '../utils/github-api.js';
+import { promptConfirmation, promptEditField, showSuccess, showError, showInfo, showWarning } from '../utils/interactive-ui.js';
+import logger from '../utils/logger.js';
+
+/**
+ * Run GitHub authentication setup
+ * Why: Interactive flow to configure GitHub token for PR creation
+ *
+ * @returns {Promise<void>}
+ */
+export async function runSetupGitHub() {
+    showInfo('GitHub Authentication Setup');
+
+    // Check existing token
+    try {
+        const validation = await validateToken();
+        if (validation.valid) {
+            showSuccess(`Already authenticated as: ${validation.user}`);
+            logger.info(`  Scopes: ${validation.scopes.join(', ')}`);
+
+            if (!validation.hasRepoScope) {
+                showWarning('Token lacks "repo" scope - PR creation may fail');
+            }
+
+            const reconfigure = await promptConfirmation('Configure a different token?', false);
+            if (!reconfigure) {
+                return;
+            }
+        }
+    } catch (e) {
+        logger.debug('setup-github', 'No existing token found or validation failed', { error: e.message });
+    }
+
+    // Show instructions
+    logger.info('Create a GitHub Personal Access Token:');
+    logger.info('  1. Go to: https://github.com/settings/tokens/new');
+    logger.info('  2. Select scopes: repo, read:org');
+    logger.info('  3. Generate and copy the token');
+
+    // Prompt for token
+    const token = await promptEditField('Paste your token (ghp_...)', '');
+
+    if (!token || token.trim() === '') {
+        showWarning('No token provided. Setup cancelled.');
+        return;
+    }
+
+    const trimmedToken = token.trim();
+
+    // Validate format
+    const formatCheck = validateTokenFormat(trimmedToken);
+    if (formatCheck.warning) {
+        showWarning(formatCheck.warning);
+        const proceed = await promptConfirmation('Continue anyway?', false);
+        if (!proceed) {
+            return;
+        }
+    }
+
+    // Save token
+    const saveResult = saveGitHubToken(trimmedToken);
+    if (!saveResult.success) {
+        showError('Failed to save token: ' + saveResult.error);
+        return;
+    }
+    showSuccess(`Token saved to ${saveResult.path}`);
+
+    // Validate with GitHub API
+    showInfo('Validating token...');
+
+    const validation = await validateToken();
+    if (validation.valid) {
+        showSuccess(`Authenticated as: ${validation.user}`);
+        if (!validation.hasRepoScope) {
+            showWarning('Token lacks "repo" scope - regenerate with "repo" enabled');
+        }
+    } else {
+        showWarning('Token validation failed - may not work correctly');
+    }
+
+    showSuccess('Setup complete! You can now use: claude-hooks create-pr');
+}

package/lib/commands/telemetry-cmd.js

@@ -0,0 +1,48 @@
+/**
+ * File: telemetry-cmd.js
+ * Purpose: Telemetry management commands (show, clear)
+ */
+
+import { getConfig } from '../config.js';
+import { displayStatistics as showTelemetryStats, clearTelemetry as clearTelemetryData } from '../utils/telemetry.js';
+import { promptConfirmation } from '../utils/interactive-ui.js';
+import logger from '../utils/logger.js';
+import {
+    success,
+    info
+} from './helpers.js';
+
+/**
+ * Show telemetry statistics
+ * Why: Help users understand JSON parsing patterns and batch performance
+ */
+export async function runShowTelemetry() {
+    await showTelemetryStats();
+}
+
+/**
+ * Clear telemetry data
+ * Why: Allow users to reset telemetry
+ */
+export async function runClearTelemetry() {
+    const config = await getConfig();
+
+    if (!config.system?.telemetry && config.system?.telemetry !== undefined) {
+        logger.warning('⚠️  Telemetry is currently disabled.');
+        logger.info('To re-enable (default), remove or set to true in .claude/config.json:');
+        logger.info('{');
+        logger.info('  "system": {');
+        logger.info('    "telemetry": true');
+        logger.info('  }');
+        logger.info('}');
+        return;
+    }
+
+    const confirmed = await promptConfirmation('Are you sure you want to clear all telemetry data?');
+    if (confirmed) {
+        await clearTelemetryData();
+        success('Telemetry data cleared successfully');
+    } else {
+        info('Telemetry data was not cleared');
+    }
+}

package/lib/commands/update.js

@@ -0,0 +1,67 @@
+/**
+ * File: update.js
+ * Purpose: Update command - update to the latest version
+ */
+
+import { execSync } from 'child_process';
+import {
+    error,
+    success,
+    info,
+    warning,
+    getPackageJson,
+    getLatestVersion,
+    compareVersions
+} from './helpers.js';
+import { runInstall } from './install.js';
+
+/**
+ * Update command - update to the latest version
+ */
+export async function runUpdate() {
+    info('Checking latest available version...');
+
+    try {
+        const currentVersion = getPackageJson().version;
+        const latestVersion = await getLatestVersion('claude-git-hooks');
+
+        const comparison = compareVersions(currentVersion, latestVersion);
+
+        if (comparison === 0) {
+            success(`You already have the latest version installed (${currentVersion})`);
+            return;
+        } else if (comparison > 0) {
+            info(`You are using a development version (${currentVersion})`);
+            info(`Latest published version: ${latestVersion}`);
+            success(`You already have the latest version installed (${currentVersion})`);
+            return;
+        }
+
+        info(`Current version: ${currentVersion}`);
+        info(`Available version: ${latestVersion}`);
+
+        // Update the package
+        info('Updating claude-git-hooks...');
+        try {
+            execSync('npm install -g claude-git-hooks@latest', { stdio: 'inherit' });
+            success(`Successfully updated to version ${latestVersion}`);
+
+            // Reinstall hooks with the new version
+            info('Reinstalling hooks with the new version...');
+            await runInstall(['--force']);
+
+        } catch (updateError) {
+            error('Error updating. Try running: npm install -g claude-git-hooks@latest');
+        }
+    } catch (e) {
+        warning('Could not check the latest available version');
+        warning('Trying to update anyway...');
+        try {
+            execSync('npm install -g claude-git-hooks@latest', { stdio: 'inherit' });
+            success('Update completed');
+            await runInstall(['--force']);
+        } catch (updateError) {
+            error('Error updating: ' + updateError.message);
+        }
+    }
+}

package/lib/config.js

@@ -101,6 +101,11 @@ const defaults = {
                 ai: ['ai', 'tooling'],
                 default: []
             },
+            // Auto-push configuration (v2.11.0)
+            autoPush: true,                // Auto-push unpublished branches
+            pushConfirm: true,             // Prompt for confirmation before push
+            verifyRemote: true,            // Verify remote exists before push
+            showCommits: true,             // Show commit preview before push
         },
     },
 

package/lib/utils/git-operations.js

@@ -328,6 +328,215 @@ const getStagedStats = () => {
     }
 };
 
+/**
+ * Gets the configured remote name
+ * Why: Determines which remote to use for push operations (usually 'origin')
+ *
+ * @returns {string} Remote name (default: 'origin')
+ */
+const getRemoteName = () => {
+    logger.debug('git-operations - getRemoteName', 'Getting remote name');
+
+    try {
+        // Get list of remotes
+        const remotes = execGitCommand('remote');
+        const remoteList = remotes.split(/\r?\n/).filter(r => r.length > 0);
+
+        if (remoteList.length === 0) {
+            logger.debug('git-operations - getRemoteName', 'No remotes configured');
+            return 'origin'; // Default even if not configured
+        }
+
+        // Prefer 'origin', otherwise use first remote
+        const remoteName = remoteList.includes('origin') ? 'origin' : remoteList[0];
+
+        logger.debug('git-operations - getRemoteName', 'Remote name determined', {
+            remoteName,
+            availableRemotes: remoteList
+        });
+
+        return remoteName;
+
+    } catch (error) {
+        logger.error('git-operations - getRemoteName', 'Failed to get remote name', error);
+        return 'origin'; // Fallback to default
+    }
+};
+
+/**
+ * Verifies that a remote exists and is configured
+ * Why: Prevents push failures by checking remote configuration first
+ *
+ * @param {string} remoteName - Name of remote to verify (e.g., 'origin')
+ * @returns {boolean} True if remote exists, false otherwise
+ */
+const verifyRemoteExists = (remoteName) => {
+    logger.debug('git-operations - verifyRemoteExists', 'Verifying remote exists', { remoteName });
+
+    try {
+        const remotes = execGitCommand('remote');
+        const remoteList = remotes.split(/\r?\n/).filter(r => r.length > 0);
+        const exists = remoteList.includes(remoteName);
+
+        logger.debug('git-operations - verifyRemoteExists', 'Remote verification result', {
+            remoteName,
+            exists,
+            availableRemotes: remoteList
+        });
+
+        return exists;
+
+    } catch (error) {
+        logger.error('git-operations - verifyRemoteExists', 'Failed to verify remote', error);
+        return false;
+    }
+};
+
+/**
+ * Gets branch push status (remote tracking, unpushed commits, divergence)
+ * Why: Determines if and how to push before creating PR
+ *
+ * @param {string} branchName - Branch to check
+ * @returns {Object} Status object with:
+ *   - hasRemote: boolean (branch exists on remote)
+ *   - hasUnpushedCommits: boolean (local commits not pushed)
+ *   - hasDiverged: boolean (local and remote histories differ)
+ *   - upstreamBranch: string (e.g., 'origin/feature-branch')
+ *   - unpushedCommits: Array<{sha, message}> (commits to push)
+ */
+const getBranchPushStatus = (branchName) => {
+    logger.debug('git-operations - getBranchPushStatus', 'Checking branch push status', { branchName });
+
+    const status = {
+        hasRemote: false,
+        hasUnpushedCommits: false,
+        hasDiverged: false,
+        upstreamBranch: null,
+        unpushedCommits: []
+    };
+
+    try {
+        // Check if branch has upstream tracking
+        // Use execSync directly to avoid logging expected "no upstream" errors
+        const upstream = execSync(
+            `git rev-parse --abbrev-ref --symbolic-full-name ${branchName}@{u}`,
+            { encoding: 'utf8', stdio: ['pipe', 'pipe', 'pipe'] }
+        ).trim();
+
+        status.upstreamBranch = upstream;
+        status.hasRemote = true;
+
+        logger.debug('git-operations - getBranchPushStatus', 'Branch has upstream', {
+            branchName,
+            upstream
+        });
+
+        // Check for unpushed commits (local ahead of remote)
+        const unpushedLog = execGitCommand(`rev-list ${upstream}..${branchName} --oneline`);
+        if (unpushedLog) {
+            status.hasUnpushedCommits = true;
+            status.unpushedCommits = unpushedLog.split(/\r?\n/)
+                .filter(line => line.length > 0)
+                .map(line => {
+                    const [sha, ...messageParts] = line.split(' ');
+                    return {
+                        sha,
+                        message: messageParts.join(' ')
+                    };
+                });
+        }
+
+        // Check for divergence (remote has commits not in local)
+        const divergedLog = execGitCommand(`rev-list ${branchName}..${upstream} --oneline`);
+        if (divergedLog) {
+            status.hasDiverged = true;
+            logger.debug('git-operations - getBranchPushStatus', 'Branch has diverged', {
+                branchName,
+                remoteCommits: divergedLog.split(/\r?\n/).length
+            });
+        }
+
+    } catch (error) {
+        // No upstream means branch not published to remote (this is expected, not an error)
+        logger.debug('git-operations - getBranchPushStatus', 'Branch has no upstream (not published)', {
+            branchName
+        });
+
+        status.hasRemote = false;
+        status.hasUnpushedCommits = true; // All commits are unpushed
+
+        // Get all commits on this branch (not on any remote branch)
+        try {
+            const remoteName = getRemoteName();
+            const allCommits = execGitCommand(`rev-list ${branchName} --not --remotes=${remoteName} --oneline`);
+            if (allCommits) {
+                status.unpushedCommits = allCommits.split(/\r?\n/)
+                    .filter(line => line.length > 0)
+                    .map(line => {
+                        const [sha, ...messageParts] = line.split(' ');
+                        return {
+                            sha,
+                            message: messageParts.join(' ')
+                        };
+                    });
+            }
+        } catch (commitError) {
+            logger.debug('git-operations - getBranchPushStatus', 'Could not get unpushed commits', commitError);
+        }
+    }
+
+    logger.debug('git-operations - getBranchPushStatus', 'Push status determined', status);
+
+    return status;
+};
+
+/**
+ * Pushes branch to remote
+ * Why: Publishes local branch to remote before creating PR
+ *
+ * @param {string} branchName - Branch to push
+ * @param {Object} options - Push options
+ * @param {boolean} options.setUpstream - Use -u flag to set upstream tracking (default: false)
+ * @returns {Object} Result object with:
+ *   - success: boolean
+ *   - output: string (stdout)
+ *   - error: string (stderr)
+ */
+const pushBranch = (branchName, { setUpstream = false } = {}) => {
+    logger.debug('git-operations - pushBranch', 'Pushing branch', { branchName, setUpstream });
+
+    try {
+        const remoteName = getRemoteName();
+        const upstreamFlag = setUpstream ? '-u' : '';
+        const command = upstreamFlag
+            ? `push ${upstreamFlag} ${remoteName} ${branchName}`
+            : `push ${remoteName} ${branchName}`;
+
+        const output = execGitCommand(command);
+
+        logger.debug('git-operations - pushBranch', 'Push successful', {
+            branchName,
+            remoteName,
+            setUpstream
+        });
+
+        return {
+            success: true,
+            output,
+            error: ''
+        };
+
+    } catch (error) {
+        logger.error('git-operations - pushBranch', 'Push failed', error);
+
+        return {
+            success: false,
+            output: error.output || '',
+            error: error.cause?.message || error.message || 'Unknown push error'
+        };
+    }
+};
+
 export {
     GitError,
     getStagedFiles,
@@ -337,5 +546,9 @@ export {
     getRepoRoot,
     getCurrentBranch,
     getRepoName,
-    getStagedStats
+    getStagedStats,
+    getRemoteName,
+    verifyRemoteExists,
+    getBranchPushStatus,
+    pushBranch
 };