coderev-cli 1.0.26 → 1.3.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "coderev-cli",
-  "version": "1.0.26",
+  "version": "1.3.0",
   "description": "Multi-agent AI code review for git -- parallel agents with confidence scoring",
   "main": "src/index.js",
   "bin": {

package/src/cli.js

@@ -43,6 +43,9 @@ program
   .option('--min-confidence <number>', 'Minimum confidence threshold 0-100 (default: 60)', '60')
   .option('--agents <list>', 'Comma-separated agent list: security,bugs,quality')
   .option('--blame', 'Enable git blame context analysis to distinguish new vs pre-existing issues')
+  .option('--rag', 'Enable RAG codebase context retrieval (requires coderev index first)')
+  .option('--issue <url>', 'Validate that PR addresses a linked GitHub/GitLab issue')
+  .option('--verify-issue', 'Auto-verify PR addresses linked issues from commit messages')
   .action(async (options) => {
     try {
       const config = loadConfig(options.config);
@@ -183,8 +186,35 @@ program
         single: options.single || undefined,
         minConfidence: parseInt(options.minConfidence) || undefined,
         blame: options.blame || undefined,
+        rag: options.rag || undefined,
+        repoRoot: options.repo || options.config ? path.dirname(options.config) : process.cwd(),
       });
 
+      // ── Issue Validation ──
+      if (options.issue) {
+        const { validateIssue } = require('./issue-validator');
+        try {
+          const issueResult = await validateIssue(options.issue, diff, {
+            token: options.githubToken || options.gitlabToken,
+            repoPath: options.repo || process.cwd(),
+            reviewResult: result,
+          });
+          // Append issue validation to result
+          result._issueValidation = issueResult.report;
+          result._issueValidationFormatted = issueResult.formatted;
+        } catch (err) {
+          result._issueValidation = { error: err.message };
+        }
+      }
+
+      if (options.verifyIssue) {
+        const { findRelatedIssues, parseCommitLog } = require('./issue-validator');
+        const repoPath = options.repo || process.cwd();
+        const commitLog = parseCommitLog(repoPath);
+        const relatedIssues = findRelatedIssues(diff, commitLog);
+        result._relatedIssuesFound = relatedIssues;
+      }
+
       let output;
       if (options.output === 'json') {
         output = JSON.stringify(result, null, 2);
@@ -325,6 +355,12 @@ program
         return;
       }
 
+      // ── Print issue validation report if available ──
+      if (result._issueValidationFormatted) {
+        // Print after main output (sent to console.error so it's visible even with piped output)
+        console.error(result._issueValidationFormatted);
+      }
+
       // ── CI Mode ──
       if (options.ci && (result.issues || []).length > 0) {
         const errorIssues = result.issues.filter(i => i.type === 'error');
@@ -888,9 +924,11 @@ program
   .option('--agent-security <name>', 'Model for security agent')
   .option('--agent-bugs <name>', 'Model for bug detection agent')
   .option('--agent-quality <name>', 'Model for quality agent')
+  .option('--auto', 'Auto-detect available providers from environment variables')
+  .option('--quick', 'Alias for --auto')
   .action((options) => {
     const fs = require('fs');
-    const { resolveTemplate } = require('./models');
+    const { resolveTemplate, autoDetectProvider, listTemplates } = require('./models');
     const configPath = path.join(process.cwd(), '.coderevrc.json');
 
     let config = {};
@@ -900,6 +938,86 @@ program
 
     if (!config.ai) config.ai = {};
 
+    // ── Auto-detect mode ──
+    if (options.auto || options.quick) {
+      console.log(chalk.bold('\n🔍 Auto-detecting AI providers...\n'));
+
+      const result = autoDetectProvider();
+
+      if (!result) {
+        console.log(chalk.yellow('⚠ No API key environment variables detected.'));
+        console.log(chalk.gray('\n  Supported providers and their env vars:'));
+        const allTemplates = listTemplates();
+        const seen = new Set();
+        for (const t of allTemplates) {
+          if (!seen.has(t.apiKeyEnv)) {
+            seen.add(t.apiKeyEnv);
+            console.log(chalk.gray(`    ${t.apiKeyEnv}  →  ${t.name} (${t.desc})`));
+          }
+        }
+        console.log(chalk.blue('\n  💡 Set one of these env vars and run `coderev setup --auto` again.'));
+        console.log(chalk.blue('     Or use `coderev setup --model <name>` to pick manually.'));
+        return;
+      }
+
+      // Show detection summary
+      console.log(chalk.bold('📋 Detection Results / 检测结果:'));
+      console.log('━'.repeat(50));
+
+      // List all detected keys
+      for (const name of result.allDetected) {
+        const t = result.allDetected.includes(name) ? require('./models').getTemplate(name) : null;
+        if (t) {
+          const masked = process.env[t.apiKeyEnv].slice(0, 6) + '...' + process.env[t.apiKeyEnv].slice(-4);
+          console.log(chalk.green(`  ✔ ${t.apiKeyEnv}`) + chalk.gray(` → ${name}  (${masked})`));
+        }
+      }
+
+      // Show providers that were NOT detected
+      const allNames = Object.keys(require('./models').BUILTIN_TEMPLATES);
+      const uniqueNotDetected = [...new Set(
+        allNames.filter(n => !result.allDetected.includes(n))
+      )];
+
+      console.log('');
+      console.log(chalk.bold(`✨ Selected: ${chalk.green(result.chosen)}`));
+      console.log(chalk.gray(`   Provider: ${result.template.provider}`));
+      console.log(chalk.gray(`   Model:    ${result.template.model}`));
+      console.log(chalk.gray(`   API Key:  ${result.template.apiKeyEnv}`));
+      console.log('');
+
+      // Write config
+      try {
+        const resolved = resolveTemplate(result.chosen);
+        Object.assign(config.ai, resolved);
+
+        // Also add fallback if second provider is available
+        const remaining = result.allDetected.filter(n => n !== result.chosen);
+        if (remaining.length > 0) {
+          const fallbackName = remaining[0];
+          const fallbackResolved = resolveTemplate(fallbackName);
+          config.ai.fallback = {
+            enabled: true,
+            provider: fallbackResolved.provider,
+            baseURL: fallbackResolved.baseURL,
+            model: fallbackResolved.model,
+            apiKeyEnv: fallbackResolved.apiKeyEnv,
+            temperature: fallbackResolved.temperature,
+            maxTokens: fallbackResolved.maxTokens,
+          };
+          console.log(chalk.blue(`   Fallback: ${fallbackName} (${fallbackResolved.model})`));
+        }
+
+        fs.writeFileSync(configPath, JSON.stringify(config, null, 2));
+        console.log(chalk.green(`\n✔ Config saved to ${configPath}`));
+        console.log(chalk.blue('  Run `coderev review` to start reviewing code!'));
+      } catch (err) {
+        console.error(chalk.red(`✖ ${err.message}`));
+        process.exit(1);
+      }
+      return;
+    }
+
     // Set primary model
     if (options.model) {
       try {
@@ -1105,6 +1223,45 @@ program
     }
   });
 
+program
+  .command('index')
+  .description('Build codebase index for RAG-powered code reviews')
+  .option('-r, --repo <path>', 'Path to git repository', '.')
+  .option('--max-files <number>', 'Maximum files to index (default: 500)', '500')
+  .option('--json', 'Output as JSON')
+  .action(async (options) => {
+    try {
+      const { buildIndex, loadIndex, INDEX_DIR } = require('./rag-indexer');
+      const repoRoot = path.resolve(options.repo);
+
+      console.error(chalk.blue(`📚 Building codebase index for ${repoRoot}...`));
+      console.error(chalk.gray(`   Max files: ${options.maxFiles}`));
+
+      const index = buildIndex(repoRoot, { maxFiles: parseInt(options.maxFiles) });
+
+      if (options.json) {
+        console.log(JSON.stringify(index.stats, null, 2));
+      } else {
+        console.log(chalk.green(`\n✅ Index built successfully!`));
+        console.log(chalk.bold(`\n📊 Statistics:`));
+        console.log(`   Files scanned:    ${index.stats.filesScanned}`);
+        console.log(`   Symbols extracted: ${index.stats.symbolsExtracted}`);
+        console.log(`   Time:             ${index.stats.timeMs}ms`);
+        console.log(`   Stored at:        ${path.join(repoRoot, INDEX_DIR)}`);
+        if (Object.keys(index.stats.languageBreakdown).length > 0) {
+          console.log(chalk.bold(`\n🔤 Language breakdown:`));
+          for (const [lang, count] of Object.entries(index.stats.languageBreakdown).sort((a, b) => b[1] - a[1])) {
+            console.log(`   ${lang}: ${count} symbols`);
+          }
+        }
+        console.log(chalk.blue(`\n💡 Tip: Run \`coderev review --rag\` to use codebase context in reviews.`));
+      }
+    } catch (err) {
+      console.error(chalk.red(`✖ ${err.message}`));
+      process.exit(1);
+    }
+  });
+
 program.parse(process.argv);
 
 // ── Helpers ───────────────────────────────────────────────────
@@ -1204,6 +1361,10 @@ function formatTerminal(result) {
       enLines.push('  ' + chalk.cyan('  Files analyzed: ') + bc.filesAnalyzed);
     }
   }
+  if (result._rag) {
+    enLines.push('\n' + chalk.bold('RAG Context:'));
+    enLines.push('  ' + chalk.magenta(`Indexed ${result._rag.indexedSymbols} symbols from codebase`));
+  }
   enLines.push('\n' + '━'.repeat(50));
 
   return cnLines.join('\n') + '\n' + enLines.join('\n');