claude-git-hooks 2.9.1 → 2.10.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/utils/github-api.js

@@ -2,7 +2,7 @@
  * File: github-api.js
  * Purpose: Direct GitHub API integration via Octokit
  *
- * Why Octokit instead of MCP:
+ * Why Octokit:
  * - PR creation is deterministic (no AI judgment needed)
  * - Reliable error handling
  * - No external process dependencies
@@ -11,8 +11,7 @@
  * Token priority:
  * 1. GITHUB_TOKEN env var (CI/CD friendly)
  * 2. GITHUB_PERSONAL_ACCESS_TOKEN env var
- * 3. .claude/settings.local.json → githubToken
- * 4. Claude Desktop config (cross-platform)
+ * 3. .claude/settings.local.json → githubToken (local dev, gitignored)
  */
 
 import { Octokit } from '@octokit/rest';
@@ -21,7 +20,6 @@ import fs from 'fs';
 import path from 'path';
 import { fileURLToPath } from 'url';
 import logger from './logger.js';
-import { findGitHubTokenInDesktopConfig } from './mcp-setup.js';
 
 // Get package info for user agent
 const __filename = fileURLToPath(import.meta.url);
@@ -89,6 +87,89 @@ const loadLocalSettings = () => {
     return {};
 };
 
+/**
+ * Save GitHub token to .claude/settings.local.json
+ * Why: Persist token in gitignored location for local development
+ *
+ * @param {string} token - GitHub Personal Access Token
+ * @returns {Object} { success: boolean, path: string, error?: string }
+ */
+export const saveGitHubToken = (token) => {
+    try {
+        const repoRoot = getRepoRoot();
+        const claudeDir = path.join(repoRoot, '.claude');
+        const settingsPath = path.join(claudeDir, 'settings.local.json');
+
+        logger.debug('github-api - saveGitHubToken', 'Saving token', { settingsPath });
+
+        // Ensure .claude directory exists
+        if (!fs.existsSync(claudeDir)) {
+            fs.mkdirSync(claudeDir, { recursive: true });
+            logger.debug('github-api - saveGitHubToken', 'Created .claude directory');
+        }
+
+        // Load existing settings or create new
+        let settings = {};
+        if (fs.existsSync(settingsPath)) {
+            try {
+                settings = JSON.parse(fs.readFileSync(settingsPath, 'utf8'));
+            } catch (e) {
+                logger.debug('github-api - saveGitHubToken', 'Invalid existing settings, starting fresh');
+                settings = {};
+            }
+        }
+
+        // Update token
+        settings.githubToken = token;
+
+        // Add comment if new file
+        if (!settings._comment) {
+            settings._comment = 'Local settings - DO NOT COMMIT. This file is gitignored.';
+        }
+
+        // Save settings
+        fs.writeFileSync(settingsPath, JSON.stringify(settings, null, 2));
+
+        logger.debug('github-api - saveGitHubToken', 'Token saved successfully');
+
+        return { success: true, path: settingsPath };
+
+    } catch (error) {
+        logger.error('github-api - saveGitHubToken', 'Failed to save token', error);
+        return { success: false, path: null, error: error.message };
+    }
+};
+
+/**
+ * Validate GitHub token format
+ * Why: Catch obvious format errors before API call
+ *
+ * @param {string} token - Token to validate
+ * @returns {Object} { valid: boolean, warning?: string }
+ */
+export const validateTokenFormat = (token) => {
+    if (!token || token.trim() === '') {
+        return { valid: false, warning: 'Token is empty' };
+    }
+
+    const trimmed = token.trim();
+
+    // Valid prefixes for GitHub tokens
+    if (trimmed.startsWith('ghp_') || trimmed.startsWith('github_pat_')) {
+        return { valid: true };
+    }
+
+    // Older token format (40 hex chars)
+    if (/^[a-f0-9]{40}$/i.test(trimmed)) {
+        return { valid: true };
+    }
+
+    return {
+        valid: true, // Still allow, just warn
+        warning: 'Token format looks unusual (expected ghp_... or github_pat_...)'
+    };
+};
+
 /**
  * Get GitHub authentication token
  * Why: Centralized token resolution with multiple fallback sources
@@ -97,7 +178,6 @@ const loadLocalSettings = () => {
  * 1. GITHUB_TOKEN env var (standard for CI/CD)
  * 2. GITHUB_PERSONAL_ACCESS_TOKEN env var (legacy support)
  * 3. .claude/settings.local.json → githubToken (local dev, gitignored)
- * 4. Claude Desktop config (cross-platform GUI users)
  *
  * @returns {string} GitHub token
  * @throws {GitHubAPIError} If no token found
@@ -122,15 +202,6 @@ export const getGitHubToken = () => {
         return localSettings.githubToken;
     }
 
-    // Priority 4: Claude Desktop config
-    const desktopToken = findGitHubTokenInDesktopConfig();
-    if (desktopToken?.token) {
-        logger.debug('github-api - getGitHubToken', 'Using token from Claude Desktop config', {
-            configPath: desktopToken.configPath
-        });
-        return desktopToken.token;
-    }
-
     // No token found
     throw new GitHubAPIError(
         'GitHub token not found. Please configure authentication.',
@@ -139,10 +210,9 @@ export const getGitHubToken = () => {
                 searchedLocations: [
                     'GITHUB_TOKEN env var',
                     'GITHUB_PERSONAL_ACCESS_TOKEN env var',
-                    '.claude/settings.local.json → githubToken',
-                    'Claude Desktop config'
+                    '.claude/settings.local.json → githubToken'
                 ],
-                suggestion: 'Run: claude-hooks setup-github or create .claude/settings.local.json with {"githubToken": "ghp_..."}'
+                suggestion: 'Run: claude-hooks setup-github'
             }
         }
     );