coderev-cli 1.0.22 → 1.0.24

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "coderev-cli",
-  "version": "1.0.22",
+  "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,236 @@ 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>')
+  .description('Manage rule packs from the coderev marketplace')
+  .option('-q, --query <text>', 'Search query')
+  .option('-n, --name <name>', 'Rule pack name')
+  .option('--version <ver>', 'Version for publish', '1.0.0')
+  .option('--desc <text>', 'Description for publish')
+  .option('--api-url <url>', 'Marketplace API URL')
+  .action(async (action, options) => {
+    try {
+      const { searchRules, installRule, publishRules, listInstalled, uninstallRule, DEFAULT_API_URL } = require('./rules-market');
+      const apiUrl = options.apiUrl || process.env.CODEREV_MARKETPLACE_URL || DEFAULT_API_URL;
+
+      switch (action) {
+        case 'search': {
+          console.log(chalk.blue(`🔍 Searching marketplace for "${options.query || ''}"...`));
+          const results = await searchRules(options.query || '', apiUrl);
+          if (!Array.isArray(results) || results.length === 0) {
+            console.log(chalk.yellow('No rule packs found.'));
+          } else {
+            console.log(chalk.bold(`\nFound ${results.length} rule pack(s):\n`));
+            for (const pack of results) {
+              console.log(chalk.green(`  📦 ${pack.name}`) + chalk.gray(` v${pack.version}`));
+              console.log(`     ${pack.description || '(no description)'}`);
+              console.log(chalk.gray(`     ${pack.rules || 0} rules  •  ${pack.downloads || 0} downloads  •  by ${pack.author || 'unknown'}`));
+              console.log('');
+            }
+            console.log(chalk.blue(`Install: coderev rules install <name>`));
+          }
+          break;
+        }
+
+        case 'install': {
+          const name = options.name || options.query;
+          if (!name) {
+            console.error(chalk.red('✖ Please specify a rule pack name: coderev rules install <name>'));
+            process.exit(1);
+          }
+          console.log(chalk.blue(`📥 Installing "${name}"...`));
+          const result = await installRule(name, apiUrl);
+          console.log(chalk.green(`✔ Installed ${result.name} v${result.version}`));
+          console.log(chalk.gray(`  ${result.added}/${result.total} rules added to .coderevrc.json`));
+          break;
+        }
+
+        case 'publish': {
+          console.log(chalk.blue('📤 Publishing rules to marketplace...'));
+          const result = await publishRules(apiUrl, {
+            name: options.name,
+            version: options.version,
+            description: options.desc,
+          });
+          console.log(chalk.green(`✔ Published "${result.name}" v${options.version} (${result.rules} rules)`));
+          break;
+        }
+
+        case 'list': {
+          const result = listInstalled();
+          if (result.packs.length === 0) {
+            console.log(chalk.yellow(result.message));
+          } else {
+            console.log(chalk.bold(`\n📦 Installed rule packs (${result.packs.length}):\n`));
+            for (const pack of result.packs) {
+              console.log(chalk.green(`  📦 ${pack.name}`) + chalk.gray(` v${pack.version}`));
+              console.log(chalk.gray(`     ${pack.rules} rules  •  installed ${new Date(pack.installedAt).toLocaleDateString()}`));
+            }
+          }
+          break;
+        }
+
+        case 'uninstall': {
+          const name = options.name || options.query;
+          if (!name) {
+            console.error(chalk.red('✖ Please specify a rule pack name: coderev rules uninstall <name>'));
+            process.exit(1);
+          }
+          const result = uninstallRule(name);
+          console.log(chalk.green(`✔ Uninstalled "${result.name}"`));
+          break;
+        }
+
+        case 'info': {
+          const name = options.name || options.query;
+          if (!name) {
+            console.error(chalk.red('✖ Please specify a rule pack name: coderev rules info <name>'));
+            process.exit(1);
+          }
+          const pack = await apiRequest(apiUrl, `/rules/${encodeURIComponent(name)}`);
+          console.log(chalk.bold(`\n📦 ${pack.name}`) + chalk.gray(` v${pack.version}`));
+          console.log(`   ${pack.description || '(no description)'}`);
+          console.log(chalk.gray(`   ${pack.rules?.length || 0} rules  •  by ${pack.author || 'unknown'}`));
+          if (pack.rules && pack.rules.length > 0) {
+            console.log(chalk.bold('\n   Rules:'));
+            for (const r of pack.rules) {
+              const sev = r.severity === 'error' ? chalk.red(r.severity) : r.severity === 'warning' ? chalk.yellow(r.severity) : chalk.gray(r.severity);
+              console.log(`   - ${r.name} [${sev}] ${r.message || ''}`);
+            }
+          }
+          break;
+        }
+
+        default:
+          console.error(chalk.red(`✖ Unknown action "${action}". Use: search | install | publish | list | uninstall | info`));
+          process.exit(1);
+      }
+    } catch (err) {
+      console.error(chalk.red(`✖ ${err.message}`));
+      process.exit(1);
+    }
+  });
+
 program.parse(process.argv);
 
 // ── Helpers ───────────────────────────────────────────────────

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,
   });
 

