claude-git-hooks 2.4.0 → 2.5.0

package/bin/claude-hooks

@@ -12,6 +12,11 @@ import { executeClaude, extractJSON } from '../lib/utils/claude-client.js';
 import { loadPrompt } from '../lib/utils/prompt-builder.js';
 import { listPresets } from '../lib/utils/preset-loader.js';
 import { getConfig } from '../lib/config.js';
+import { getOrPromptTaskId, formatWithTaskId } from '../lib/utils/task-id.js';
+import { createPullRequest, getReviewersForFiles, parseGitHubRepo, setupGitHubMcp, getGitHubMcpStatus } from '../lib/utils/github-client.js';
+import { showPRPreview, promptConfirmation, promptMenu, showSuccess, showError, showInfo, showWarning, showSpinner, promptEditField } from '../lib/utils/interactive-ui.js';
+import { setupGitHubMCP } from '../lib/utils/mcp-setup.js';
+import logger from '../lib/utils/logger.js';
 
 // Why: ES6 modules don't have __dirname, need to recreate it
 const __filename = fileURLToPath(import.meta.url);
@@ -452,6 +457,17 @@ async function install(args) {
     warning('config.json not found - using defaults');
   }
 
+  // Create settings.local.json for sensitive data (gitignored)
+  const settingsLocalPath = path.join(claudeDir, 'settings.local.json');
+  if (!fs.existsSync(settingsLocalPath)) {
+    const settingsLocalContent = {
+      "_comment": "Local settings - DO NOT COMMIT. This file is gitignored.",
+      "githubToken": ""
+    };
+    fs.writeFileSync(settingsLocalPath, JSON.stringify(settingsLocalContent, null, 2));
+    info('settings.local.json created (add your GitHub token here)');
+  }
+
   // Configure Git
   configureGit();
 
@@ -469,10 +485,14 @@ async function install(args) {
   console.log('  🎯 Use presets: backend, frontend, fullstack, database, ai, default');
   console.log('  🚀 Enable parallel analysis: set subagents.enabled = true');
   console.log('  🐛 Enable debug mode: claude-hooks --debug true');
+  console.log('\n🔗 GitHub PR Creation (v2.5.0+):');
+  console.log('  claude-hooks setup-github    # Configure GitHub token for create-pr');
+  console.log('  claude-hooks create-pr main  # Create PR with auto-generated metadata');
   console.log('\n📖 Example config.json:');
   console.log('  {');
   console.log('    "preset": "backend",');
-  console.log('    "subagents": { "enabled": true, "model": "haiku", "batchSize": 3 }');
+  console.log('    "subagents": { "enabled": true, "model": "haiku", "batchSize": 3 },');
+  console.log('    "github": { "pr": { "reviewers": ["your-username"] } }');
   console.log('  }');
   console.log('\nFor more options: claude-hooks --help');
 }
