@blockdeepanshu/ai-pr-review-cli 1.2.0

package/batch-review.js

@@ -0,0 +1,409 @@
+#!/usr/bin/env node
+
+/**
+ * Batch Review Script
+ * Automatically reviews large repositories in chunks to avoid rate limits
+ */
+
+const { execSync } = require('child_process');
+const fs = require('fs');
+
+async function batchReview() {
+  const isFrontend = process.argv.includes('--frontend');
+  const batchSizeArg = process.argv.indexOf('--batch-size');
+  const defaultBatchSize = batchSizeArg > -1 ? parseInt(process.argv[batchSizeArg + 1]) : 8;
+  
+  console.log('🤖 Starting Batch AI Review...\n');
+  if (isFrontend) {
+    console.log('🎨 Frontend optimization enabled');
+  }
+  console.log('DEBUG: Current directory:', process.cwd());
+  console.log('DEBUG: Default batch size:', defaultBatchSize);
+
+  try {
+    // Get all changed files (both staged and unstaged)
+    let changedFiles = [];
+    try {
+      // Try staged files first
+      const staged = execSync('git diff --name-only --cached', { encoding: 'utf-8' })
+        .split('\n')
+        .filter(f => f.trim().length > 0);
+      
+      // Try unstaged files
+      const unstaged = execSync('git diff --name-only', { encoding: 'utf-8' })
+        .split('\n')
+        .filter(f => f.trim().length > 0);
+      
+      // Combine and deduplicate
+      changedFiles = [...new Set([...staged, ...unstaged])];
+      
+      console.log('DEBUG: Staged files:', staged);
+      console.log('DEBUG: Unstaged files:', unstaged);
+    } catch (error) {
+      console.log('DEBUG: Git diff failed:', error.message);
+    }
+
+    if (changedFiles.length === 0) {
+      console.log('❌ No changes detected. Nothing to review.');
+      console.log('\n💡 To include files for review:');
+      console.log('   git add your-file.js        # Stage specific file');
+      console.log('   git add .                   # Stage all changes');
+      console.log('   git status                  # See what can be staged');
+      console.log('\n🔍 The tool reviews:');
+      console.log('   • Staged files (git add)');
+      console.log('   • Uncommitted changes');
+      console.log('   • Commits since base branch');
+      return;
+    }
+
+    console.log(`📁 Found ${changedFiles.length} changed files`);
+    console.log('Files:', changedFiles.join(', '));
+
+    // Group files by type/directory for logical batching
+    const batches = createBatches(changedFiles, defaultBatchSize, isFrontend);
+
+    console.log(`\n🔄 Creating ${batches.length} review batches...\n`);
+
+    for (let i = 0; i < batches.length; i++) {
+      const batch = batches[i];
+      console.log(`--- Batch ${i + 1}/${batches.length}: ${batch.name} ---`);
+      console.log(`Files: ${batch.files.join(', ')}`);
+
+      // Stage only these files
+      execSync('git reset'); // Clear staging area
+      batch.files.forEach(file => {
+        try {
+          execSync(`git add "${file}"`);
+        } catch (error) {
+          console.log(`⚠️  Could not add ${file}: ${error.message}`);
+        }
+      });
+
+      // Review this batch
+      try {
+        console.log('🔍 Reviewing...');
+        
+        // Check if we're in dry-run mode
+        const isDryRun = process.argv.includes('--dry-run');
+        
+        if (isDryRun) {
+          console.log('DRY RUN: Would run: node bin/cli.js review');
+          console.log('DRY RUN: Simulating AI review...\n');
+        } else {
+          // Use the local development version instead of global npm package
+          const path = require('path');
+          const cliPath = path.join(__dirname, 'bin', 'cli.js');
+          execSync(`node "${cliPath}" review`, { stdio: 'inherit' });
+        }
+      } catch (error) {
+        console.log(`❌ Review failed for batch ${i + 1}: ${error.message}`);
+        console.log('⏳ Waiting 30 seconds before continuing...\n');
+        await new Promise(resolve => setTimeout(resolve, 30000));
+      }
+
+      console.log('\n');
+
+      // Wait between batches to respect rate limits
+      if (i < batches.length - 1) {
+        console.log('⏳ Waiting 10 seconds before next batch...\n');
+        await new Promise(resolve => setTimeout(resolve, 10000));
+      }
+    }
+
+    // Reset staging area
+    execSync('git reset');
+    console.log('✅ Batch review completed!');
+    console.log('💡 Remember to stage and commit your changes after addressing feedback.');
+
+  } catch (error) {
+    console.error('❌ Batch review failed:', error.message);
+  }
+}
+
+function createBatches(files, batchSize = 8, isFrontend = false) {
+  const batches = [];
+  
+  // Filter out files we should skip entirely
+  const filteredFiles = files.filter(f => {
+    const skipPatterns = [
+      /node_modules/,
+      /\.git/,
+      /dist\//,
+      /build\//,
+      /coverage\//,
+      /\.min\.(js|css)$/,
+      /bundle.*\.js$/,
+      /chunk.*\.js$/,
+      /\.map$/,
+      /\.log$/
+    ];
+    return !skipPatterns.some(pattern => pattern.test(f));
+  });
+  
+  // Universal grouping (works for all project types)
+  let groups;
+  
+  if (isFrontend) {
+    // Frontend-specific grouping
+    groups = createFrontendGroups(filteredFiles);
+  } else {
+    // Universal grouping for all project types
+    groups = createUniversalGroups(filteredFiles);
+  }
+
+  // Create batches from groups with dynamic batch sizes
+  Object.entries(groups).forEach(([groupName, groupFiles]) => {
+    if (groupFiles.length === 0) return;
+
+    // Adjust batch size based on file type and frontend optimization
+    let dynamicBatchSize = batchSize;
+    
+    if (isFrontend) {
+      // Frontend-optimized batch sizes
+      if (groupName === 'packageLock') {
+        dynamicBatchSize = 1; // Package-lock is huge, review alone
+      } else if (groupName === 'styles') {
+        dynamicBatchSize = 15; // CSS files are usually smaller in frontend
+      } else if (groupName === 'components') {
+        dynamicBatchSize = 5; // React/Vue components can be complex
+      } else if (groupName === 'pages') {
+        dynamicBatchSize = 4; // Pages are usually larger/complex
+      } else if (groupName === 'hooks') {
+        dynamicBatchSize = 8; // Hooks are typically focused
+      } else if (groupName === 'utils') {
+        dynamicBatchSize = 10; // Utility functions are usually small
+      } else if (groupName === 'config') {
+        dynamicBatchSize = 12; // Config files are small
+      } else if (groupName === 'tests') {
+        dynamicBatchSize = 6; // Test files can be substantial
+      }
+    } else {
+      // Universal batch sizes for all project types
+      if (groupName === 'lockFiles') {
+        dynamicBatchSize = 1; // Lock files are huge, review alone
+      } else if (groupName === 'api') {
+        dynamicBatchSize = 6; // API endpoints can be complex
+      } else if (groupName === 'services') {
+        dynamicBatchSize = 5; // Services contain business logic
+      } else if (groupName === 'models') {
+        dynamicBatchSize = 8; // Models are usually focused
+      } else if (groupName === 'frontend') {
+        dynamicBatchSize = 6; // Frontend components in full-stack
+      } else if (groupName === 'utils') {
+        dynamicBatchSize = 10; // Utility functions are usually small
+      } else if (groupName === 'tests') {
+        dynamicBatchSize = 8; // Test files vary in size
+      } else if (groupName === 'config') {
+        dynamicBatchSize = 12; // Config files are typically small
+      } else if (groupName === 'infrastructure') {
+        dynamicBatchSize = 7; // Infrastructure files can be complex
+      } else if (groupName === 'scripts') {
+        dynamicBatchSize = 10; // Scripts are usually focused
+      } else if (groupName === 'docs') {
+        dynamicBatchSize = 15; // Documentation files are usually text
+      } else if (groupName === 'styles') {
+        dynamicBatchSize = 12; // CSS files
+      }
+    }
+
+    // Split large groups into smaller batches
+    for (let i = 0; i < groupFiles.length; i += dynamicBatchSize) {
+      const batchFiles = groupFiles.slice(i, i + dynamicBatchSize);
+      const batchNumber = Math.floor(i / dynamicBatchSize) + 1;
+      const name = groupFiles.length > dynamicBatchSize 
+        ? `${groupName} (batch ${batchNumber})`
+        : groupName;
+      
+      batches.push({
+        name,
+        files: batchFiles
+      });
+    }
+  });
+
+  // Sort batches by priority (most important first)
+  const priorityOrder = isFrontend ? [
+    'components', 'pages', 'hooks', 'utils', 'config', 
+    'styles', 'tests', 'assets', 'packageLock', 'docs', 'other'
+  ] : [
+    'api', 'services', 'models', 'frontend', 'utils', 'config',
+    'tests', 'infrastructure', 'scripts', 'styles', 'lockFiles', 'docs', 'other'
+  ];
+  
+  batches.sort((a, b) => {
+    const aPriority = priorityOrder.findIndex(p => a.name.includes(p));
+    const bPriority = priorityOrder.findIndex(p => b.name.includes(p));
+    return aPriority - bPriority;
+  });
+
+  return batches;
+}
+
+function createFrontendGroups(filteredFiles) {
+  return {
+    components: filteredFiles.filter(f => 
+      /\.(js|jsx|ts|tsx|vue)$/.test(f) && 
+      /\/(components|ui|widgets)\//.test(f)
+    ),
+    pages: filteredFiles.filter(f => 
+      /\.(js|jsx|ts|tsx|vue)$/.test(f) && 
+      /\/(pages|views|screens|routes)\//.test(f)
+    ),
+    hooks: filteredFiles.filter(f => 
+      /\.(js|jsx|ts|tsx)$/.test(f) && 
+      /\/(hooks|composables|custom)\//.test(f)
+    ),
+    utils: filteredFiles.filter(f => 
+      /\.(js|jsx|ts|tsx)$/.test(f) && 
+      /\/(utils|helpers|lib|shared)\//.test(f)
+    ),
+    styles: filteredFiles.filter(f => 
+      /\.(css|scss|sass|less|stylus|module\.css)$/.test(f)
+    ),
+    config: filteredFiles.filter(f => {
+      // Split package.json separately due to size
+      if (f.includes('package-lock.json')) return false;
+      return /\.(json|yml|yaml|toml|js|ts)$/.test(f) && 
+             /(config|settings|env|webpack|vite|rollup|babel)/.test(f);
+    }),
+    packageLock: filteredFiles.filter(f => f.includes('package-lock.json')),
+    tests: filteredFiles.filter(f => 
+      /\.(test|spec)\.(js|ts|jsx|tsx)$/.test(f) ||
+      /\/__tests__\//.test(f)
+    ),
+    docs: filteredFiles.filter(f => /\.(md|txt|rst)$/.test(f)),
+    assets: filteredFiles.filter(f => 
+      /\/(assets|static|public)\/.*\.(js|ts|jsx|tsx|css|scss)$/.test(f)
+    ),
+    other: filteredFiles.filter(f => {
+      const assigned = [
+        /(components|ui|widgets|pages|views|screens|routes|hooks|composables|custom|utils|helpers|lib|shared)\//,
+        /\.(css|scss|sass|less|stylus|module\.css)$/,
+        /(config|settings|env|webpack|vite|rollup|babel)/,
+        /package-lock\.json/,
+        /\.(test|spec)\.(js|ts|jsx|tsx)$/,
+        /\/__tests__\//,
+        /\.(md|txt|rst)$/,
+        /\/(assets|static|public)\/.*\.(js|ts|jsx|tsx|css|scss)$/
+      ];
+      return !assigned.some(pattern => pattern.test(f));
+    })
+  };
+  
+  return groups;
+}
+
+function createUniversalGroups(filteredFiles) {
+  return {
+    // Backend/API files
+    api: filteredFiles.filter(f => 
+      /\.(js|ts|py|java|go|rb|php|cs)$/.test(f) && 
+      /\/(api|routes|controllers|endpoints|handlers)\//.test(f)
+    ),
+    
+    // Services and business logic
+    services: filteredFiles.filter(f => 
+      /\.(js|ts|py|java|go|rb|php|cs)$/.test(f) && 
+      /\/(services|business|logic|core|domain)\//.test(f)
+    ),
+    
+    // Models and database
+    models: filteredFiles.filter(f => 
+      /\.(js|ts|py|java|go|rb|php|cs|sql)$/.test(f) && 
+      /\/(models|entities|schemas|database|db|migrations)\//.test(f)
+    ),
+    
+    // Frontend components (for full-stack projects)
+    frontend: filteredFiles.filter(f => 
+      /\.(js|jsx|ts|tsx|vue)$/.test(f) && 
+      /\/(components|pages|views|screens|ui)\//.test(f)
+    ),
+    
+    // Utilities and helpers
+    utils: filteredFiles.filter(f => 
+      /\.(js|ts|py|java|go|rb|php|cs)$/.test(f) && 
+      /\/(utils|helpers|lib|shared|common)\//.test(f)
+    ),
+    
+    // Tests
+    tests: filteredFiles.filter(f => 
+      /\.(test|spec)\.(js|ts|py|java|go|rb|php|cs)$/.test(f) ||
+      /\/(tests?|__tests__|spec)\//.test(f) ||
+      /test_.*\.py$/.test(f)
+    ),
+    
+    // Configuration files
+    config: filteredFiles.filter(f => {
+      if (f.includes('package-lock.json') || f.includes('yarn.lock') || f.includes('poetry.lock')) return false;
+      return /\.(json|yml|yaml|toml|ini|cfg|conf|properties|xml)$/.test(f) ||
+             /(config|settings|env)/.test(f);
+    }),
+    
+    // Lock files (handled separately due to size)
+    lockFiles: filteredFiles.filter(f => 
+      /\.(lock|lock\.json)$/.test(f) ||
+      f.includes('package-lock.json') ||
+      f.includes('yarn.lock') ||
+      f.includes('poetry.lock') ||
+      f.includes('Gemfile.lock')
+    ),
+    
+    // Infrastructure and DevOps
+    infrastructure: filteredFiles.filter(f => 
+      /\.(tf|yml|yaml)$/.test(f) && /(terraform|ansible|kubernetes|docker|k8s)/.test(f) ||
+      /Dockerfile|docker-compose|\.tf$/.test(f)
+    ),
+    
+    // Scripts and automation
+    scripts: filteredFiles.filter(f => 
+      /\.(sh|bash|ps1|py|rb|js)$/.test(f) && 
+      /\/(scripts|bin|tools|automation)\//.test(f) ||
+      /Makefile|Rakefile/.test(f)
+    ),
+    
+    // Documentation
+    docs: filteredFiles.filter(f => 
+      /\.(md|txt|rst|adoc|tex)$/.test(f) ||
+      /\/(docs|documentation)\//.test(f) ||
+      /README|CHANGELOG|LICENSE/.test(f)
+    ),
+    
+    // Styles (for any project with styling)
+    styles: filteredFiles.filter(f => 
+      /\.(css|scss|sass|less|stylus)$/.test(f)
+    ),
+    
+    // Other files
+    other: filteredFiles.filter(f => {
+      const assigned = [
+        /\/(api|routes|controllers|endpoints|handlers)\//,
+        /\/(services|business|logic|core|domain)\//,
+        /\/(models|entities|schemas|database|db|migrations)\//,
+        /\/(components|pages|views|screens|ui)\//,
+        /\/(utils|helpers|lib|shared|common)\//,
+        /\.(test|spec)\.(js|ts|py|java|go|rb|php|cs)$/,
+        /\/(tests?|__tests__|spec)\//,
+        /test_.*\.py$/,
+        /\.(json|yml|yaml|toml|ini|cfg|conf|properties|xml)$/,
+        /\.(lock|lock\.json)$/,
+        /package-lock\.json|yarn\.lock|poetry\.lock|Gemfile\.lock/,
+        /\.(tf|yml|yaml).*terraform|ansible|kubernetes|docker|k8s/,
+        /Dockerfile|docker-compose|\.tf$/,
+        /\.(sh|bash|ps1|py|rb|js).*\/(scripts|bin|tools|automation)\//,
+        /Makefile|Rakefile/,
+        /\.(md|txt|rst|adoc|tex)$/,
+        /\/(docs|documentation)\//,
+        /README|CHANGELOG|LICENSE/,
+        /\.(css|scss|sass|less|stylus)$/
+      ];
+      return !assigned.some(pattern => pattern.test(f));
+    })
+  };
+  
+  return groups;
+}
+
+// Run the batch review
+batchReview().catch(console.error);
+
+

