coderev-cli 1.0.23 → 1.0.24

package/package.json

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

package/src/cli.js

@@ -848,6 +848,124 @@ program
     }
   });
 
+// ── Models ────────────────────────────────────────────────────────
+program
+  .command('models')
+  .description('List available AI model templates')
+  .option('--json', 'Output as JSON')
+  .action((options) => {
+    const { listTemplates } = require('./models');
+    const templates = listTemplates();
+
+    if (options.json) {
+      console.log(JSON.stringify(templates, null, 2));
+      return;
+    }
+
+    const tierIcons = { recommended: '⭐', reasoning: '🧠', standard: '  ' };
+    console.log(chalk.bold('\n📋 Available Model Templates\n'));
+    console.log(chalk.gray('  Usage: coderev setup --model <name>        (set primary model)'));
+    console.log(chalk.gray('         coderev setup --model <name> --fallback <name>  (set primary + fallback)'));
+    console.log(chalk.gray('         coderev setup --agent-security <name> --agent-quality <name>'));
+    console.log('');
+
+    for (const t of templates) {
+      const icon = tierIcons[t.tier] || '  ';
+      const providerTag = chalk.gray(`[${t.provider}]`);
+      console.log(`  ${icon} ${chalk.green(t.name)}  ${providerTag}`);
+      console.log(`     ${t.desc}`);
+      console.log(chalk.gray(`     API Key: ${t.apiKeyEnv}`));
+      console.log('');
+    }
+  });
+
+// ── Config ────────────────────────────────────────────────────────
+program
+  .command('setup')
+  .description('Manage coderev model configuration')
+  .option('--model <name>', 'Set primary model template')
+  .option('--fallback <name>', 'Set fallback model template')
+  .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')
+  .action((options) => {
+    const fs = require('fs');
+    const { resolveTemplate } = require('./models');
+    const configPath = path.join(process.cwd(), '.coderevrc.json');
+
+    let config = {};
+    if (fs.existsSync(configPath)) {
+      config = JSON.parse(fs.readFileSync(configPath, 'utf-8'));
+    }
+
+    if (!config.ai) config.ai = {};
+
+    // Set primary model
+    if (options.model) {
+      try {
+        const resolved = resolveTemplate(options.model);
+        Object.assign(config.ai, resolved);
+        console.log(chalk.green(`✔ Primary model set to "${options.model}" (${resolved.model})`));
+      } catch (err) {
+        console.error(chalk.red(`✖ ${err.message}`));
+        process.exit(1);
+      }
+    }
+
+    // Set fallback model
+    if (options.fallback) {
+      try {
+        const resolved = resolveTemplate(options.fallback);
+        config.ai.fallback = {
+          enabled: true,
+          provider: resolved.provider,
+          baseURL: resolved.baseURL,
+          model: resolved.model,
+          temperature: resolved.temperature,
+          maxTokens: resolved.maxTokens,
+        };
+        console.log(chalk.green(`✔ Fallback model set to "${options.fallback}" (${resolved.model})`));
+      } catch (err) {
+        console.error(chalk.red(`✖ ${err.message}`));
+        process.exit(1);
+      }
+    }
+
+    // Set per-agent models
+    if (!config.ai.agents) config.ai.agents = {};
+    const agentOpts = [
+      ['security', options.agentSecurity],
+      ['bugs', options.agentBugs],
+      ['quality', options.agentQuality],
+    ];
+    for (const [agent, templateName] of agentOpts) {
+      if (templateName) {
+        try {
+          const resolved = resolveTemplate(templateName);
+          config.ai.agents[agent] = {
+            provider: resolved.provider,
+            baseURL: resolved.baseURL,
+            model: resolved.model,
+            temperature: resolved.temperature,
+          };
+          console.log(chalk.green(`✔ ${agent} agent model set to "${templateName}" (${resolved.model})`));
+        } catch (err) {
+          console.error(chalk.red(`✖ ${err.message}`));
+          process.exit(1);
+        }
+      }
+    }
+
+    fs.writeFileSync(configPath, JSON.stringify(config, null, 2));
+    console.log(chalk.blue(`   Config saved to ${configPath}`));
+
+    if (!options.model && !options.fallback && !options.agentSecurity && !options.agentBugs && !options.agentQuality) {
+      // No options: show current config
+      console.log(chalk.bold('\n📋 Current coderev config:\n'));
+      console.log(JSON.stringify(config, null, 2));
+    }
+  });
+
 // ── Rules Marketplace ─────────────────────────────────────────────
 program
   .command('rules <action>')

package/src/models.js

