codeflow-hook 1.1.0 → 1.3.0

package/bin/codeflow-hook.js

@@ -6,8 +6,13 @@ import ora from 'ora';
 import axios from 'axios';
 import fs from 'fs';
 import path from 'path';
-import { execSync } from 'child_process';
+import os from 'os'; // Make sure os is imported
 import readline from 'readline';
+import { indexProject } from './rag.js';
+import { orchestrateReview } from './agents.js';
+
+// Export for use in agents module
+export { callAIProvider };
 
 const program = new Command();
 
@@ -25,94 +30,168 @@ program
   .option('-u, --url <url>', 'Custom API URL (optional)')
   .option('-m, --model <model>', 'AI model name (optional - uses provider default)')
   .action(async (options) => {
-    const configDir = path.join(process.env.HOME, '.codeflow-hook');
+    // Use USERPROFILE on Windows instead of HOME which might be undefined
+    const homeDir = process.env.HOME || process.env.USERPROFILE;
+    const configDir = path.join(homeDir, '.codeflow-hook');
     if (!fs.existsSync(configDir)) {
       fs.mkdirSync(configDir, { recursive: true });
     }
 
     const configPath = path.join(configDir, 'config.json');
+
+    // Configuration cascade: Check for project-level config first, then fall back to global
+    const projectConfigPath = path.join(process.cwd(), '.codeflowrc.json');
+    const projectConfig = fs.existsSync(projectConfigPath) ? JSON.parse(fs.readFileSync(projectConfigPath, 'utf8')) : {};
+
     const existingConfig = fs.existsSync(configPath) ? JSON.parse(fs.readFileSync(configPath, 'utf8')) : {};
 
-    // Initialize config with existing values, then override with CLI options
+    // Show config cascade message
+    if (Object.keys(projectConfig).length > 0) {
+      console.log(chalk.blue('📁 Using configuration cascade (project → global):'));
+      console.log(chalk.gray(`   Project config: ${projectConfigPath}`));
+      if (fs.existsSync(configPath)) {
+        console.log(chalk.gray(`   Global config: ${configPath}`));
+      }
+    }
+
+    // Determine what the new provider and API key should be
+    const requestedProvider = (options.provider || existingConfig.provider || 'gemini').toLowerCase();
+    const requestedApiKey = options.key || existingConfig.apiKey;
+
+    // FIX: Explicit boolean coercion to prevent || operator from returning non-boolean values
+    // Step by step to ensure proper boolean evaluation
+    const hasNewKey = !!options.key;
+    const isFirstTimeSetup = !existingConfig.provider && !existingConfig.apiKey;
+    const shouldValidate = hasNewKey || isFirstTimeSetup;
+
+    console.log('VALIDATION DEBUG - provider:', requestedProvider, 'key_exists:', !!options.key, 'shouldValidate:', shouldValidate);
+
+    if (shouldValidate && requestedApiKey) {
+      console.log(chalk.blue('🔐 Validating API key for provider:', requestedProvider));
+      const validationSpinner = ora('Checking key permissions...').start();
+
+      try {
+        await validateApiKey(requestedProvider, requestedApiKey);
+        validationSpinner.succeed('API key validated');
+      } catch (error) {
+        validationSpinner.fail('Validation failed');
+        console.error(chalk.red(`❌ ${error.message}`));
+        console.error(chalk.red(`💡 Make sure you're using a valid ${requestedProvider.toUpperCase()} API key for the ${requestedProvider} provider.`));
+        process.exit(1);
+      }
+    } else {
+      console.log(chalk.yellow('⚠️ Validation skipped - no API key validation needed'));
+    }
+
+    // Initialize config with existing values, then override with verified CLI options
     const config = {
-      provider: options.provider || existingConfig.provider || 'gemini',
-      apiKey: options.key || existingConfig.apiKey,
+      provider: requestedProvider,
+      apiKey: requestedApiKey,
       apiUrl: options.url || existingConfig.apiUrl,
       model: options.model || existingConfig.model
     };
 
-    // Set default API URL and model if not provided by options or existing config
+    // Interactive model selection if model is not explicitly provided
+    if (!options.model) {
+      // FIX: More robust logic for when to fetch new models
+      const isNewProvider = existingConfig.provider && (existingConfig.provider.toLowerCase() !== config.provider.toLowerCase());
+      const hasNewKey = !!options.key;
+
+      const shouldFetchModels = !existingConfig.model || isNewProvider || hasNewKey;
+
+      if (shouldFetchModels) {
+        console.log(chalk.blue('🔍 Fetching available models...'));
+
+        const modelSpinner = ora('Contacting API...').start();
+        try {
+          const models = await fetchModels(config.provider, config.apiKey);
+          modelSpinner.succeed('Models fetched successfully');
+
+          console.log(chalk.blue('Available models:'));
+          models.forEach((model, index) => {
+            console.log(chalk.gray(`  ${index + 1}. ${model}`));
+          });
+
+          const rl = readline.createInterface({
+            input: process.stdin,
+            output: process.stdout
+          });
+
+          const selectedModel = await new Promise(resolve => {
+            rl.question(chalk.blue(`Enter the model name (or number): `), (input) => {
+              rl.close();
+              resolve(input.trim());
+            });
+          });
+
+          // Check if user entered a number
+          const index = parseInt(selectedModel) - 1;
+          if (!isNaN(index) && index >= 0 && index < models.length) {
+            config.model = models[index];
+          } else {
+            config.model = selectedModel;
+          }
+
+          console.log(chalk.green(`✓ Selected model: ${config.model}`));
+
+        } catch (error) {
+          modelSpinner.fail('Failed to fetch models');
+          console.error(chalk.red(`❌ API Error: ${error.message}`));
+          // Fallback to hardcoded list if API call fails
+          const fallbackModels = getFallbackModels(config.provider);
+
+          console.log(chalk.yellow('⚠️ Using fallback model list:'));
+          fallbackModels.forEach((model, index) => {
+            console.log(chalk.gray(`  ${index + 1}. ${model}`));
+          });
+
+          const rl = readline.createInterface({
+            input: process.stdin,
+            output: process.stdout
+          });
+
+          const selectedModel = await new Promise(resolve => {
+            rl.question(chalk.blue(`Select a model (name or number): `), (input) => {
+              rl.close();
+              resolve(input.trim());
+            });
+          });
+
+          const index = parseInt(selectedModel) - 1;
+          if (!isNaN(index) && index >= 0 && index < fallbackModels.length) {
+            config.model = fallbackModels[index];
+          } else {
+            config.model = selectedModel;
+          }
+
+          console.log(chalk.green(`✓ Selected fallback model: ${config.model}`));
+        }
+      } else {
+        // Reuse existing model and config
+        console.log(chalk.blue(`📚 Using existing configuration (provider: ${existingConfig.provider}, model: ${existingConfig.model})`));
+      }
+    } else {
+      // User explicitly provided model
+      console.log(chalk.green(`✓ Using specified model: ${config.model}`));
+    }
+
+    // Set default API URL if not provided by options or existing config
     if (!config.apiUrl) {
       switch (config.provider) {
         case 'openai':
           config.apiUrl = 'https://api.openai.com/v1/chat/completions';
-          config.model = config.model || 'gpt-4'; // Default model for OpenAI
           break;
         case 'claude':
           config.apiUrl = 'https://api.anthropic.com/v1/messages';
-          config.model = config.model || 'claude-3-sonnet-20240229'; // Default model for Claude
           break;
         case 'gemini':
         default:
-          // Updated Gemini API URL to v1
-          config.apiUrl = 'https://generativelanguage.googleapis.com/v1/models/gemini-pro:generateContent';
-          // Default model for Gemini
-          config.model = config.model || 'gemini-pro'; // Using 'gemini-pro' as a common default
+          // Updated Gemini API URL to v1 - using a base URL
+          config.apiUrl = 'https://generativelanguage.googleapis.com/v1/models';
           break;
       }
     }
 
-    // Interactive model selection if model is not explicitly provided via CLI option
-    // AND if the model is not already set (either from existing config or default)
-    if (!options.model && !config.model) {
-      try {
-        switch (config.provider) {
-          case 'gemini':
-            const geminiModels = ['gemini-1.5-pro-latest', 'gemini-1.5-flash-latest', 'gemini-pro'];
-            const geminiRl = readline.createInterface({
-              input: process.stdin,
-              output: process.stdout
-            });
-            config.model = await new Promise(resolve => {
-              geminiRl.question(chalk.blue(`Select a Gemini model (${geminiModels.join(', ')}): `), (model) => {
-                geminiRl.close();
-                resolve(model || config.model); // Use input or current model if empty
-              });
-            });
-            break;
-          case 'openai':
-            const openaiModels = ['gpt-4o', 'gpt-4-turbo', 'gpt-4', 'gpt-3.5-turbo'];
-            const openaiRl = readline.createInterface({
-              input: process.stdin,
-              output: process.stdout
-            });
-            config.model = await new Promise(resolve => {
-              openaiRl.question(chalk.blue(`Select an OpenAI model (${openaiModels.join(', ')}): `), (model) => {
-                openaiRl.close();
-                resolve(model || config.model);
-              });
-            });
-            break;
-          case 'claude':
-            const claudeModels = ['claude-3-opus-20240229', 'claude-3-sonnet-20240229', 'claude-3-haiku-20240307'];
-            const claudeRl = readline.createInterface({
-              input: process.stdin,
-              output: process.stdout
-            });
-            config.model = await new Promise(resolve => {
-              claudeRl.question(chalk.blue(`Select a Claude model (${claudeModels.join(', ')}): `), (model) => {
-                claudeRl.close();
-                resolve(model || config.model);
-              });
-            });
-            break;
-        }
-      } catch (error) {
-        console.error(chalk.red(`Error selecting model: ${error.message}`));
-        process.exit(1); // Exit if model selection fails
-      }
-    }
-
     fs.writeFileSync(configPath, JSON.stringify(config, null, 2));
     console.log(chalk.green(`✅ Configuration saved for ${config.provider} provider`));
     if (config.model) {
@@ -120,6 +199,45 @@ program
     }
   });
 