package/bin/cli.js

@@ -0,0 +1,113 @@
+#!/usr/bin/env node
+
+const { Command } = require("commander");
+const review = require("../src/reviewer");
+const { createGlobalConfig } = require("../src/config");
+
+const program = new Command();
+
+program
+  .name("ai-pr-review")
+  .description("🤖 AI-powered Pull Request reviewer")
+  .version("1.0.0");
+
+program
+  .command("review")
+  .description("🔍 Review current branch changes with AI")
+  .option("-b, --base <branch>", "Base branch to compare against (e.g., main, origin/main, develop)")
+  .option("-m, --model <model>", "AI model to use (default: gpt-4o-mini)")
+  .option("--provider <provider>", "AI provider (default: openai)")
+  .option("-v, --verbose", "Show detailed output")
+  .action(async (options) => {
+    // Show a nice header
+    const { default: chalk } = await import("chalk");
+    console.log(chalk.blue.bold("\n🤖 AI PR Review"));
+    console.log(chalk.gray("━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\n"));
+    
+    await review(options);
+  });
+
+program
+  .command("config")
+  .description("⚙️  Set up global configuration")
+  .option("-m, --model <model>", "Default AI model to use")
+  .option("-b, --base <branch>", "Default base branch")
+  .option("--provider <provider>", "Default AI provider")
+  .action(async (options) => {
+    const { default: chalk } = await import("chalk");
+    
+    if (Object.keys(options).length === 0) {
+      console.log(chalk.yellow("Please specify configuration options:"));
+      console.log(chalk.gray("  ai-pr-review config --model gpt-4o-mini --base main"));
+      console.log(chalk.gray("  ai-pr-review config --provider openai"));
+      return;
+    }
+
+    try {
+      const configPath = createGlobalConfig(options);
+      console.log(chalk.green("✅ Global configuration saved!"));
+      console.log(chalk.gray(`   Config file: ${configPath}`));
+      
+      if (options.model) console.log(chalk.blue(`   Default model: ${options.model}`));
+      if (options.provider) console.log(chalk.blue(`   Default provider: ${options.provider}`));
+      if (options.base) console.log(chalk.blue(`   Default base branch: ${options.base}`));
+    } catch (error) {
+      console.error(chalk.red(`❌ Failed to save configuration: ${error.message}`));
+    }
+  });
+
+program
+  .command("batch")
+  .description("🔄 Review large repositories in batches to avoid rate limits")
+  .option("--dry-run", "Show what would be reviewed without actually running AI review")
+  .option("--frontend", "Optimize batching for frontend projects (React, Vue, Angular)")
+  .option("--batch-size <number>", "Number of files per batch (default: 8)", "8")
+  .action(async (options) => {
+    const { default: chalk } = await import("chalk");
+    console.log(chalk.blue.bold("\n🔄 Batch AI Review"));
+    console.log(chalk.gray("━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\n"));
+    
+    try {
+      const { spawn } = require('child_process');
+      const path = require('path');
+      const batchScriptPath = path.join(__dirname, '..', 'batch-review.js');
+      
+      const args = [batchScriptPath];
+      if (options.dryRun) {
+        args.push('--dry-run');
+      }
+      if (options.frontend) {
+        args.push('--frontend');
+      }
+      if (options.batchSize) {
+        args.push('--batch-size', options.batchSize);
+      }
+      
+      const child = spawn('node', args, { stdio: 'inherit' });
+      child.on('close', (code) => {
+        if (code !== 0) {
+          console.error(chalk.red(`\n❌ Batch review exited with code ${code}`));
+        }
+      });
+    } catch (error) {
+      console.error(chalk.red(`❌ Failed to run batch review: ${error.message}`));
+    }
+  });
+
+// Also support direct usage without subcommand
+program
+  .option("-b, --base <branch>", "Base branch to compare against")
+  .option("-m, --model <model>", "AI model to use")
+  .option("--provider <provider>", "AI provider")  
+  .option("-v, --verbose", "Show detailed output")
+  .action(async (options) => {
+    // If no specific command was run, default to review
+    if (process.argv.length > 2 && !process.argv.includes('review')) {
+      const { default: chalk } = await import("chalk");
+      console.log(chalk.blue.bold("\n🤖 AI PR Review"));
+      console.log(chalk.gray("━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\n"));
+      await review(options);
+    }
+  });
+
+program.parse();