package/src/rules-market.js

@@ -0,0 +1,257 @@
+/**
+ * Rules Market — SaaS cloud rule repository for coderev.
+ *
+ * Commands:
+ *   coderev rules search <query>   Search the rule marketplace
+ *   coderev rules install <name>   Install a rule pack from the marketplace
+ *   coderev rules publish          Publish local rules to the marketplace
+ *   coderev rules list             List installed rule packs
+ *
+ * API Base: configurable via .coderevrc.json → marketplace.apiUrl
+ * Default: https://rules.coderev.dev/api
+ */
+
+const fs = require('fs');
+const path = require('path');
+const https = require('https');
+const http = require('http');
+
+const DEFAULT_API_URL = 'https://rules.coderev.dev/api';
+const MARKETPLACE_DIR = '.coderev-marketplace';
+const INSTALLED_MANIFEST = 'installed.json';
+
+// ── API Client ───────────────────────────────────────────
+
+/**
+ * Make an HTTP request to the marketplace API.
+ */
+function apiRequest(apiUrl, endpoint, method = 'GET', body = null) {
+  const url = new URL(`${apiUrl}${endpoint}`);
+  const isHttps = url.protocol === 'https:';
+  const transport = isHttps ? https : http;
+
+  return new Promise((resolve, reject) => {
+    const options = {
+      hostname: url.hostname,
+      port: url.port || (isHttps ? 443 : 80),
+      path: url.pathname + url.search,
+      method,
+      headers: {
+        'Accept': 'application/json',
+        'User-Agent': 'coderev-cli',
+        ...(body ? { 'Content-Type': 'application/json' } : {}),
+      },
+      timeout: 15000,
+    };
+
+    const req = transport.request(options, (res) => {
+      let data = '';
+      res.on('data', (chunk) => (data += chunk));
+      res.on('end', () => {
+        try {
+          const json = JSON.parse(data);
+          if (res.statusCode >= 400) {
+            reject(new Error(json.error || `API error: ${res.statusCode}`));
+          } else {
+            resolve(json);
+          }
+        } catch (e) {
+          reject(new Error(`Invalid API response: ${data.slice(0, 200)}`));
+        }
+      });
+    });
+
+    req.on('timeout', () => {
+      req.destroy();
+      reject(new Error('API request timed out'));
+    });
+    req.on('error', (err) => reject(new Error(`API connection failed: ${err.message}`)));
+
+    if (body) req.write(JSON.stringify(body));
+    req.end();
+  });
+}
+
+// ── Marketplace Directory ────────────────────────────────
+
+function getMarketplaceDir() {
+  return path.join(process.cwd(), MARKETPLACE_DIR);
+}
+
+function getInstalledManifest() {
+  const dir = getMarketplaceDir();
+  const manifestPath = path.join(dir, INSTALLED_MANIFEST);
+  if (!fs.existsSync(manifestPath)) return { packs: [] };
+  return JSON.parse(fs.readFileSync(manifestPath, 'utf-8'));
+}
+
+function saveInstalledManifest(manifest) {
+  const dir = getMarketplaceDir();
+  if (!fs.existsSync(dir)) fs.mkdirSync(dir, { recursive: true });
+  fs.writeFileSync(path.join(dir, INSTALLED_MANIFEST), JSON.stringify(manifest, null, 2));
+}
+
+// ── Search ───────────────────────────────────────────────
+
+async function searchRules(query, apiUrl) {
+  const endpoint = query
+    ? `/rules?q=${encodeURIComponent(query)}`
+    : '/rules';
+  const result = await apiRequest(apiUrl, endpoint);
+  return result.rules || result;
+}
+
+// ── Install ──────────────────────────────────────────────
+
+async function installRule(packName, apiUrl) {
+  // Fetch rule pack from marketplace
+  const pack = await apiRequest(apiUrl, `/rules/${encodeURIComponent(packName)}`);
+
+  if (!pack || !pack.rules) {
+    throw new Error(`Rule pack "${packName}" not found or empty`);
+  }
+
+  // Merge into local .coderevrc.json
+  const configPath = path.join(process.cwd(), '.coderevrc.json');
+  let config = {};
+  if (fs.existsSync(configPath)) {
+    config = JSON.parse(fs.readFileSync(configPath, 'utf-8'));
+  }
+
+  // Ensure custom rules array exists
+  if (!config.rules) config.rules = {};
+  if (!config.rules.custom) config.rules.custom = [];
+
+  // Add pack rules (skip duplicates by name)
+  let added = 0;
+  for (const rule of pack.rules) {
+    const exists = config.rules.custom.some(r => r.name === rule.name);
+    if (!exists) {
+      config.rules.custom.push({
+        ...rule,
+        _source: packName,
+        _version: pack.version,
+      });
+      added++;
+    }
+  }
+
+  fs.writeFileSync(configPath, JSON.stringify(config, null, 2));
+
+  // Record installation
+  const manifest = getInstalledManifest();
+  const existing = manifest.packs.findIndex(p => p.name === packName);
+  if (existing >= 0) {
+    manifest.packs[existing] = {
+      name: packName,
+      version: pack.version,
+      rules: pack.rules.length,
+      installedAt: new Date().toISOString(),
+    };
+  } else {
+    manifest.packs.push({
+      name: packName,
+      version: pack.version,
+      rules: pack.rules.length,
+      installedAt: new Date().toISOString(),
+    });
+  }
+  saveInstalledManifest(manifest);
+
+  return { name: packName, version: pack.version, added, total: pack.rules.length };
+}
+
+// ── Publish ───────────────────────────────────────────────
+
+async function publishRules(apiUrl, options = {}) {
+  const configPath = path.join(process.cwd(), '.coderevrc.json');
+  if (!fs.existsSync(configPath)) {
+    throw new Error('No .coderevrc.json found. Run `coderev init` first.');
+  }
+
+  const config = JSON.parse(fs.readFileSync(configPath, 'utf-8'));
+  const rules = config.rules?.custom || [];
+
+  if (rules.length === 0) {
+    throw new Error('No custom rules found in .coderevrc.json');
+  }
+
+  const packName = options.name || path.basename(process.cwd());
+  const payload = {
+    name: packName,
+    version: options.version || '1.0.0',
+    description: options.description || `Rules from ${packName}`,
+    rules: rules.map(r => ({
+      name: r.name,
+      pattern: r.pattern,
+      severity: r.severity || 'warning',
+      message: r.message,
+      filePattern: r.filePattern,
+      category: r.category || 'style',
+    })),
+  };
+
+  const result = await apiRequest(apiUrl, '/rules', 'POST', payload);
+
+  return { name: packName, version: payload.version, rules: rules.length, published: true };
+}
+
+// ── List Installed ───────────────────────────────────────
+
+function listInstalled() {
+  const manifest = getInstalledManifest();
+
+  if (manifest.packs.length === 0) {
+    return { packs: [], message: 'No rule packs installed. Use `coderev rules search` to find rules.' };
+  }
+
+  return { packs: manifest.packs };
+}
+
+// ── Uninstall ─────────────────────────────────────────────
+
+function uninstallRule(packName) {
+  const manifest = getInstalledManifest();
+  const idx = manifest.packs.findIndex(p => p.name === packName);
+  if (idx < 0) {
+    throw new Error(`Rule pack "${packName}" is not installed.`);
+  }
+
+  manifest.packs.splice(idx, 1);
+  saveInstalledManifest(manifest);
+
+  // Also remove from .coderevrc.json
+  const configPath = path.join(process.cwd(), '.coderevrc.json');
+  if (fs.existsSync(configPath)) {
+    const config = JSON.parse(fs.readFileSync(configPath, 'utf-8'));
+    if (config.rules?.custom) {
+      config.rules.custom = config.rules.custom.filter(r => r._source !== packName);
+      fs.writeFileSync(configPath, JSON.stringify(config, null, 2));
+    }
+  }
+
+  return { name: packName, removed: true };
+}
+
+// ── Search Local ──────────────────────────────────────────
+
+function searchLocalRules(query) {
+  const manifest = getInstalledManifest();
+  if (!query) return manifest.packs;
+
+  const q = query.toLowerCase();
+  return manifest.packs.filter(
+    p => p.name.toLowerCase().includes(q)
+  );
+}
+
+module.exports = {
+  searchRules,
+  installRule,
+  publishRules,
+  listInstalled,
+  uninstallRule,
+  searchLocalRules,
+  DEFAULT_API_URL,
+  getMarketplaceDir,
+};