+// Index project knowledge base for RAG
+program
+  .command('index')
+  .description('Index project files for Retrieval-Augmented Generation (RAG)')
+  .option('-d, --dry-run', 'Show what files would be indexed without actually indexing')
+  .action(async (options) => {
+    try {
+      const configPath = path.join(os.homedir(), '.codeflow-hook', 'config.json');
+
+      if (!fs.existsSync(configPath)) {
+        console.log(chalk.red('No configuration found. Run: codeflow-hook config -k <api-key>'));
+        process.exit(1);
+      }
+
+      const config = JSON.parse(fs.readFileSync(configPath, 'utf8'));
+      const spinner = ora('Indexing project knowledge base...').start();
+
+      if (options.dryRun) {
+        spinner.stop();
+        console.log(chalk.blue('🔍 Dry run mode - files to be indexed:'));
+        const { findKeyFiles } = await import('./rag.js');
+        const keyFiles = await findKeyFiles(process.cwd());
+        keyFiles.forEach(file => console.log(chalk.gray(`  - ${file}`)));
+        console.log(chalk.green(`📊 Total files to index: ${keyFiles.length}`));
+        return;
+      }
+
+      const result = await indexProject(config);
+
+      spinner.succeed('Knowledge base indexing complete');
+      console.log(chalk.green(`✅ Indexed ${result.indexedFiles} files with ${result.totalChunks} chunks`));
+      console.log(chalk.blue('📁 Knowledge base stored in: .codeflow/index/'));
+
+    } catch (error) {
+      console.error(chalk.red(`❌ Indexing failed: ${error.message}`));
+      process.exit(1);
+    }
+  });
+
 // Install git hooks
 program
   .command('install')