package/package.json

@@ -0,0 +1,72 @@
+{
+  "name": "@blockdeepanshu/ai-pr-review-cli",
+  "version": "1.2.0",
+  "description": "🤖 AI-powered Pull Request reviewer - Get instant feedback on your code changes using GPT",
+  "main": "src/reviewer.js",
+  "bin": {
+    "ai-pr-review": "./bin/cli.js",
+    "aipr": "./bin/cli.js"
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "type": "commonjs",
+  "engines": {
+    "node": ">=16.0.0"
+  },
+  "scripts": {
+    "start": "node bin/cli.js",
+    "batch-review": "node batch-review.js",
+    "test": "echo \"Error: no test specified\" && exit 1",
+    "prepublishOnly": "echo 'Ready to publish!'"
+  },
+  "keywords": [
+    "ai",
+    "artificial-intelligence", 
+    "pr-review",
+    "pull-request",
+    "code-review",
+    "cli",
+    "git",
+    "github",
+    "openai",
+    "gpt",
+    "developer-tools",
+    "automation"
+  ],
+  "author": {
+    "name": "Deepanshu Chauhan",
+    "email": "chauhandeepanshu336@gmail.com"
+  },
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/blockDeepanshu/ai-pr-review.git"
+  },
+  "bugs": {
+    "url": "https://github.com/blockDeepanshu/ai-pr-review/issues"
+  },
+  "homepage": "https://github.com/blockDeepanshu/ai-pr-review#readme",
+  "files": [
+    "bin/",
+    "src/",
+    "batch-review.js",
+    "README.md",
+    "CHANGELOG.md",
+    "LICENSE"
+  ],
+  "preferGlobal": true,
+  "dependencies": {
+    "axios": "^1.6.0",
+    "chalk": "^5.3.0",
+    "commander": "^11.0.0",
+    "dotenv": "^17.3.1",
+    "ora": "^6.3.1",
+    "simple-git": "^3.19.1"
+  },
+  "devDependencies": {},
+  "funding": {
+    "type": "individual",
+    "url": "https://github.com/blockDeepanshu"
+  }
+}