@@ -0,0 +1,160 @@
+/**
+ * Model Templates — built-in hot model presets for coderev.
+ *
+ * Usage:
+ *   coderev config --model deepseek          # switch to DeepSeek template
+ *   coderev config --model openai --fallback qwen  # primary + fallback
+ *   coderev config --agent-security deepseek --agent-quality qwen
+ *   coderev models                           # list all templates
+ *
+ * Each template provides provider + baseURL + default model,
+ * user only needs to set the corresponding API key env var.
+ */
+
+const BUILTIN_TEMPLATES = {
+  deepseek: {
+    provider: 'deepseek',
+    baseURL: 'https://api.deepseek.com',
+    model: 'deepseek-chat',
+    apiKeyEnv: 'DEEPSEEK_API_KEY',
+    desc: 'DeepSeek V3 — 国产高性价比，¥1/百万token',
+    tier: 'recommended',
+  },
+  'deepseek-r1': {
+    provider: 'deepseek',
+    baseURL: 'https://api.deepseek.com',
+    model: 'deepseek-reasoner',
+    apiKeyEnv: 'DEEPSEEK_API_KEY',
+    desc: 'DeepSeek R1 — 推理增强，适合复杂漏洞分析',
+    tier: 'reasoning',
+  },
+  openai: {
+    provider: 'openai',
+    baseURL: 'https://api.openai.com/v1',
+    model: 'gpt-4o',
+    apiKeyEnv: 'OPENAI_API_KEY',
+    desc: 'GPT-4o — OpenAI 多模态旗舰',
+    tier: 'standard',
+  },
+  'openai-o3': {
+    provider: 'openai',
+    baseURL: 'https://api.openai.com/v1',
+    model: 'o3-mini',
+    apiKeyEnv: 'OPENAI_API_KEY',
+    desc: 'OpenAI o3-mini — 推理型，速度快',
+    tier: 'reasoning',
+  },
+  qwen: {
+    provider: 'openai',
+    baseURL: 'https://dashscope.aliyuncs.com/compatible-mode/v1',
+    model: 'qwen-plus',
+    apiKeyEnv: 'DASHSCOPE_API_KEY',
+    desc: '通义千问 Qwen-Plus — 中文能力强，¥0.8/百万token',
+    tier: 'standard',
+  },
+  'qwen-coder': {
+    provider: 'openai',
+    baseURL: 'https://dashscope.aliyuncs.com/compatible-mode/v1',
+    model: 'qwen-coder-plus',
+    apiKeyEnv: 'DASHSCOPE_API_KEY',
+    desc: '通义千问 Coder — 代码专精，¥2/百万token',
+    tier: 'recommended',
+  },
+  claude: {
+    provider: 'openai',
+    baseURL: 'https://api.anthropic.com/v1',
+    model: 'claude-sonnet-4-20250514',
+    apiKeyEnv: 'ANTHROPIC_API_KEY',
+    desc: 'Claude Sonnet 4 — 代码理解深度最强',
+    tier: 'standard',
+  },
+  gemini: {
+    provider: 'openai',
+    baseURL: 'https://generativelanguage.googleapis.com/v1beta/openai',
+    model: 'gemini-2.5-pro',
+    apiKeyEnv: 'GEMINI_API_KEY',
+    desc: 'Gemini 2.5 Pro — Google，100万token上下文',
+    tier: 'standard',
+  },
+  zhipu: {
+    provider: 'openai',
+    baseURL: 'https://open.bigmodel.cn/api/paas/v4',
+    model: 'glm-4-plus',
+    apiKeyEnv: 'ZHIPU_API_KEY',
+    desc: '智谱 GLM-4-Plus — 国产强推理',
+    tier: 'standard',
+  },
+  moonshot: {
+    provider: 'openai',
+    baseURL: 'https://api.moonshot.cn/v1',
+    model: 'moonshot-v1-8k',
+    apiKeyEnv: 'MOONSHOT_API_KEY',
+    desc: '月之暗面 Kimi — 长文本处理强',
+    tier: 'standard',
+  },
+  codestral: {
+    provider: 'openai',
+    baseURL: 'https://api.mistral.ai/v1',
+    model: 'codestral-latest',
+    apiKeyEnv: 'MISTRAL_API_KEY',
+    desc: 'Mistral Codestral — 专注代码生成与审查',
+    tier: 'standard',
+  },
+};
+
+/**
+ * Resolve a model template by name, with optional user overrides.
+ * Returns a full ai config block ready for use.
+ *
+ * @param {string} templateName - Template name (e.g. 'deepseek', 'qwen')
+ * @param {object} [overrides] - User overrides (model, baseURL, provider, etc.)
+ * @returns {object} Resolved ai config
+ */
+function resolveTemplate(templateName, overrides = {}) {
+  const template = BUILTIN_TEMPLATES[templateName];
+  if (!template) {
+    throw new Error(
+      `Unknown model template "${templateName}". ` +
+      `Available: ${Object.keys(BUILTIN_TEMPLATES).join(', ')}`
+    );
+  }
+
+  return {
+    provider: overrides.provider || template.provider,
+    baseURL: overrides.baseURL || template.baseURL,
+    model: overrides.model || template.model,
+    apiKeyEnv: overrides.apiKeyEnv || template.apiKeyEnv,
+    temperature: overrides.temperature ?? 0.3,
+    maxTokens: overrides.maxTokens || 4096,
+    _template: templateName,
+  };
+}
+
+/**
+ * List all built-in templates with key info.
+ * @returns {Array<{name: string, provider: string, model: string, apiKeyEnv: string, desc: string, tier: string}>}
+ */
+function listTemplates() {
+  return Object.entries(BUILTIN_TEMPLATES).map(([name, t]) => ({
+    name,
+    provider: t.provider,
+    model: t.model,
+    apiKeyEnv: t.apiKeyEnv,
+    desc: t.desc,
+    tier: t.tier,
+  }));
+}
+
+/**
+ * Get a single template by name. Returns null if not found.
+ */
+function getTemplate(name) {
+  return BUILTIN_TEMPLATES[name] || null;
+}
+
+module.exports = {
+  BUILTIN_TEMPLATES,
+  resolveTemplate,
+  listTemplates,
+  getTemplate,
+};

