codeflow-hook 2.0.3 → 2.2.0

package/bin/codeflow-hook.js

@@ -11,7 +11,7 @@ import readline from 'readline';
 import { orchestrateReview } from './agents.js';
 
 // Import CLI integration service
-import { indexProject, analyzeDiff } from '../lib/cli-integration/dist/index.js';
+import { indexProject } from '../lib/cli-integration/dist/index.js';
 
 // Export for use in agents module
 export { callAIProvider };
@@ -26,13 +26,16 @@ program
 // Configure AI provider settings
 program
   .command('config')
-  .description('Configure AI provider settings')
-  .option('-p, --provider <provider>', 'AI provider (gemini, openai, claude)', 'gemini')
-  .option('-k, --key <key>', 'API key for the chosen provider')
-  .option('-u, --url <url>', 'Custom API URL (optional)')
-  .option('-m, --model <model>', 'AI model name (optional - uses provider default)')
+  .description('Configure AI provider settings (gemini, openai, claude, ollama)')
+  .option('-p, --provider <provider>', 'AI provider (gemini, openai, claude, ollama)', 'gemini')
+  .option('-k, --key <key>', 'API key for cloud providers (not needed for ollama)')
+  .option('-u, --url <url>', 'Custom API URL (for ollama: http://localhost:11434)')
+  .option('-m, --model <model>', 'AI model name (for ollama: auto-discovered if not specified)')
+  .option('--ollama-enable', 'Enable Ollama as the primary provider')
+  .option('--ollama-disable', 'Disable Ollama and use cloud provider instead')
+  .option('--ollama-url <url>', 'Ollama server URL (default: http://localhost:11434)')
+  .option('--list-models', 'List available Ollama models and exit')
   .action(async (options) => {
-    // 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)) {
@@ -40,164 +43,186 @@ program
     }
 
     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')) : {};
 
-    // 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();
-
+    // List Ollama models mode
+    if (options.listModels) {
+      const ollamaUrl = options.ollamaUrl || existingConfig.ollama?.url || 'http://localhost:11434';
+      console.log(chalk.blue(`🔍 Fetching models from Ollama at ${ollamaUrl}...`));
       try {
-        await validateApiKey(requestedProvider, requestedApiKey);
-        validationSpinner.succeed('API key validated');
+        const { listOllamaModels, isOllamaRunning } = await import('../lib/ai-reviewer.cjs');
+        const running = await isOllamaRunning(ollamaUrl);
+        if (!running) {
+          console.log(chalk.red('❌ Ollama is not running or not reachable'));
+          console.log(chalk.yellow(`💡 Start Ollama: ollama serve`));
+          process.exit(1);
+        }
+        const models = await listOllamaModels(ollamaUrl);
+        if (models.length === 0) {
+          console.log(chalk.yellow('⚠️  No models found. Pull a model first:'));
+          console.log(chalk.gray('   ollama pull qwen2.5-coder'));
+          console.log(chalk.gray('   ollama pull deepseek-coder'));
+          console.log(chalk.gray('   ollama pull codellama'));
+        } else {
+          console.log(chalk.green(`✅ Found ${models.length} model(s):`));
+          models.forEach((m, i) => console.log(chalk.gray(`  ${i + 1}. ${m}`)));
+        }
+        process.exit(0);
       } 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.`));
+        console.log(chalk.red(`❌ Failed to connect to Ollama: ${error.message}`));
         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 requestedProvider = (options.provider || existingConfig.provider || 'gemini').toLowerCase();
+    const ollamaEnabled = options.ollamaEnable === true ||
+      (options.ollamaEnable === undefined && options.ollamaDisable === undefined && existingConfig.ollama?.enabled === true) ||
+      requestedProvider === 'ollama';
+
+    // Initialize config structure
     const config = {
-      provider: requestedProvider,
-      apiKey: requestedApiKey,
+      provider: requestedProvider === 'ollama' ? 'ollama' : (existingConfig.provider || 'gemini'),
+      apiKey: options.key || existingConfig.apiKey,
       apiUrl: options.url || existingConfig.apiUrl,
-      model: options.model || existingConfig.model
+      model: options.model || existingConfig.model,
+      ollama: {
+        enabled: ollamaEnabled,
+        url: options.ollamaUrl || existingConfig.ollama?.url || 'http://localhost:11434'
+      }
     };
 
-    // 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;
+    // If Ollama is the primary provider, discover models
+    if (config.ollama.enabled) {
+      console.log(chalk.blue('🦙 Ollama provider detected'));
+      console.log(chalk.gray(`   URL: ${config.ollama.url}`));
 
-      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];
+      try {
+        const { listOllamaModels, isOllamaRunning } = await import('../lib/ai-reviewer.cjs');
+        const running = await isOllamaRunning(config.ollama.url);
+
+        if (!running) {
+          console.log(chalk.yellow('⚠️  Ollama is not running or not reachable'));
+          console.log(chalk.yellow('   Models will not be auto-discovered'));
+          if (!config.model) {
+            console.log(chalk.gray('   Using default model: qwen2.5-coder'));
+            config.model = 'qwen2.5-coder';
+          }
+        } else {
+          const models = await listOllamaModels(config.ollama.url);
+          if (models.length === 0) {
+            console.log(chalk.yellow('⚠️  No Ollama models found'));
+            console.log(chalk.gray('   Pull a model: ollama pull qwen2.5-coder'));
+            if (!config.model) {
+              config.model = 'qwen2.5-coder';
+            }
           } else {
-            config.model = selectedModel;
+            console.log(chalk.green(`✅ Found ${models.length} model(s):`));
+            models.forEach((m, i) => console.log(chalk.gray(`  ${i + 1}. ${m}`)));
+
+            // Auto-select or prompt
+            if (!options.model) {
+              const defaultModel = models.find(m => m.includes('coder') || m.includes('code')) || models[0];
+              console.log(chalk.blue(`\n💡 Recommended: ${defaultModel}`));
+
+              const rl = readline.createInterface({
+                input: process.stdin,
+                output: process.stdout
+              });
+
+              const input = await new Promise(resolve => {
+                rl.question(chalk.blue(`Select model (name or number, Enter for ${defaultModel}): `), (answer) => {
+                  rl.close();
+                  resolve(answer.trim());
+                });
+              });
+
+              if (input === '') {
+                config.model = defaultModel;
+              } else {
+                const idx = parseInt(input) - 1;
+                config.model = (!isNaN(idx) && idx >= 0 && idx < models.length) ? models[idx] : input;
+              }
+              console.log(chalk.green(`✓ Selected: ${config.model}`));
+            }
           }
+        }
+      } catch (error) {
+        console.log(chalk.yellow(`⚠️  Could not connect to Ollama: ${error.message}`));
+        if (!config.model) {
+          config.model = 'qwen2.5-coder';
+        }
+      }
+    } else if (options.key || !existingConfig.apiKey) {
+      // Cloud provider setup with API key validation
+      const hasNewKey = !!options.key;
+      const isFirstTime = !existingConfig.provider && !existingConfig.apiKey;
+      const shouldValidate = hasNewKey || isFirstTime;
 
-          console.log(chalk.green(`✓ Selected model: ${config.model}`));
-
+      if (shouldValidate && config.apiKey) {
+        console.log(chalk.blue(`🔐 Validating API key for ${config.provider}...`));
+        try {
+          await validateApiKey(config.provider, config.apiKey);
+          console.log(chalk.green('✅ API key validated'));
         } 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}`));