@@ -127,63 +245,45 @@ program
   .option('--hooks-dir <dir>', 'Custom hooks directory', '.git/hooks')
   .action(async (options) => {
     const spinner = ora('Installing git hooks...').start();
-
     try {
       const hooksDir = path.resolve(options.hooksDir);
       if (!fs.existsSync(hooksDir)) {
         fs.mkdirSync(hooksDir, { recursive: true });
       }
 
-      // Create pre-commit hook
+      // CHANGE 1: The git hooks are modified to PIPE the diff content via stdin
       const preCommitHook = `#!/usr/bin/env bash
 # Codeflow pre-commit hook
-# Auto-generated by codeflow-hook CLI
-
 set -e
-
 echo "🔬 Running Codeflow AI Code Analysis..."
-
-# Get staged changes
 STAGED_DIFF=$(git diff --cached --no-color)
-
 if [ -z "$STAGED_DIFF" ]; then
   echo "ℹ️  No staged changes to analyze"
   exit 0
 fi
-
-# Run AI analysis
-npx codeflow-hook analyze-diff "$STAGED_DIFF"
+# Use stdin to avoid "command line too long" error
+echo "$STAGED_DIFF" | npx codeflow-hook analyze-diff
 `;
 
       fs.writeFileSync(path.join(hooksDir, 'pre-commit'), preCommitHook, { mode: 0o755 });
 
-      // Create pre-push hook (enhanced version)
       const prePushHook = `#!/usr/bin/env bash
 # Codeflow pre-push hook
-# Auto-generated by codeflow-hook CLI
-
 set -e
-
 echo "🚀 Running Codeflow CI/CD simulation..."
-
-# Run tests if available
 if [ -f "package.json" ]; then
   echo "🧪 Running tests..."
   npm test || (echo "❌ Tests failed" && exit 1)
 fi
-
-# Get staged changes for AI analysis
 STAGED_DIFF=$(git diff --cached --no-color)
-
 if [ -n "$STAGED_DIFF" ]; then
   echo "🔬 Running AI Code Review..."
-  npx codeflow-hook analyze-diff "$STAGED_DIFF" || exit 1
+  # Use stdin to avoid "command line too long" error
+  echo "$STAGED_DIFF" | npx codeflow-hook analyze-diff || exit 1
 fi
-
 echo "✅ All checks passed!"
 exit 0
 `;
-
       fs.writeFileSync(path.join(hooksDir, 'pre-push'), prePushHook, { mode: 0o755 });
 
       spinner.succeed('Git hooks installed successfully');
@@ -198,14 +298,26 @@ exit 0
     }
   });
 