package/src/ai.js

@@ -0,0 +1,38 @@
+const axios = require("axios");
+require("dotenv").config();
+async function openai(prompt, model) {
+  try {
+    const res = await axios.post(
+      "https://api.openai.com/v1/chat/completions",
+      {
+        model,
+        messages: [{ role: "user", content: prompt }],
+        temperature: 0.2,
+      },
+      {
+        headers: {
+          Authorization: `Bearer ${process.env.OPENAI_API_KEY}`,
+        },
+      },
+    );
+
+    return res.data.choices[0].message.content;
+  } catch (error) {
+    if (error.response?.status === 429) {
+      const resetTime = error.response.headers['x-ratelimit-reset-requests'] || 'unknown';
+      throw new Error(`Rate limit exceeded. Please wait and try again. Reset time: ${resetTime}. Consider upgrading your OpenAI plan for higher limits.`);
+    } else if (error.response?.status === 401) {
+      throw new Error('Invalid OpenAI API key. Please check your OPENAI_API_KEY environment variable.');
+    } else if (error.response?.status === 403) {
+      throw new Error('OpenAI API access denied. Check your API key permissions.');
+    } else {
+      throw new Error(`OpenAI API error: ${error.response?.data?.error?.message || error.message}`);
+    }
+  }
+}
+
+async function runAI(prompt, config) {
+  return openai(prompt, config.model);
+}
+
+module.exports = { runAI };