-          });
+          console.log(chalk.red(`❌ ${error.message}`));
+          process.exit(1);
+        }
+      }
 
-          const rl = readline.createInterface({
-            input: process.stdin,
-            output: process.stdout
-          });
+      // Set default API URL for cloud providers
+      if (!config.apiUrl) {
+        switch (config.provider) {
+          case 'openai':
+            config.apiUrl = 'https://api.openai.com/v1/chat/completions';
+            break;
+          case 'claude':
+            config.apiUrl = 'https://api.anthropic.com/v1/messages';
+            break;
+          case 'gemini':
+          default:
+            config.apiUrl = 'https://generativelanguage.googleapis.com/v1beta/models';
+            break;
+        }
+      }
 
-          const selectedModel = await new Promise(resolve => {
-            rl.question(chalk.blue(`Select a model (name or number): `), (input) => {
-              rl.close();
-              resolve(input.trim());
+      // Interactive model selection for cloud providers
+      if (!options.model) {
+        const shouldFetch = !existingConfig.model || existingConfig.provider !== config.provider || hasNewKey;
+        if (shouldFetch) {
+          console.log(chalk.blue('🔍 Fetching available models...'));
+          try {
+            const models = await fetchModels(config.provider, config.apiKey);
+            console.log(chalk.blue('Available models:'));
+            models.forEach((m, i) => console.log(chalk.gray(`  ${i + 1}. ${m}`)));
+
+            const rl = readline.createInterface({ input: process.stdin, output: process.stdout });
+            const input = await new Promise(resolve => {
+              rl.question(chalk.blue('Enter model name or number: '), (a) => { rl.close(); resolve(a.trim()); });
             });
-          });
-
-          const index = parseInt(selectedModel) - 1;
-          if (!isNaN(index) && index >= 0 && index < fallbackModels.length) {
-            config.model = fallbackModels[index];
-          } else {
-            config.model = selectedModel;
+            const idx = parseInt(input) - 1;
+            config.model = (!isNaN(idx) && idx >= 0 && idx < models.length) ? models[idx] : input;
+          } catch {
+            const fallbacks = getFallbackModels(config.provider);
+            fallbacks.forEach((m, i) => console.log(chalk.gray(`  ${i + 1}. ${m}`)));
+            const rl = readline.createInterface({ input: process.stdin, output: process.stdout });
+            const input = await new Promise(resolve => {
+              rl.question(chalk.blue('Select model: '), (a) => { rl.close(); resolve(a.trim()); });
+            });
+            const idx = parseInt(input) - 1;
+            config.model = (!isNaN(idx) && idx >= 0 && idx < fallbacks.length) ? fallbacks[idx] : input;
           }
-
-          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';
-          break;
-        case 'claude':
-          config.apiUrl = 'https://api.anthropic.com/v1/messages';
-          break;
-        case 'gemini':
-        default:
-          // Updated Gemini API URL to v1 - using a base URL
-          config.apiUrl = 'https://generativelanguage.googleapis.com/v1/models';
-          break;
       }
     }
 
+    // Save config
     fs.writeFileSync(configPath, JSON.stringify(config, null, 2));
-    console.log(chalk.green(`✅ Configuration saved for ${config.provider} provider`));
-    if (config.model) {
-      console.log(chalk.green(`   Model: ${config.model}`));
+    console.log(chalk.green('\n✅ Configuration saved'));
+    console.log(chalk.gray(`   Provider: ${config.provider}`));
+    console.log(chalk.gray(`   Model: ${config.model}`));
+    console.log(chalk.gray(`   Ollama: ${config.ollama.enabled ? 'enabled (' + config.ollama.url + ')' : 'disabled'}`));
+    if (config.apiKey) {
+      console.log(chalk.gray(`   API Key: ${config.apiKey.substring(0, 8)}...`));
     }
   });
 
@@ -293,12 +318,13 @@ exit 0
     }
   });
 