@@ -509,14 +529,12 @@ async function checkAndInstallDependencies(sudoPassword = null, skipAuth = false
 
   // v2.0.0+: Unix tools (sed, awk, grep, etc.) no longer needed (pure Node.js implementation)
 
-  // Check and install Claude CLI
-  await checkAndInstallClaude();
-
-  // Check Claude authentication (if not skipped)
+  // Check and install Claude CLI (skip if --skip-auth)
   if (!skipAuth) {
+    await checkAndInstallClaude();
     await checkClaudeAuth();
   } else {
-    warning('Skipping Claude authentication verification (--skip-auth)');
+    warning('Skipping Claude CLI verification and authentication (--skip-auth)');
   }
 
   // Clear password from memory
@@ -530,9 +548,19 @@ function isWindows() {
 }
 
 // Get Claude command based on platform
-// Why: On Windows, Claude CLI runs in WSL, so we need 'wsl claude'
+// Why: On Windows, try native Claude first, then WSL as fallback
 function getClaudeCommand() {
-  return isWindows() ? 'wsl claude' : 'claude';
+  if (isWindows()) {
+    // Try native Windows Claude first
+    try {
+      execSync('claude --version', { stdio: 'ignore', timeout: 3000 });
+      return 'claude';
+    } catch (e) {
+      // Fallback to WSL
+      return 'wsl claude';
+    }
+  }
+  return 'claude';
 }
 
 // Check if we need to install dependencies
@@ -629,7 +657,7 @@ function updateGitignore() {
 
   const gitignorePath = '.gitignore';
   const claudeEntries = [
-    '# Claude Git Hooks',
+    '# Claude Git Hooks (includes .claude/settings.local.json for tokens)',
     '.claude/',
   ];
 
@@ -1017,6 +1045,392 @@ async function analyzeDiff(args) {
   }
 }
 
+// Create PR command (v2.5.0+ - Octokit-based)
+async function createPr(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('../lib/utils/github-api.js');
+    const { parseGitHubRepo } = await import('../lib/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 });
+    const response = await executeClaude(prompt, { timeout: 180000 });
+    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);
+  }
+}
+
+// Setup GitHub authentication
+async function setupGitHub() {
+  const { validateToken } = await import('../lib/utils/github-api.js');
+
+  console.log('');
+  info('GitHub Authentication Setup');
+  console.log('');
+
+  // Check existing token
+  try {
+    const validation = await validateToken();
+    if (validation.valid) {
+      success(`Already authenticated as: ${validation.user}`);
+      console.log(`  Scopes: ${validation.scopes.join(', ')}`);
+
+      if (!validation.hasRepoScope) {
+        warning('Token lacks "repo" scope - PR creation may fail');
+      }
+
+      console.log('');
+      info('To use a different token, edit .claude/settings.local.json');
+      return;
+    }
+  } catch (e) {
+    // No token configured, continue with setup
+  }
+
+  console.log('No GitHub token found. You have several options:');
+  console.log('');
+  console.log('Option 1: Create .claude/settings.local.json');
+  console.log('  {');
+  console.log('    "githubToken": "ghp_your_token_here"');
+  console.log('  }');
+  console.log('');
+  console.log('Option 2: Set environment variable');
+  console.log('  export GITHUB_TOKEN="ghp_your_token_here"');
+  console.log('');
+  console.log('Option 3: Run setup-mcp (if you also want MCP features)');
+  console.log('  claude-hooks setup-mcp');
+  console.log('');
+  console.log('To create a token:');
+  console.log('  1. Go to https://github.com/settings/tokens/new');
+  console.log('  2. Select scopes: repo, read:org');
+  console.log('  3. Generate and copy the token');
+  console.log('');
+}
+
 // Comando status
 function status() {
   if (!checkGitRepo()) {
@@ -1165,6 +1579,8 @@ Commands:
   disable [hook]       Disable hooks (all or one specific)
   status               Show the status of hooks
   analyze-diff [base]  Analyze differences between branches and generate PR info
+  create-pr [base]     Create pull request with auto-generated metadata and reviewers
+  setup-github         Setup GitHub login (required for create-pr)
   presets              List all available presets
   --set-preset <name>  Set the active preset
   preset current       Show the current active preset
@@ -1184,6 +1600,9 @@ Examples:
   claude-hooks enable               # Enable all hooks
   claude-hooks status               # View current status
   claude-hooks analyze-diff main    # Analyze differences with main
+  claude-hooks setup-github         # Configure GitHub authentication for PR creation
+  claude-hooks setup-mcp            # Setup GitHub MCP (one-time setup)
+  claude-hooks create-pr develop    # Create PR targeting develop branch
   claude-hooks presets              # List available presets
   claude-hooks --set-preset backend # Set backend preset
   claude-hooks preset current       # Show current preset
@@ -1202,6 +1621,20 @@ Analyze-diff use case:
     → PR Description: "## Summary\n- Added JWT authentication..."
     → Suggested branch: "feature/user-authentication"
 
+Create-pr use case (v2.5.0+):
+  claude-hooks create-pr develop    # Create PR targeting develop:
+    → Validates GitHub token
+    → Extracts task-id from branch (IX-123, #456, LIN-123)
+    → Analyzes diff and generates PR metadata with Claude
+    → Creates PR directly via GitHub API (Octokit)
+    → Adds labels based on preset
+    → Returns PR URL
+
+  Token configuration:
+    → .claude/settings.local.json (recommended, gitignored)
+    → GITHUB_TOKEN environment variable
+    → Claude Desktop config (auto-detected)
+
 Presets (v2.3.0+):
   Built-in tech-stack specific configurations:
   - backend: Spring Boot + SQL Server (.java, .xml, .yml)
@@ -1310,7 +1743,7 @@ async function updateConfig(propertyPath, value, options = {}) {
     fs.writeFileSync(configPath, JSON.stringify(config, null, 2));
 
     // Show success message
-    const message = successMessage ? successMessage(value) : 'Configuration updated';
+    const message = successMessage ? await successMessage(value) : 'Configuration updated';
     success(message);
     info(`Configuration saved to ${configPath}`);
   } catch (err) {
@@ -1472,6 +1905,15 @@ async function main() {
     case 'analyze-diff':
       await analyzeDiff(args.slice(1));
       break;
+    case 'create-pr':
+      await createPr(args.slice(1));
+      break;
+    case 'setup-mcp':
+      await setupGitHubMCP();
+      break;
+    case 'setup-github':
+      await setupGitHub();
+      break;
     case 'presets':
       await showPresets();
       break;

package/lib/config.js

@@ -38,6 +38,11 @@ const defaults = {
     commitMessage: {
         autoKeyword: 'auto',               // Keyword to trigger auto-generation
         timeout: 300000,
+        // Task-ID detection pattern (from branch name)
+        // Default: 1-3 uppercase letters + separator + 3-5 digits
+        // Examples: "ABC-12345", "IX-123", "DE 4567"
+        // Regex is case-insensitive and extracted from branch name
+        taskIdPattern: '([A-Z]{1,3}[-\\s]\\d{3,5})'
     },
 
     // Subagent configuration (parallel analysis)
@@ -56,6 +61,7 @@ const defaults = {
         analyzeDiff: 'ANALYZE_DIFF.md',                       // PR analysis prompt
         resolution: 'CLAUDE_RESOLUTION_PROMPT.md',            // Issue resolution prompt
         subagentInstruction: 'SUBAGENT_INSTRUCTION.md',       // Parallel analysis instruction
+        createGithubPR: 'CREATE_GITHUB_PR.md',                // GitHub PR creation via MCP
     },
 
     // Output file paths (relative to repo root)
@@ -76,6 +82,29 @@ const defaults = {
     git: {
         diffFilter: 'ACM',                 // Added, Copied, Modified (excludes Deleted)
     },
+
+    // GitHub integration (v2.5.0+)
+    github: {
+        enabled: true,                     // Changed from false - enable by default since Octokit works without MCP
+
+        // Pull Request configuration
+        pr: {
+            defaultBase: 'develop',        // Default base branch for PRs
+
+            // Reviewers (usernames without @)
+            reviewers: [],                 // Example: ["juan.perez", "maria.garcia"]
+
+            // Labels by preset
+            labelRules: {
+                backend: ['backend', 'java'],
+                frontend: ['frontend', 'react'],
+                fullstack: ['fullstack'],
+                database: ['database', 'sql'],
+                ai: ['ai', 'tooling'],
+                default: []
+            },
+        },
+    },
 };
 
 /**

package/lib/hooks/pre-commit.js

@@ -27,8 +27,6 @@ import {
 } from '../utils/git-operations.js';
 import {
     filterFiles,
-    filterSkipAnalysis,
-    readFile
 } from '../utils/file-operations.js';
 import { analyzeCode, analyzeCodeParallel, chunkArray } from '../utils/claude-client.js';
 import { buildAnalysisPrompt } from '../utils/prompt-builder.js';
@@ -282,6 +280,8 @@ const main = async () => {
             logger.warning('Consider splitting the commit into smaller parts');
             process.exit(0);
         }
+        
+        logger.info("test log");
 
         // Step 3: Build file data for prompt
         logger.debug('pre-commit - main', 'Building file data for analysis');
@@ -290,9 +290,6 @@ const main = async () => {
                 // Get diff
                 let diff = getFileDiff(filePath);
 
-                // Apply SKIP_ANALYSIS filtering
-                diff = filterSkipAnalysis(diff);
-
                 // Check if new file
                 const isNew = isNewFile(filePath);
 
@@ -300,7 +297,6 @@ const main = async () => {
                 let content = null;
                 if (isNew) {
                     content = await getFileContentFromStaging(filePath);
-                    content = filterSkipAnalysis(content);
                 }
 
                 return {