package/src/config.js

@@ -0,0 +1,52 @@
+const fs = require("fs");
+const path = require("path");
+const os = require("os");
+
+function getConfig() {
+  // Default configuration
+  const defaultConfig = {
+    provider: "openai",
+    model: "gpt-4o-mini",
+    baseBranch: null, // Will be auto-detected
+  };
+
+  // Try to load global config from user's home directory
+  const globalConfigPath = path.join(os.homedir(), ".aiprconfig.json");
+  let config = { ...defaultConfig };
+
+  if (fs.existsSync(globalConfigPath)) {
+    try {
+      const globalConfig = JSON.parse(fs.readFileSync(globalConfigPath, "utf-8"));
+      config = { ...config, ...globalConfig };
+    } catch (error) {
+      console.warn("Warning: Could not parse global config file:", globalConfigPath);
+    }
+  }
+
+  // Try to load local project config (overrides global)
+  const localConfigPath = path.join(process.cwd(), ".aiprconfig.json");
+  if (fs.existsSync(localConfigPath)) {
+    try {
+      const localConfig = JSON.parse(fs.readFileSync(localConfigPath, "utf-8"));
+      config = { ...config, ...localConfig };
+    } catch (error) {
+      console.warn("Warning: Could not parse local config file:", localConfigPath);
+    }
+  }
+
+  return config;
+}
+
+function createGlobalConfig(options) {
+  const globalConfigPath = path.join(os.homedir(), ".aiprconfig.json");
+  const config = {
+    provider: options.provider || "openai",
+    model: options.model || "gpt-4o-mini",
+    ...(options.baseBranch && { baseBranch: options.baseBranch })
+  };
+  
+  fs.writeFileSync(globalConfigPath, JSON.stringify(config, null, 2));
+  return globalConfigPath;
+}
+
+module.exports = { getConfig, createGlobalConfig };