-// Analyze diff with EKG Query Service context enhancement (Phase 4)
+// Analyze diff with AI review + heuristic fallback
 program
   .command('analyze-diff')
-  .description('Analyze git diff using EKG context enhancement')
+  .description('Analyze git diff with AI code review (Gemini API) and heuristic fallback')
   .argument('[diff]', 'Git diff content')
-  .option('--legacy', 'Use legacy analysis instead of EKG-enhanced analysis')
+  .option('--min-score <score>', 'Minimum score to pass (1-10, default: 3)', '3')
+  .option('--json', 'Output results as JSON only')
   .action(async (diff, options) => {
     try {
       // Read diff content from stdin or argument
@@ -316,24 +342,48 @@ program
         return;
       }
 
-      console.log(chalk.blue('🔬 Analyzing diff with EKG context enhancement...'));
+      // Guard against huge diffs
+      if (diffContent.length > 20000) {
+        console.log(chalk.yellow('⚠️  Diff too large for AI review (>20KB), using heuristic'));
+      }
 
-      const result = await analyzeDiff(diffContent, {
-        legacy: options.legacy || false,
-        outputFormat: 'console'
-      });
+      const minScore = parseInt(options.minScore, 10);
+      const { reviewDiff } = await import('../lib/ai-reviewer.cjs');
 
-      if (result.success) {
-        console.log(chalk.green(`✅ ${result.message}`));
-        displayEKGAnalysisResults(result.analysis);
+      const result = await reviewDiff(diffContent, { minScore });
 
-        if (result.stats) {
-          console.log(chalk.gray(`📊 EKG Queries: ${result.stats.ekg_queries}`));
-          console.log(chalk.gray(`👥 Similar Repos Found: ${result.stats.similar_repos_found}`));
-          console.log(chalk.gray(`⏱️  Analysis Time: ${result.stats.analysis_time}ms`));
-        }
+      if (options.json) {
+        console.log(JSON.stringify(result, null, 2));
       } else {
-        console.log(chalk.red(`❌ Analysis failed: ${result.message}`));
+        const icon = result.success ? '✅' : '❌';
+        const color = result.success ? chalk.green : chalk.red;
+        const providerLabel = result.provider === 'ollama' ? '🦙 Ollama' :
+          result.provider === 'heuristic' ? '🔍 Heuristic' :
+          result.provider === 'gemini' ? '💎 Gemini' :
+          result.provider === 'openai' ? '🔵 OpenAI' :
+          result.provider === 'claude' ? '🟣 Claude' : result.provider;
+        console.log(color(`${icon} ${result.message}`));
+        console.log(chalk.gray(`   Provider: ${providerLabel}${result.usedFallback ? ' (fallback)' : ''}`));
+
+        if (result.result.score) {
+          console.log(chalk.blue(`📊 Score: ${result.result.score}/10 (threshold: ${minScore}/10)`));
+        }
+        if (result.result.summary) {
+          console.log(chalk.gray(`📝 ${result.result.summary}`));
+        }
+        if (result.result.files && result.result.files.length > 0) {
+          for (const file of result.result.files) {
+            if (file.issues && file.issues.length > 0) {
+              console.log(chalk.yellow(`\n📁 ${file.fileName}:`));
+              for (const issue of file.issues) {
+                console.log(chalk.red(`   - [${issue.type}] ${issue.description}`));
+              }
+            }
+          }
+        }
+      }
+
+      if (!result.success) {
         process.exit(1);
       }
 
@@ -433,11 +483,10 @@ program
 program
   .command('status')
   .description('Show installation and configuration status')
-  .action(() => {
+  .action(async () => {
     console.log(chalk.blue('🔍 Codeflow Hook Status'));
     console.log();
 
-    // Check configuration cascade
     const globalConfigPath = path.join(os.homedir(), '.codeflow-hook', 'config.json');
     const projectConfigPath = path.join(process.cwd(), '.codeflowrc.json');
 
@@ -451,16 +500,35 @@ program
     }
 
     if (hasGlobalConfig) {
+      const config = JSON.parse(fs.readFileSync(globalConfigPath, 'utf8'));
       console.log(chalk.green('✅ Global Configuration: Found'));
+      console.log(chalk.gray(`   Provider: ${config.provider || 'gemini'}`));
+      console.log(chalk.gray(`   Model: ${config.model || '(not set)'}`));
+      if (config.ollama?.enabled) {
+        console.log(chalk.green(`   Ollama: enabled (${config.ollama.url || 'http://localhost:11434'})`));
+        try {
+          const { isOllamaRunning } = await import('../lib/ai-reviewer.cjs');
+          const running = await isOllamaRunning(config.ollama.url);
+          console.log(running ? chalk.green('   Ollama Status: running') : chalk.yellow('   Ollama Status: not running'));
+        } catch {
+          console.log(chalk.yellow('   Ollama Status: unknown'));
+        }
+      } else {
+        console.log(chalk.gray('   Ollama: disabled'));
+      }
+      if (config.apiKey) {
+        console.log(chalk.gray(`   API Key: ${config.apiKey.substring(0, 8)}...`));
+      }
     } 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>'));
+      console.log(chalk.red('❌ No configuration found. Run: codeflow-hook config'));
+      console.log(chalk.gray('   Cloud: codeflow-hook config -k <api-key> -p gemini'));
+      console.log(chalk.gray('   Local:  codeflow-hook config --ollama-enable'));
     }
 
-    // Check git hooks
     const hooksDir = '.git/hooks';
     const preCommitHook = path.join(hooksDir, 'pre-commit');
     const prePushHook = path.join(hooksDir, 'pre-push');
@@ -479,9 +547,9 @@ program
 
     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'));
+    console.log(chalk.gray('   • Use --ollama-enable for local AI (no API key needed)'));
+    console.log(chalk.gray('   • List Ollama models: codeflow-hook config --list-models'));
+    console.log(chalk.gray('   • Large diffs (>20KB) use heuristic fallback'));
   });
 
 

package/lib/ai-reviewer.cjs

@@ -0,0 +1,422 @@
+const fs = require('fs');
+const path = require('path');
+const os = require('os');
+const http = require('http');
+const https = require('https');
+
+/**
+ * AI Code Review Module
+ *
+ * Supports multiple AI providers:
+ * - gemini: Google Gemini API (cloud, requires API key)
+ * - openai: OpenAI API (cloud, requires API key)
+ * - claude: Anthropic Claude API (cloud, requires API key)
+ * - ollama: Ollama local models (self-hosted, no API key needed)
+ *
+ * Falls back to the deterministic heuristic analyzer if:
+ * - No provider is configured or enabled
+ * - API call fails (network, timeout, invalid key)
+ * - Response cannot be parsed
+ *
+ * This ensures the pre-commit hook never blocks development due to
+ * missing or broken AI configuration.
+ */
+
+const DEFAULT_CONFIG_PATH = path.join(os.homedir(), '.codeflow-hook', 'config.json');
+
+const AI_REVIEW_PROMPT = `You are "Codeflow", a Principal Engineer performing a rigorous code review on the provided git diff.
+
+Your response MUST be a single, valid JSON object with no markdown, no code blocks, no extra text.
+
+The JSON must have this exact structure:
+{
+  "overallStatus": "PASS" or "FAIL",
+  "score": integer 1-10,
+  "summary": "one sentence executive summary",
+  "files": [
+    {
+      "fileName": "path/to/file",
+      "status": "PASS" or "FAIL",
+      "issues": [
+        { "line": number, "type": "Security"|"Bug"|"Performance"|"Quality"|"Best Practice", "description": "clear description" }
+      ],
+      "suggestions": ["actionable suggestion"]
+    }
+  ]
+}
+
+Rules:
+- overallStatus must be "FAIL" if ANY Security, Bug, or critical Performance issues exist
+- score: 1-10 (10 = production-ready, 1 = fundamentally broken)
+- Be constructive and precise
+- Focus on: security vulnerabilities, bugs, performance issues, code quality
+
+Git diff to review:
+`;
+
+/**
+ * Load AI provider configuration from ~/.codeflow-hook/config.json
+ * @returns {{ provider: string, apiKey: string, apiUrl: string, model: string, ollama: { enabled: boolean, url: string } } | null}
+ */
+function loadConfig() {
+  try {
+    if (fs.existsSync(DEFAULT_CONFIG_PATH)) {
+      const raw = fs.readFileSync(DEFAULT_CONFIG_PATH, 'utf8');
+      const config = JSON.parse(raw);
+      // Ensure ollama section exists with defaults
+      if (!config.ollama) {
+        config.ollama = { enabled: false, url: 'http://localhost:11434' };
+      }
+      return config;
+    }
+  } catch (e) {
+    // Config file exists but is invalid — fall back to heuristic
+  }
+  return null;
+}
+
+/**
+ * Call Ollama local API with the diff and return structured review.
+ * Uses /api/generate endpoint with format: "json" for structured output.
+ * @param {string} diff - Git diff content
+ * @param {{ model: string, url: string }} config
+ * @returns {Promise<string>} - Raw text response from Ollama
+ */
+async function callOllamaAPI(diff, config) {
+  const prompt = AI_REVIEW_PROMPT + diff;
+  const baseUrl = config.url || 'http://localhost:11434';
+  const urlObj = new URL(`${baseUrl}/api/generate`);
+
+  const payload = JSON.stringify({
+    model: config.model || 'qwen2.5-coder',
+    prompt,
+    stream: false,
+    format: 'json',
+    options: {
+      temperature: 0.2,
+      num_ctx: 8192,
+    }
+  });
+
+  const isHttps = urlObj.protocol === 'https:';
+  const client = isHttps ? https : http;
+
+  return new Promise((resolve, reject) => {
+    const req = client.request(urlObj, {
+      method: 'POST',
+      headers: {
+        'Content-Type': 'application/json',
+        'Content-Length': Buffer.byteLength(payload)
+      },
+      timeout: 120000 // 2 minute timeout for local models
+    }, (res) => {
+      let data = '';
+      res.on('data', (chunk) => { data += chunk; });
+      res.on('end', () => {
+        if (res.statusCode !== 200) {
+          return reject(new Error(`Ollama returned ${res.statusCode}: ${data.substring(0, 200)}`));
+        }
+        try {
+          const response = JSON.parse(data);
+          const text = response.response;
+          if (!text) {
+            return reject(new Error('Ollama returned no text response'));
+          }
+          resolve(text);
+        } catch (e) {
+          reject(new Error(`Failed to parse Ollama response: ${e.message}`));
+        }
+      });
+    });
+
+    req.on('error', (e) => reject(e));
+    req.on('timeout', () => {
+      req.destroy();
+      reject(new Error('Ollama request timed out after 120s — is the model loaded?'));
+    });
+
+    req.write(payload);
+    req.end();
+  });
+}
+
+/**
+ * List available Ollama models by calling /api/tags
+ * @param {string} baseUrl - Ollama URL (default: http://localhost:11434)
+ * @returns {Promise<string[]>} - Array of model names
+ */
+async function listOllamaModels(baseUrl) {
+  const url = `${baseUrl || 'http://localhost:11434'}/api/tags`;
+  const urlObj = new URL(url);
+  const isHttps = urlObj.protocol === 'https:';
+  const client = isHttps ? https : http;
+
+  return new Promise((resolve, reject) => {
+    const req = client.request(urlObj, {
+      method: 'GET',
+      timeout: 10000
+    }, (res) => {
+      let data = '';
+      res.on('data', (chunk) => { data += chunk; });
+      res.on('end', () => {
+        if (res.statusCode !== 200) {
+          return reject(new Error(`Ollama returned ${res.statusCode}`));
+        }
+        try {
+          const response = JSON.parse(data);
+          const models = (response.models || []).map(m => m.name);
+          resolve(models);
+        } catch (e) {
+          reject(new Error(`Failed to parse Ollama model list: ${e.message}`));
+        }
+      });
+    });
+
+    req.on('error', (e) => reject(e));
+    req.on('timeout', () => {
+      req.destroy();
+      reject(new Error('Ollama connection timed out — is Ollama running?'));
+    });
+
+    req.end();
+  });
+}
+
+/**
+ * Check if Ollama is running and reachable
+ * @param {string} baseUrl - Ollama URL
+ * @returns {Promise<boolean>}
+ */
+async function isOllamaRunning(baseUrl) {
+  try {
+    const models = await listOllamaModels(baseUrl);
+    return models.length > 0;
+  } catch {
+    return false;
+  }
+}
+
+/**
+ * Call Gemini API with the diff and return structured review.
+ * @param {string} diff - Git diff content
+ * @param {{ apiKey: string, apiUrl: string, model: string }} config
+ * @returns {Promise<string>} - Raw text response
+ */
+async function callGeminiAPI(diff, config) {
+  const prompt = AI_REVIEW_PROMPT + diff;
+
+  let url;
+  if (config.apiUrl && config.apiUrl.includes('generativelanguage')) {
+    url = `${config.apiUrl}/${config.model || 'gemini-2.0-flash'}:generateContent?key=${config.apiKey}`;
+  } else if (config.apiUrl) {
+    url = config.apiUrl;
+  } else {
+    url = `https://generativelanguage.googleapis.com/v1beta/models/${config.model || 'gemini-2.0-flash'}:generateContent?key=${config.apiKey}`;
+  }
+
+  const payload = JSON.stringify({
+    contents: [{
+      parts: [{ text: prompt }]
+    }],
+    generationConfig: {
+      temperature: 0.2,
+      maxOutputTokens: 4096,
+    }
+  });
+
+  return new Promise((resolve, reject) => {
+    const req = https.request(url, {
+      method: 'POST',
+      headers: {
+        'Content-Type': 'application/json',
+        'Content-Length': Buffer.byteLength(payload)
+      },
+      timeout: 30000
+    }, (res) => {
+      let data = '';
+      res.on('data', (chunk) => { data += chunk; });
+      res.on('end', () => {
+        if (res.statusCode !== 200) {
+          return reject(new Error(`Gemini API returned ${res.statusCode}: ${data.substring(0, 200)}`));
+        }
+        try {
+          const response = JSON.parse(data);
+          const text = response.candidates?.[0]?.content?.parts?.[0]?.text;
+          if (!text) {
+            return reject(new Error('Gemini returned no text response'));
+          }
+          resolve(text);
+        } catch (e) {
+          reject(new Error(`Failed to parse Gemini response: ${e.message}`));
+        }
+      });
+    });
+
+    req.on('error', (e) => reject(e));
+    req.on('timeout', () => {
+      req.destroy();
+      reject(new Error('Gemini API request timed out after 30s'));
+    });
+
+    req.write(payload);
+    req.end();
+  });
+}
+
+/**
+ * Parse AI response text into structured review result.
+ * Handles cases where the response is wrapped in markdown code blocks.
+ * @param {string} text - Raw AI response text
+ * @returns {{ overallStatus: string, score: number, summary: string, files: Array }}
+ */
+function parseAIResponse(text) {
+  let cleaned = text.trim();
+  const codeBlockMatch = cleaned.match(/```(?:json)?\s*([\s\S]*?)```/);
+  if (codeBlockMatch) {
+    cleaned = codeBlockMatch[1].trim();
+  }
+
+  const jsonMatch = cleaned.match(/\{[\s\S]*\}/);
+  if (!jsonMatch) {
+    throw new Error('No JSON object found in AI response');
+  }
+
+  const parsed = JSON.parse(jsonMatch[0]);
+
+  if (!parsed.overallStatus || !parsed.score || !parsed.files) {
+    throw new Error('AI response missing required fields (overallStatus, score, files)');
+  }
+
+  const score = Math.max(1, Math.min(10, Math.round(parsed.score)));
+
+  return {
+    overallStatus: parsed.overallStatus.toUpperCase() === 'FAIL' ? 'FAIL' : 'PASS',
+    score,
+    summary: parsed.summary || 'No summary provided',
+    files: Array.isArray(parsed.files) ? parsed.files : []
+  };
+}
+
+/**
+ * Main entry point: review a git diff.
+ * Provider priority: Ollama (if enabled) → Cloud provider (Gemini/OpenAI/Claude) → Heuristic fallback
+ *
+ * @param {string} diff - Git diff content
+ * @param {{ minScore?: number }} options
+ * @returns {Promise<{ success: boolean, result: object, message: string, usedFallback: boolean, provider: string }>}
+ */
+async function reviewDiff(diff, options = {}) {
+  const minScore = options.minScore || 3;
+  const config = loadConfig();
+
+  // Determine which provider to use
+  const useOllama = config?.ollama?.enabled === true;
+  const provider = useOllama ? 'ollama' : (config?.provider || 'none');
+
+  // Try Ollama if enabled
+  if (useOllama) {
+    try {
+      const ollamaConfig = {
+        model: config.model || 'qwen2.5-coder',
+        url: config.ollama.url || 'http://localhost:11434'
+      };
+      const responseText = await callOllamaAPI(diff, ollamaConfig);
+      const result = parseAIResponse(responseText);
+
+      if (result.score < minScore) {
+        return {
+          success: false,
+          result,
+          message: `Ollama review score ${result.score}/10 is below threshold ${minScore}/10`,
+          usedFallback: false,
+          provider: 'ollama'
+        };
+      }
+
+      if (result.overallStatus === 'FAIL') {
+        return {
+          success: false,
+          result,
+          message: 'Ollama review found critical issues — review required',
+          usedFallback: false,
+          provider: 'ollama'
+        };
+      }
+
+      return {
+        success: true,
+        result,
+        message: `Ollama review passed — score ${result.score}/10 (${ollamaConfig.model})`,
+        usedFallback: false,
+        provider: 'ollama'
+      };
+    } catch (error) {
+      console.error(`Ollama review failed (${error.message}), trying cloud provider...`);
+    }
+  }
+
+  // Try cloud provider (Gemini, OpenAI, Claude)
+  if (config?.apiKey) {
+    try {
+      const responseText = await callGeminiAPI(diff, config);
+      const result = parseAIResponse(responseText);
+
+      if (result.score < minScore) {
+        return {
+          success: false,
+          result,
+          message: `${provider} review score ${result.score}/10 is below threshold ${minScore}/10`,
+          usedFallback: false,
+          provider
+        };
+      }
+
+      if (result.overallStatus === 'FAIL') {
+        return {
+          success: false,
+          result,
+          message: `${provider} review found critical issues — review required`,
+          usedFallback: false,
+          provider
+        };
+      }
+
+      return {
+        success: true,
+        result,
+        message: `${provider} review passed — score ${result.score}/10`,
+        usedFallback: false,
+        provider
+      };
+    } catch (error) {
+      console.error(`${provider} review failed (${error.message}), using heuristic fallback`);
+    }
+  }
+
+  // Final fallback: heuristic analyzer
+  const { analyzeCode } = require('../../../server/analyzer.js');
+  const heuristicResult = analyzeCode(diff);
+  const score = heuristicResult.files.reduce((min, f) => Math.min(min, f.score), 10);
+  const passed = score >= minScore && heuristicResult.overallStatus === 'PASS';
+
+  return {
+    success: passed,
+    result: { ...heuristicResult, score },
+    message: passed
+      ? `Heuristic review passed — score ${score}/10 (AI unavailable)`
+      : `Heuristic review failed — score ${score}/10 (AI unavailable)`,
+    usedFallback: true,
+    provider: 'heuristic'
+  };
+}
+
+module.exports = {
+  reviewDiff,
+  loadConfig,
+  callGeminiAPI,
+  callOllamaAPI,
+  listOllamaModels,
+  isOllamaRunning,
+  parseAIResponse,
+  AI_REVIEW_PROMPT
+};

package/lib/cli-integration/src/index.ts

@@ -1,14 +1,14 @@
 #!/usr/bin/env node
 
 /**
- * CLI Integration Service - Phase 4
+ * CLI Integration Service
  *
- * Bridges the local CLI commands with EKG backend services.
- * Transforms CLI operations from local processing to backend-driven workflows.
+ * Bridges CLI commands with local git operations.
+ * EKG backend integration (Phase 4) removed — not deployed.
  *
- * Key transformations:
- * - `codeflow index` → EKG Ingestion Service webhook simulation
- * - `codeflow analyze-diff` → EKG Query Service context-enhanced analysis
+ * Key operations:
+ * - `codeflow index` → Submit repository for indexing
+ * - `codeflow analyze-diff` → Local diff parsing only
  */
 
 import axios from 'axios';
@@ -235,9 +235,8 @@ export class CLIIntegrationService {
   }
 
   /**
-   * Analyze code diff with EKG context enhancement
-   *
-   * Sends diff to Query Service for EKG-enhanced analysis instead of local RAG
+   * Analyze code diff — simplified to local diff parsing only.
+   * EKG backend integration removed (Phase 4 not deployed).
    */
   async analyzeDiff(diffContent: string, options: {
     legacy?: boolean;
@@ -263,22 +262,12 @@ export class CLIIntegrationService {
         };
       }
 
-      if (options.legacy) {
-        // Fallback to local analysis (would integrate with existing agents)
-        logger.warn('Legacy mode requested - falling back to local analysis');
-        return {
-          success: false,
-          analysis: null,
-          message: 'Legacy mode not yet implemented with EKG integration'
-        };
-      }
-
-      logger.info('Analyzing diff with EKG context enhancement', {
+      logger.info('Analyzing diff (local only — EKG backend not deployed)', {
         diffSize: diffContent.length,
         lines: diffContent.split('\n').length
       });
 
-      // Analyze diff and extract context
+      // Parse diff content locally
       const diffAnalysis = this.analyzeDiffContent(diffContent);
 
       if (diffAnalysis.files.length === 0) {
@@ -289,28 +278,30 @@ export class CLIIntegrationService {
         };
       }
 
-      // Query EKG for context on affected files
-      const ekgContext = await this.getEKGContext(diffAnalysis);
-
-      // Generate enhanced analysis with EKG data
-      const enhancedAnalysis = await this.generateEKGEnhancedAnalysis(diffAnalysis, ekgContext);
-
       const analysisTime = Date.now() - startTime;
 
-      logger.info('Diff analysis completed with EKG enhancement', {
+      logger.info('Diff analysis completed', {
         affectedFiles: diffAnalysis.files.length,
-        ekgQueries: ekgContext.queriesMade,
-        similarReposFound: ekgContext.similarRepositories?.length || 0,
         analysisTime
       });
 
       return {
         success: true,
-        analysis: enhancedAnalysis,
-        message: 'Diff analyzed with EKG context enhancement',
+        analysis: {
+          summary: {
+            totalFiles: diffAnalysis.files.length,
+            totalAdditions: diffAnalysis.totalAdditions,
+            totalDeletions: diffAnalysis.totalDeletions,
+            ekgEnhanced: false
+          },
+          files: diffAnalysis.files,
+          issues: [],
+          recommendations: []
+        },
+        message: 'Diff analyzed (local analysis only)',
         stats: {
-          ekg_queries: ekgContext.queriesMade,
-          similar_repos_found: ekgContext.similarRepositories?.length || 0,
+          ekg_queries: 0,
+          similar_repos_found: 0,
           analysis_time: analysisTime
         }
       };
@@ -410,178 +401,6 @@ export class CLIIntegrationService {
     };
   }
 
-  /**
-   * Query EKG for context on affected files
-   */
-  private async getEKGContext(diffAnalysis: any): Promise<{
-    queriesMade: number;
-    repositoryIntelligence?: any;
-    similarRepositories: any[];
-    patterns: any[];
-  }> {
-    let queriesMade = 0;
-
-    try {
-      // Get current repository information
-      const repoInfo = await this.getRepositoryInfo();
-      const repositoryId = this.generateRepositoryId(repoInfo.fullName);
-
-      // Query repository intelligence if repository exists in EKG
-      let repositoryIntelligence = null;
-      try {
-        const response = await this.makeGraphQLRequest(
-          `
-          query GetRepositoryIntelligence($repoId: ID!) {
-            repositoryIntelligence(repositoryId: $repoId) {
-              repository {
-                id name fullName language
-              }
-              patterns {
-                name type confidence category
-              }
-              dependencies {
-                dependencyType currentVersion confidence
-              }
-            }
-          }
-          `,
-          { repoId: repositoryId }
-        );
-        repositoryIntelligence = response.data?.repositoryIntelligence;
-        queriesMade++;
-      } catch (error) {
-        logger.warn('Repository not found in EKG, continuing analysis', { repositoryId });
-      }
-
-      // Find similar repositories and patterns for context
-      let similarRepositories: any[] = [];
-      try {
-        const response = await this.makeGraphQLRequest(
-          `
-          query FindSimilarRepositories($repoId: ID!, $limit: Int) {
-            similarRepositories(repositoryId: $repoId, limit: $limit) {
-              repository { name fullName language }
-              similarityScore reasons
-              sharedPatterns sizeComparison
-            }
-          }
-          `,
-          { repoId: repositoryId, limit: 5 }
-        );
-        similarRepositories = response.data?.similarRepositories || [];
-        queriesMade++;
-      } catch (error) {
-        logger.warn('Could not fetch similar repositories', { error: this.formatError(error) });
-      }
-
-      // Get enterprise-wide patterns that might be relevant
-      let patterns: any[] = [];
-      try {
-        const languages = [...new Set(diffAnalysis.files.map((f: any) => f.language))];
-
-        const response = await this.makeGraphQLRequest(
-          `
-          query GetRelevantPatterns($language: String, $limit: Int) {
-            patterns(language: $language, minConfidence: 0.7, limit: $limit) {
-              name type category confidence observationCount
-            }
-          }
-          `,
-          { language: languages[0], limit: 10 }
-        );
-        patterns = response.data?.patterns || [];
-        queriesMade++;
-      } catch (error) {
-        logger.warn('Could not fetch patterns', { error: this.formatError(error) });
-      }
-
-      return {
-        queriesMade,
-        repositoryIntelligence,
-        similarRepositories,
-        patterns
-      };
-
-    } catch (error) {
-      logger.error('EKG context retrieval failed', { error: this.formatError(error) });
-      return {
-        queriesMade,
-        similarRepositories: [],
-        patterns: []
-      };
-    }
-  }
-
-  /**
-   * Generate enhanced analysis using EKG context
-   */
-  private async generateEKGEnhancedAnalysis(diffAnalysis: any, ekgContext: any): Promise<any> {
-    // Analyze changes with EKG context
-    const issues: any[] = [];
-    const recommendations: any[] = [];
-
-    // Check against existing patterns
-    if (ekgContext.patterns && ekgContext.patterns.length > 0) {
-      for (const file of diffAnalysis.files) {
-        const relevantPatterns = ekgContext.patterns.filter((p: any) =>
-          p.type === 'security' || p.type === 'architecture'
-        );
-
-        if (relevantPatterns.length > 0) {
-          recommendations.push({
-            type: 'ekg_pattern_alignment',
-            description: `File ${file.path} modified - consider these established patterns: ${relevantPatterns.map((p: any) => p.name).join(', ')}`,
-            severity: 'info',
-            file: file.path
-          });
-        }
-      }
-    }
-
-    // Compare against similar repositories
-    if (ekgContext.similarRepositories && ekgContext.similarRepositories.length > 0) {
-      const similarRepoNames = ekgContext.similarRepositories.map((sr: any) => sr.repository.fullName);
-      recommendations.push({
-        type: 'similar_repositories',
-        description: `Changes similar to patterns seen in: ${similarRepoNames.slice(0, 3).join(', ')}`,
-        severity: 'info'
-      });
-    }
-
-    // Add repository-specific context if available
-    if (ekgContext.repositoryIntelligence) {
-      const repo = ekgContext.repositoryIntelligence.repository;
-      issues.push({
-        type: 'repository_context',
-        description: `Analyzing changes in repository ${repo.fullName} (${repo.language})`,
-        severity: 'info'
-      });
-    }
-
-    return {
-      summary: {
-        totalFiles: diffAnalysis.files.length,
-        totalAdditions: diffAnalysis.totalAdditions,
-        totalDeletions: diffAnalysis.totalDeletions,
-        ekgEnhanced: true
-      },
-      files: diffAnalysis.files.map((file: any) => ({
-        path: file.path,
-        language: file.language,
-        additions: file.additions,
-        deletions: file.deletions,
-        isNew: file.isNew
-      })),
-      issues,
-      recommendations,
-      ekg_context: {
-        patterns_analyzed: ekgContext.patterns?.length || 0,
-        similar_repositories_found: ekgContext.similarRepositories?.length || 0,
-        repository_known: !!ekgContext.repositoryIntelligence
-      }
-    };
-  }
-
   /**
    * Get current repository information
    */
@@ -780,18 +599,7 @@ export class CLIIntegrationService {
   }
 
   /**
-   * Make GraphQL request to Query Service
-   */
-  private async makeGraphQLRequest(query: string, variables: any = {}): Promise<any> {
-    return this.makeBackendRequest(
-      `${this.config.queryServiceUrl}/graphql`,
-      { query, variables },
-      { 'Content-Type': 'application/json' }
-    );
-  }
-
-  /**
-   * Generate repository ID (similar to ingestion service)
+   * Generate repository ID
    */
   private generateRepositoryId(fullName: string): string {
     return `${fullName.replace('/', '-')}-${Date.now().toString(36)}`;

package/package.json

@@ -1,8 +1,8 @@
 
 {
   "name": "codeflow-hook",
-  "version": "2.0.3",
-  "description": "An interactive CI/CD simulator and lightweight pre-push code reviewer using Gemini AI",
+  "version": "2.2.0",
+  "description": "Local AI-powered code analysis and pre-push review for development workflows",
   "type": "module",
   "main": "index.js",
   "bin": {