-// Analyze diff with configured AI provider
+// Analyze diff with specialized AI agents
 program
   .command('analyze-diff')
-  .description('Analyze git diff with configured AI provider')
-  .argument('<diff>', 'Git diff content')
-  .action(async (diff) => {
+  .description('Analyze git diff using specialized AI agents (RAG-enhanced)')
+  .argument('[diff]', 'Git diff content')
+  .option('--legacy', 'Use legacy monolithic analysis instead of agentic workflow')
+  .option('--no-rag', 'Disable RAG context retrieval')
+  .action(async (diff, options) => {
     try {
-      const configPath = path.join(process.env.HOME, '.codeflow-hook', 'config.json');
+      // Read diff content from stdin or argument
+      let diffContent = diff;
+      if (!diffContent) {
+        const chunks = [];
+        for await (const chunk of process.stdin) {
+          chunks.push(chunk);
+        }
+        diffContent = Buffer.concat(chunks).toString('utf8');
+      }
+
+      const configPath = path.join(os.homedir(), '.codeflow-hook', 'config.json');
 
       if (!fs.existsSync(configPath)) {
         console.log(chalk.red('No configuration found. Run: codeflow-hook config -k <api-key>'));
@@ -214,27 +326,51 @@ program
 
       const config = JSON.parse(fs.readFileSync(configPath, 'utf8'));
 
-      if (diff.trim() === '') {
+      if (diffContent.trim() === '') {
         console.log(chalk.gray('ℹ️  No changes to analyze'));
         return;
       }
 
-      const spinner = ora(`Analyzing code with ${config.provider}...`).start();
-      const prompt = generateCodeReviewPrompt(diff);
+      // Legacy mode: use original monolithic analysis
+      if (options.legacy) {
+        const spinner = ora(`Analyzing code with ${config.provider}...`).start();
+        const prompt = generateCodeReviewPrompt(diffContent);
+
+        let result;
+        try {
+          result = await callAIProvider(config, prompt);
+        } catch (error) {
+          spinner.fail('Analysis failed');
+          console.error(chalk.red(`AI API Error: ${error.message}`));
+          process.exit(1);
+        }
+
+        spinner.succeed('Analysis complete');
+        displayAnalysisResults(result);
+        return;
+      }
+
+      // Agentic workflow mode
+      const spinner = ora(`Running specialized code review agents...`).start();
 
-      let result;
+      let results;
       try {
-        result = await callAIProvider(config, prompt);
+        if (options.rag === false) {
+          // Force no RAG context
+          const { orchestrateReviewWithoutRAG } = await import('./agents.js');
+          results = await orchestrateReviewWithoutRAG(diffContent, config);
+        } else {
+          // Use RAG-enabled workflow
+          results = await orchestrateReview(diffContent, config);
+        }
       } catch (error) {
         spinner.fail('Analysis failed');
-        console.error(chalk.red(`AI API Error: ${error.message}`));
+        console.error(chalk.red(`Agent analysis failed: ${error.message}`));
         process.exit(1);
       }
 
-      spinner.succeed('Analysis complete');
-
-      // Parse and display results
-      displayAnalysisResults(result);
+      spinner.succeed('Agentic analysis complete');
+      displayAgenticResults(results);
 
     } catch (error) {
       console.log(chalk.red(`Configuration error: ${error.message}`));
@@ -250,12 +386,27 @@ program
     console.log(chalk.blue('🔍 Codeflow Hook Status'));
     console.log();
 
-    // Check configuration
-    const configPath = path.join(process.env.HOME, '.codeflow-hook', 'config.json');
-    if (fs.existsSync(configPath)) {
-      console.log(chalk.green('✅ Configuration: Found'));
+    // Check configuration cascade
+    const globalConfigPath = path.join(os.homedir(), '.codeflow-hook', 'config.json');
+    const projectConfigPath = path.join(process.cwd(), '.codeflowrc.json');
+
+    const hasGlobalConfig = fs.existsSync(globalConfigPath);
+    const hasProjectConfig = fs.existsSync(projectConfigPath);
+
+    if (hasProjectConfig) {
+      console.log(chalk.green('✅ Project Configuration: Found (.codeflowrc.json)'));
     } else {
-      console.log(chalk.red('❌ Configuration: Not found (run: codeflow-hook config)'));
+      console.log(chalk.gray('ℹ️  Project Configuration: Not found'));
+    }
+
+    if (hasGlobalConfig) {
+      console.log(chalk.green('✅ Global Configuration: Found'));
+    } else {
+      console.log(chalk.red('❌ Global Configuration: Not found (run: codeflow-hook config)'));
+    }
+
+    if (!hasGlobalConfig && !hasProjectConfig) {
+      console.log(chalk.red('❌ No configuration found. Run: codeflow-hook config -k <api-key>'));
     }
 
     // Check git hooks
@@ -274,8 +425,111 @@ program
     } else {
       console.log(chalk.red('❌ Git Hook (pre-push): Not installed'));
     }
+
+    console.log();
+    console.log(chalk.blue('💡 Tips:'));
+    console.log(chalk.gray('   • Create .codeflowrc.json in project root for project-specific settings'));
+    console.log(chalk.gray('   • Large diffs (>20KB) will prompt for confirmation to avoid high costs'));
+    console.log(chalk.gray('   • Run "codeflow-hook config -h" for configuration options'));
   });
 
+
+async function validateApiKey(provider, apiKey) {
+  console.log(`DEBUG: validateApiKey called for provider: ${provider}`);
+  if (!apiKey) {
+    throw new Error('No API key provided');
+  }
+
+  try {
+    console.log(`DEBUG: Making API call for ${provider} validation...`);
+    switch (provider) {
+      case 'gemini':
+        // Test Gemini API key by making a simple models list request
+        const geminiUrl = `https://generativelanguage.googleapis.com/v1beta/models?key=${apiKey}`;
+        console.log(`DEBUG: Gemini URL: ${geminiUrl.substring(0, 80)}...`);
+        await axios.get(geminiUrl);
+        console.log(`DEBUG: Gemini API call succeeded`);
+        break;
+      case 'openai':
+        const openaiUrl = 'https://api.openai.com/v1/models';
+        console.log(`DEBUG: OpenAI URL: ${openaiUrl} with Bearer token`);
+        await axios.get(openaiUrl, {
+          headers: { 'Authorization': `Bearer ${apiKey}` }
+        });
+        console.log(`DEBUG: OpenAI API call succeeded`);
+        break;
+      case 'claude':
+        // Test Claude API key with a minimal request (Anthropic doesn't have models endpoint, so we use a very basic check)
+        console.log(`DEBUG: Claude validation call`);
+        try {
+          await axios.post('https://api.anthropic.com/v1/messages', {
+            model: 'claude-3-haiku-20240307',
+            max_tokens: 1,
+            messages: [{ role: 'user', content: 'Test' }]
+          }, {
+            headers: {
+              'x-api-key': apiKey,
+              'anthropic-version': '2023-06-01',
+              'Content-Type': 'application/json'
+            }
+          });
+        } catch (claudeError) {
+          console.log(`DEBUG: Claude error status: ${claudeError.response?.status}`);
+          if (claudeError.response?.status === 401) {
+            throw new Error('Invalid Claude API key');
+          }
+          // If it's a different error (like rate limit), we'll allow it through
+        }
+        break;
+      default:
+        throw new Error(`Unsupported provider: ${provider}`);
+    }
+  } catch (error) {
+    console.log(`DEBUG: Validation failed with error: ${error.message}`);
+    console.log(`DEBUG: Error response status: ${error.response?.status}`);
+    if (error.response?.status === 401) {
+      throw new Error(`Invalid ${provider} API key`);
+    } else if (error.response?.status === 403) {
+      throw new Error(`API key lacks permissions for ${provider}`);
+    } else if (error.response?.status === 429) {
+      throw new Error(`API rate limit exceeded. Please try again later.`);
+    } else {
+      throw new Error(`${provider} API is currently unavailable: ${error.message}`);
+    }
+  }
+}
+
+async function fetchModels(provider, apiKey) {
+  switch (provider) {
+    case 'gemini':
+      const geminiResponse = await axios.get(`https://generativelanguage.googleapis.com/v1beta/models?key=${apiKey}`);
+      return geminiResponse.data.models.map(m => m.name.replace('models/', ''));
+    case 'openai':
+      const openaiResponse = await axios.get('https://api.openai.com/v1/models', {
+        headers: { 'Authorization': `Bearer ${apiKey}` }
+      });
+      return openaiResponse.data.data.map(m => m.id);
+    case 'claude':
+      console.log(chalk.yellow("Claude does not support dynamic model fetching. Using a standard list."));
+      return getFallbackModels('claude');
+    default:
+      return [];
+  }
+}
+
+function getFallbackModels(provider) {
+  switch (provider) {
+    case 'gemini':
+      return ['gemini-1.5-pro-latest', 'gemini-1.5-flash-latest', 'gemini-pro'];
+    case 'openai':
+      return ['gpt-4o', 'gpt-4-turbo', 'gpt-3.5-turbo'];
+    case 'claude':
+      return ['claude-3-opus-20240229', 'claude-3-sonnet-20240229', 'claude-3-haiku-20240307'];
+    default:
+      return [];
+  }
+}
+
 function generateCodeReviewPrompt(diff) {
   return `You are "Codeflow", a world-class AI software engineering assistant acting as a Principal Engineer. Your mission is to perform a rigorous and constructive code review on the provided code changes.
 
@@ -330,7 +584,8 @@ async function callGemini(config, prompt) {
     }
   };
 
-  const response = await axios.post(`${config.apiUrl}?key=${config.apiKey}`, payload, {
+  const url = `${config.apiUrl}/${config.model}:generateContent?key=${config.apiKey}`;
+  const response = await axios.post(url, payload, {
     headers: {
       'Content-Type': 'application/json'
     }
@@ -406,4 +661,78 @@ function displayAnalysisResults(result) {
   console.log();
 }
 
-program.parse();
+function displayAgenticResults(results) {
+  if (!results || results.length === 0) {
+    console.log(chalk.green('✅ No issues found in the analysis.'));
+    return;
+  }
+
+  // Group results by file and type
+  const groupedResults = {};
+  const summaryStats = { security: 0, architecture: 0, maintainability: 0 };
+
+  for (const result of results) {
+    const key = `${result.file}:${result.scopeType}`;
+    if (!groupedResults[key]) {
+      groupedResults[key] = [];
+    }
+    groupedResults[key].push(result);
+
+    // Count by severity for summary
+    summaryStats[result.type.toLowerCase()]++;
+  }
+
+  // Display summary stats
+  console.log(chalk.blue('📊 Code Review Summary:'));
+  console.log(`   🔒 Security issues: ${summaryStats.security}`);
+  console.log(`   🏗️  Architecture issues: ${summaryStats.architecture}`);
+  console.log(`   📝 Maintainability issues: ${summaryStats.maintainability}`);
+  console.log();
+
+  // Display detailed results by file and scope
+  for (const [scopeKey, scopeResults] of Object.entries(groupedResults)) {
+    const [file, scopeType] = scopeKey.split(':');
+    console.log(chalk.yellow(`📁 ${file} (${scopeType})`));
+
+    for (const result of scopeResults) {
+      const severityColor = getSeverityColor(result.severity);
+      const typeIcon = getTypeIcon(result.type);
+      console.log(`   ${severityColor}${typeIcon} ${result.severity}: ${result.description}`);
+      if (result.line && result.line !== 'N/A') {
+        console.log(chalk.gray(`      Line: ${result.lineRange}`));
+      }
+    }
+    console.log();
+  }
+}
+
+function getSeverityColor(severity) {
+  switch (severity?.toUpperCase()) {
+    case 'CRITICAL':
+      return chalk.red('🔴');
+    case 'HIGH':
+      return chalk.red('🟠');
+    case 'MEDIUM':
+      return chalk.yellow('🟡');
+    case 'LOW':
+      return chalk.green('🟢');
+    default:
+      return chalk.gray('⚪');
+  }
+}
+
+function getTypeIcon(type) {
+  switch (type?.toUpperCase()) {
+    case 'SECURITY':
+      return '🔒';
+    case 'ARCHITECTURE':
+      return '🏗️ ';
+    case 'MAINTAINABILITY':
+      return '📝';
+    default:
+      return '❓';
+  }
+}
+
+// Make sure the final line uses parseAsync
+program.parseAsync(process.argv);