package/src/models.test.js

@@ -0,0 +1,80 @@
+const { describe, it } = require('node:test');
+const assert = require('assert');
+const { BUILTIN_TEMPLATES, resolveTemplate, listTemplates, getTemplate } = require('./models');
+
+describe('models.js', () => {
+  it('should have all 11 built-in templates', () => {
+    const templates = listTemplates();
+    assert.strictEqual(templates.length, 11);
+  });
+
+  it('should resolve deepseek template correctly', () => {
+    const result = resolveTemplate('deepseek');
+    assert.strictEqual(result.provider, 'deepseek');
+    assert.strictEqual(result.model, 'deepseek-chat');
+    assert.strictEqual(result.baseURL, 'https://api.deepseek.com');
+    assert.strictEqual(result.apiKeyEnv, 'DEEPSEEK_API_KEY');
+    assert.strictEqual(result._template, 'deepseek');
+  });
+
+  it('should resolve qwen template with openai-compatible provider', () => {
+    const result = resolveTemplate('qwen');
+    assert.strictEqual(result.provider, 'openai');
+    assert.strictEqual(result.model, 'qwen-plus');
+    assert.ok(result.baseURL.includes('dashscope'));
+    assert.strictEqual(result.apiKeyEnv, 'DASHSCOPE_API_KEY');
+  });
+
+  it('should apply user overrides on template', () => {
+    const result = resolveTemplate('openai', {
+      model: 'gpt-4o-mini',
+      temperature: 0.1,
+    });
+    assert.strictEqual(result.provider, 'openai');
+    assert.strictEqual(result.model, 'gpt-4o-mini');
+    assert.strictEqual(result.temperature, 0.1);
+    assert.strictEqual(result._template, 'openai');
+  });
+
+  it('should throw on unknown template', () => {
+    assert.throws(() => resolveTemplate('nonexistent'), {
+      message: /Unknown model template/,
+    });
+  });
+
+  it('getTemplate should return null for unknown', () => {
+    assert.strictEqual(getTemplate('nonexistent'), null);
+  });
+
+  it('getTemplate should return object for known', () => {
+    const t = getTemplate('deepseek');
+    assert.ok(t);
+    assert.strictEqual(t.model, 'deepseek-chat');
+  });
+
+  it('listTemplates should return array with required fields', () => {
+    const templates = listTemplates();
+    for (const t of templates) {
+      assert.ok(t.name, `template should have name: ${JSON.stringify(t)}`);
+      assert.ok(t.provider, `template should have provider: ${JSON.stringify(t)}`);
+      assert.ok(t.model, `template should have model: ${JSON.stringify(t)}`);
+      assert.ok(t.apiKeyEnv, `template should have apiKeyEnv: ${JSON.stringify(t)}`);
+      assert.ok(t.desc, `template should have desc: ${JSON.stringify(t)}`);
+    }
+  });
+
+  it('should have recommended and reasoning tiers', () => {
+    const templates = listTemplates();
+    const recommended = templates.filter(t => t.tier === 'recommended');
+    const reasoning = templates.filter(t => t.tier === 'reasoning');
+    assert.ok(recommended.length >= 2, 'should have at least 2 recommended templates');
+    assert.ok(reasoning.length >= 2, 'should have at least 2 reasoning templates');
+  });
+
+  it('deepseek-r1 should be a reasoning model', () => {
+    const t = getTemplate('deepseek-r1');
+    assert.ok(t);
+    assert.strictEqual(t.tier, 'reasoning');
+    assert.strictEqual(t.model, 'deepseek-reasoner');
+  });
+});

package/src/reviewer.js

@@ -186,7 +186,8 @@ async function runParallelAgents(apiKey, config, prompts) {
 
   const tasks = prompts.map(async (p) => {
     try {
-      const text = await callAI(apiKey, p.messages, config);
+      // Pass agent name so callAI can select per-agent model config
+      const text = await callAI(apiKey, p.messages, config, p.role.name);
       const parsed = parseReviewResponse(text);
       return { name: p.role.name, success: true, ...parsed };
     } catch (err) {
@@ -440,32 +441,84 @@ Important:
 }
 
 /**
- * Call the AI provider.
+ * Call the AI provider with support for:
+ * - Per-agent model selection (ai.agents[agentType])
+ * - Primary/fallback model switching (ai.fallback)
+ *
+ * @param {string} apiKey - API key
+ * @param {Array} messages - Chat messages
+ * @param {object} config - Full config object
+ * @param {string} [agentType] - Agent type for per-agent model selection ('security'|'bugs'|'quality')
+ * @returns {Promise<string>} AI response text
  */
-async function callAI(apiKey, messages, config) {
+async function callAI(apiKey, messages, config, agentType) {
   const aiConfig = config.ai || {};
-  const provider = aiConfig.provider || 'openai';
 
-  const OpenAI = require('openai');
+  // Resolve model config for this agent
+  let modelConfig = { ...aiConfig };
+  if (agentType && aiConfig.agents && aiConfig.agents[agentType]) {
+    const agentCfg = aiConfig.agents[agentType];
+    modelConfig = { ...aiConfig, ...agentCfg };
+  }
 
-  // Determine base URL from provider or config
-  let baseURL = aiConfig.baseURL;
+  const provider = modelConfig.provider || 'openai';
+
+  // Determine base URL
+  let baseURL = modelConfig.baseURL;
   if (!baseURL) {
     if (provider === 'deepseek') baseURL = 'https://api.deepseek.com';
-    // openai and all others default to undefined (official endpoint)
   }
 
-  const defaultModels = {
-    openai: 'gpt-4o',
-    deepseek: 'deepseek-chat',
-  };
+  const defaultModels = { openai: 'gpt-4o', deepseek: 'deepseek-chat' };
+  const model = modelConfig.model || defaultModels[provider] || provider;
+
+  // Try primary model first
+  try {
+    return await _doCallAI(apiKey, messages, {
+      model,
+      baseURL,
+      temperature: modelConfig.temperature ?? 0.3,
+      maxTokens: modelConfig.maxTokens || 4096,
+    });
+  } catch (err) {
+    const fallback = aiConfig.fallback;
+    const fallbackEnabled = fallback && fallback.enabled !== false;
+
+    if (!fallbackEnabled || !fallback.model) {
+      throw err;
+    }
 
+    // Log fallback attempt (visible in --debug mode)
+    const chalk = require('chalk');
+    console.error(chalk.yellow(`⚠️  Primary model failed: ${err.message}`));
+    console.error(chalk.blue(`↩  Falling back to ${fallback.model}...`));
+
+    const fbProvider = fallback.provider || provider;
+    let fbBaseURL = fallback.baseURL;
+    if (!fbBaseURL) {
+      if (fbProvider === 'deepseek') fbBaseURL = 'https://api.deepseek.com';
+    }
+
+    return await _doCallAI(apiKey, messages, {
+      model: fallback.model,
+      baseURL: fbBaseURL,
+      temperature: fallback.temperature ?? 0.3,
+      maxTokens: fallback.maxTokens || 4096,
+    });
+  }
+}
+
+/**
+ * Internal: make a single AI call.
+ */
+async function _doCallAI(apiKey, messages, { model, baseURL, temperature, maxTokens }) {
+  const OpenAI = require('openai');
   const client = new OpenAI({ apiKey, baseURL: baseURL || undefined });
 
   const response = await client.chat.completions.create({
-    model: aiConfig.model || defaultModels[provider] || provider,
-    temperature: aiConfig.temperature ?? 0.3,
-    max_tokens: aiConfig.maxTokens || 4096,
+    model,
+    temperature,
+    max_tokens: maxTokens,
     messages,
   });