devassist-agent 1.0.0

package/src/ai/adapter.js

@@ -0,0 +1,464 @@
+/**
+ * AI Adapter - unified interface for multiple LLM providers.
+ *
+ * Core principle: "Rules engine first, AI second."
+ * The AI adapter is only called when the rule engine flags a "suspect" finding
+ * that needs deeper analysis. This saves tokens and keeps latency low.
+ *
+ * Supported providers:
+ *   - qwen    (通义千问, Alibaba)
+ *   - openai  (GPT, OpenAI)
+ *   - claude  (Claude, Anthropic)
+ *   - hunyuan (混元, Tencent)
+ *
+ * Degradation strategy: if AI is unreachable, return rule engine results as-is
+ * with a flag "ai_analysis_unavailable: true".
+ */
+
+const { Logger } = require('../core/logger');
+const log = new Logger('AIAdapter');
+
+// Provider registry
+const providers = {};
+
+/**
+ * Register a provider implementation.
+ * Each provider must implement:
+ *   async chat(messages, options) -> { content, usage, model }
+ */
+function registerProvider(name, impl) {
+  providers[name] = impl;
+  log.info(`已注册 AI provider：${name}`);
+}
+
+/**
+ * Get a provider by name.
+ */
+function getProvider(name) {
+  return providers[name];
+}
+
+/**
+ * List registered providers.
+ */
+function listProviders() {
+  return Object.keys(providers);
+}
+
+/**
+ * Unified AI analysis interface.
+ * Takes findings from the rule engine and asks the AI for deeper analysis.
+ *
+ * @param {object} config - { provider, apiKey, model, baseUrl }
+ * @param {Array} findings - rule engine findings to analyze
+ * @param {object} context - { files, conventions, projectInfo }
+ * @returns {Promise<Array>} - findings enriched with AI analysis
+ */
+async function analyze(config, findings, context) {
+  if (!config || !config.provider || !providers[config.provider]) {
+    log.warn('未配置 AI provider——仅返回规则引擎结果');
+    return findings.map(f => ({ ...f, aiAnalysis: null, aiAnalysisUnavailable: true }));
+  }
+
+  const provider = providers[config.provider];
+
+  // Only send findings that are 'warn' or 'block' to AI (save tokens)
+  const suspectFindings = findings.filter(f => f.severity === 'block' || f.severity === 'warn');
+
+  if (suspectFindings.length === 0) {
+    log.info('无疑似问题需要发送给 AI');
+    return findings;
+  }
+
+  // Batch processing: split into chunks to avoid timeout on large finding sets
+  const BATCH_SIZE = 20;
+  const batches = [];
+  for (let i = 0; i < suspectFindings.length; i += BATCH_SIZE) {
+    batches.push(suspectFindings.slice(i, i + BATCH_SIZE));
+  }
+
+  log.info(`发送 ${suspectFindings.length} 个发现给 ${config.provider}（${config.model || '默认模型'}），分 ${batches.length} 批`);
+
+  let allAIAnalysis = [];
+  let lastModel = config.model || 'unknown';
+
+  for (let i = 0; i < batches.length; i++) {
+    const { systemPrompt, userPrompt } = buildPrompt(batches[i], context);
+    const messages = [
+      { role: 'system', content: systemPrompt },
+      { role: 'user', content: userPrompt },
+    ];
+
+    try {
+      const result = await provider.chat(messages, {
+        apiKey: config.apiKey,
+        model: config.model,
+        baseUrl: config.baseUrl,
+        temperature: 0.1,
+        maxTokens: 4000,
+      });
+
+      const batchAnalysis = parseAIResponse(result.content);
+      allAIAnalysis = allAIAnalysis.concat(batchAnalysis);
+      lastModel = result.model;
+    } catch (err) {
+      log.error(`AI 分析失败（批次 ${i + 1}/${batches.length}）：${err.message}`);
+      // Continue with remaining batches if one fails
+    }
+  }
+
+  if (allAIAnalysis.length === 0) {
+    // All batches failed
+    return findings.map(f => ({
+      ...f,
+      aiAnalysis: null,
+      aiAnalysisUnavailable: true,
+      aiError: '所有批次分析均失败',
+    }));
+  }
+
+  // Merge AI analysis back into findings
+  // Use a multi-strategy matching approach for better accuracy
+  return findings.map(f => {
+    // Strategy 1: Match by ruleId + file path
+    let aiMatch = allAIAnalysis.find(a =>
+      a.ruleId === f.ruleId && a.file && f.file &&
+      f.file.includes(a.file) || (a.file && a.file.includes(f.file.split(/[\\\/]/).pop()))
+    );
+    // Strategy 2: Match by ruleId only (if unique in this batch)
+    if (!aiMatch) {
+      const sameRule = allAIAnalysis.filter(a => a.ruleId === f.ruleId);
+      if (sameRule.length === 1) {
+        aiMatch = sameRule[0];
+      }
+    }
+    // Strategy 3: Match by ruleId + partial message
+    if (!aiMatch && f.ruleId) {
+      aiMatch = allAIAnalysis.find(a =>
+        a.ruleId === f.ruleId && a.rootCause &&
+        (a.rootCause.includes(f.file?.split(/[\\\/]/).pop() || '') ||
+         a.rootCause.includes(String(f.line || '')))
+      );
+    }
+    return {
+      ...f,
+      aiAnalysis: aiMatch || null,
+      aiModel: lastModel,
+    };
+  });
+}
+
+/**
+ * Build the system and user prompts for AI analysis.
+ */
+function buildPrompt(findings, context) {
+  const systemPrompt = `你是一个集成在开发护栏工具（DevAssist）中的代码分析专家。
+你的职责是分析静态规则引擎发现的代码问题，给出精准的根因分析和修复建议。
+
+## 输出格式（严格）
+
+以 JSON 数组格式回复，每个发现对应一个对象。不要输出 JSON 以外的文字：
+[
+  {
+    "ruleId": "<必须与输入中的 ruleId 完全一致>",
+    "rootCause": "<2-4句根因分析，必须具体到当前代码，不能是通用模板>",
+    "isFalsePositive": false,
+    "falsePositiveReason": "<如果是误报，说明原因；如果不是误报，留空>",
+    "fix": "<具体修复步骤，含函数名/变量名>",
+    "codeExample": "<修复后的代码片段，可选>",
+    "confidence": 0.85,
+    "category": "<bug|security|performance|convention|maintainability>"
+  }
+]
+
+## 根因分析规则
+
+分析必须针对当前代码的具体上下文，禁止通用模板回复。按以下框架分析：
+
+1. **是什么**：代码做了什么导致触发规则？引用具体的代码行/变量名
+2. **为什么错**：这个问题会导致什么后果？（崩溃/安全漏洞/性能退化/维护困难）
+3. **AI Agent 视角**：如果这是 AI Agent（Cursor/Trae/WorkBuddy）生成的代码，最可能的原因是什么？
+   - AI 常见错误模式：局部编辑不看全局、约定漂移、过度工程化、幻觉 API、忽略已有代码直接覆盖
+4. **修复方向**：最小改动原则——不引入新的复杂度
+
+## 误报判定标准
+
+以下情况判定为误报（isFalsePositive: true）：
+- 规则引擎自身的测试代码（test/ 目录、测试 fixture 中的故意错误）
+- 代码中的字符串/注释/正则表达式被误匹配（不是真正的代码执行）
+- 已有保护措施但规则引擎未检测到（如上层有 try/catch、已有空值检查）
+- 代码库基础设施代码（如 Logger、配置加载器）中的合理模式
+
+以下情况**不是**误报：
+- 真实的变量/函数名冲突
+- 真实的缺失保护（即使当前不会触发，但属于防御性编程缺失）
+- 真实的约定违规（项目中确实存在多种不一致的模式）
+
+## 项目背景
+
+- 项目使用 AI Agent（Cursor/Trae/WorkBuddy）辅助开发
+- 常见问题模式：AI 覆盖大文件丢失既有逻辑、约定漂移（命名/格式不统一）、局部优化破坏全局一致性
+- 分析要具体、有针对性，直接引用代码中的变量名和函数名`;
+
+  let userPrompt = `请分析以下 ${findings.length} 个发现：\n\n`;
+
+  // Add convention context if available
+  if (context && context.conventions && context.conventions.length > 0) {
+    userPrompt += `## 项目约定\n`;
+    for (const c of context.conventions.slice(0, 10)) {
+      userPrompt += `- ${c.id || c.rule}: ${c.rule || c.description || ''}\n`;
+    }
+    userPrompt += '\n';
+  }
+
+  // Add project info if available
+  if (context && context.projectInfo && context.projectInfo.root) {
+    userPrompt += `## 项目信息\n- 项目根目录: ${context.projectInfo.root}\n\n`;
+  }
+
+  // Add findings (with code context for deeper analysis)
+  findings.forEach((f, i) => {
+    userPrompt += `### 发现 ${i + 1}\n`;
+    userPrompt += `- 规则ID: ${f.ruleId || '(无)'}\n`;
+    userPrompt += `- 严重级别: ${f.severity}\n`;
+    userPrompt += `- 类别: ${f.category || '(未分类)'}\n`;
+    userPrompt += `- 文件: ${f.file}\n`;
+    if (f.line) userPrompt += `- 行号: ${f.line}\n`;
+    userPrompt += `- 问题描述: ${f.message}\n`;
+    if (f.suggestion) userPrompt += `- 规则建议: ${f.suggestion}\n`;
+    if (f.context) userPrompt += `- 规则上下文: ${JSON.stringify(f.context)}\n`;
+    // Include actual code context so AI can see the problem
+    if (f.codeContext) {
+      userPrompt += `\n代码上下文：\n\`\`\`\n${f.codeContext}\n\`\`\`\n`;
+    }
+    userPrompt += '\n';
+  });
+
+  userPrompt += `请严格按照 JSON 数组格式回复，确保每个发现的 ruleId 与上述输入一致。`;
+
+  return { systemPrompt, userPrompt };
+}
+
+/**
+ * Parse AI response into structured analysis objects.
+ * Handles common LLM response formats: JSON arrays, markdown-wrapped JSON,
+ * and partial/truncated JSON.
+ */
+function parseAIResponse(content) {
+  // Strategy 1: Direct JSON parse
+  try {
+    const parsed = JSON.parse(content);
+    if (Array.isArray(parsed)) return parsed;
+    if (parsed && typeof parsed === 'object') return [parsed];
+  } catch (_) {}
+
+  // Strategy 2: Extract JSON array from markdown code blocks or mixed text
+  const jsonMatch = content.match(/\[[\s\S]*\]/);
+  if (jsonMatch) {
+    try {
+      return JSON.parse(jsonMatch[0]);
+    } catch (_) {
+      // Strategy 3: Try to fix truncated JSON array
+      // Find all complete objects in the array
+      const objects = [];
+      const objRegex = /\{[^{}]*\}/g;
+      let objMatch;
+      while ((objMatch = objRegex.exec(jsonMatch[0])) !== null) {
+        try {
+          objects.push(JSON.parse(objMatch[0]));
+        } catch (_) {}
+      }
+      if (objects.length > 0) return objects;
+    }
+  }
+
+  // Strategy 4: Extract individual JSON objects from text
+  const objRegex2 = /\{[^{}]*\}/g;
+  const objects2 = [];
+  let objMatch2;
+  while ((objMatch2 = objRegex2.exec(content)) !== null) {
+    try {
+      const obj = JSON.parse(objMatch2[0]);
+      if (obj.ruleId || obj.rootCause || obj.fix) {
+        objects2.push(obj);
+      }
+    } catch (_) {}
+  }
+  if (objects2.length > 0) return objects2;
+
+  // Strategy 5: Fallback - treat as plain text analysis
+  return [{
+    ruleId: '*',
+    rootCause: content.substring(0, 500),
+    isFalsePositive: false,
+    fix: '参见上方根因分析',
+    confidence: 0.3,
+  }];
+}
+
+/**
+ * Multi-engine analysis.
+ * Runs N providers in parallel and returns findings enriched with all analyses.
+ *
+ * Each engine config: { provider, apiKey, model, baseUrl, name?, id? }
+ *
+ * Finding enrichment:
+ *   f.aiAnalyses = [
+ *     { engineId, engineName, provider, model, analysis, available, error },
+ *     ...
+ *   ]
+ *
+ * For backward compatibility with 2-engine code:
+ *   f.aiAnalysis     = aiAnalyses[0]?.analysis
+ *   f.aiAnalysis2    = aiAnalyses[1]?.analysis
+ *   f.aiAnalysisUnavailable  = !aiAnalyses[0]?.available
+ *   f.aiAnalysis2Unavailable = !aiAnalyses[1]?.available
+ *
+ * @param {Array} engineConfigs - array of { provider, apiKey, model, baseUrl, name?, id? }
+ * @param {Array} findings      - rule engine findings to analyze
+ * @param {object} context      - { files, conventions, projectInfo }
+ * @returns {Promise<Array>}    - findings enriched with aiAnalyses array
+ */
+async function multiAnalyze(engineConfigs, findings, context) {
+  if (!engineConfigs || engineConfigs.length === 0) {
+    log.warn('未配置任何 AI 引擎');
+    return findings.map(f => ({ ...f, aiAnalyses: [], aiAnalysis: null, aiAnalysisUnavailable: true }));
+  }
+
+  // Deduplicate by provider+model (avoid running same engine twice)
+  const seen = new Set();
+  const engines = engineConfigs.filter(cfg => {
+    if (!cfg || !cfg.provider || !providers[cfg.provider]) {
+      log.warn(`跳过未注册的 provider: ${cfg?.provider}`);
+      return false;
+    }
+    const key = `${cfg.provider}:${cfg.model || ''}`;
+    if (seen.has(key)) return false;
+    seen.add(key);
+    return true;
+  });
+
+  if (engines.length === 0) {
+    log.warn('无有效的 AI 引擎');
+    return findings.map(f => ({ ...f, aiAnalyses: [], aiAnalysis: null, aiAnalysisUnavailable: true }));
+  }
+
+  log.info(`多引擎分析：${engines.length} 个引擎并行（${engines.map(e => e.provider).join(', ')}）`);
+
+  // Run all engines in parallel
+  const results = await Promise.allSettled(
+    engines.map(cfg => analyze(cfg, findings, context))
+  );
+
+  // Build per-engine result maps: key -> analysis
+  const engineMaps = results.map((result, idx) => {
+    const engine = engines[idx];
+    const engineId = engine.id || engine.provider;
+    const engineName = engine.name || engine.provider;
+    const map = new Map();
+
+    if (result.status === 'fulfilled') {
+      for (const f of result.value) {
+        const key = `${f.file}:${f.line}:${f.ruleId}`;
+        map.set(key, {
+          analysis: f.aiAnalysis || null,
+          available: !f.aiAnalysisUnavailable,
+          error: f.aiError || null,
+        });
+      }
+    } else {
+      log.error(`引擎 [${engine.provider}] 分析失败：${result.reason?.message}`);
+    }
+
+    return { engineId, engineName, provider: engine.provider, model: engine.model, map, failed: result.status !== 'fulfilled', error: result.reason?.message };
+  });
+
+  // Merge all engine results into findings
+  return findings.map(f => {
+    const key = `${f.file}:${f.line}:${f.ruleId}`;
+    const aiAnalyses = engineMaps.map(em => {
+      const entry = em.map.get(key);
+      return {
+        engineId: em.engineId,
+        engineName: em.engineName,
+        provider: em.provider,
+        model: em.model,
+        analysis: entry?.analysis || null,
+        available: entry ? entry.available : !em.failed,
+        error: entry?.error || (em.failed ? em.error : null),
+      };
+    });
+
+    // Backward compatibility: populate legacy fields
+    const primary = aiAnalyses[0];
+    const secondary = aiAnalyses[1];
+    const enriched = {
+      ...f,
+      aiAnalyses,
+      aiAnalysis: primary?.analysis || null,
+      aiAnalysisUnavailable: primary ? !primary.available : true,
+      aiError: primary?.error || null,
+    };
+    if (secondary) {
+      enriched.aiAnalysis2 = secondary.analysis || null;
+      enriched.aiAnalysis2Unavailable = !secondary.available;
+      enriched.aiError2 = secondary.error || null;
+    }
+
+    return enriched;
+  });
+}
+
+/**
+ * Dual-engine comparison analysis (backward compatibility wrapper).
+ * Delegates to multiAnalyze with 2 engine configs.
+ */
+async function compareAnalyze(primaryConfig, secondaryConfig, findings, context) {
+  return multiAnalyze([primaryConfig, secondaryConfig], findings, context);
+}
+
+/**
+ * Ask a free-form question to the AI.
+ * Used for the "smart Q&A" feature.
+ */
+async function ask(config, question, context) {
+  if (!config || !config.provider || !providers[config.provider]) {
+    return { content: 'AI provider 尚未配置。请在 .devassist/ai-config.json 中设置。', unavailable: true };
+  }
+
+  const provider = providers[config.provider];
+  const systemPrompt = `你是一个项目开发助手，服务于使用 AI Agent 进行开发的项目。
+回答关于代码、架构和最佳实践的问题。
+回答要简洁、针对当前项目。${context?.conventions ? '\n\n项目约定：\n' + context.conventions : ''}`;
+
+  try {
+    const result = await provider.chat(
+      [
+        { role: 'system', content: systemPrompt },
+        { role: 'user', content: question },
+      ],
+      {
+        apiKey: config.apiKey,
+        model: config.model,
+        baseUrl: config.baseUrl,
+        temperature: 0.3,
+        maxTokens: 1500,
+      }
+    );
+    return { content: result.content, model: result.model };
+  } catch (err) {
+    log.error(`AI 问答失败：${err.message}`);
+    return { content: `AI 请求失败：${err.message}`, error: true };
+  }
+}
+
+module.exports = {
+  registerProvider,
+  getProvider,
+  listProviders,
+  analyze,
+  multiAnalyze,
+  compareAnalyze,
+  ask,
+  buildPrompt,
+};

package/src/ai/providers/claude.js

@@ -0,0 +1,80 @@
+/**
+ * Claude provider (Anthropic)
+ *
+ * API: https://docs.anthropic.com/en/api/messages
+ * Uses the Anthropic Messages API.
+ */
+
+const https = require('https');
+const http = require('http');
+const { URL } = require('url');
+
+async function chat(messages, options) {
+  const baseUrl = options.baseUrl || 'https://api.anthropic.com';
+  const model = options.model || 'claude-sonnet-4-20250514';
+  const apiKey = options.apiKey;
+
+  if (!apiKey) {
+    throw new Error('Anthropic API key required. Set ANTHROPIC_API_KEY or configure in ai-config.json');
+  }
+
+  const url = new URL(`${baseUrl}/v1/messages`);
+  const body = JSON.stringify({
+    model,
+    messages: messages.map(m => ({
+      role: m.role === 'system' ? 'user' : m.role,
+      content: m.content,
+    })),
+    // Claude uses system as a top-level param
+    system: messages.find(m => m.role === 'system')?.content,
+    max_tokens: options.maxTokens || 2000,
+    temperature: options.temperature ?? 0.1,
+  });
+
+  const response = await request(url, {
+    method: 'POST',
+    headers: {
+      'Content-Type': 'application/json',
+      'x-api-key': apiKey,
+      'anthropic-version': '2023-06-01',
+    },
+    body,
+  });
+
+  const data = JSON.parse(response.body);
+  return {
+    content: data.content?.[0]?.text || '',
+    usage: data.usage || {},
+    model: data.model || model,
+  };
+}
+
+function request(url, options) {
+  return new Promise((resolve, reject) => {
+    const lib = url.protocol === 'https:' ? https : http;
+    const req = lib.request(url, {
+      method: options.method || 'GET',
+      headers: options.headers || {},
+    }, (res) => {
+      let body = '';
+      res.on('data', (chunk) => body += chunk);
+      res.on('end', () => {
+        if (res.statusCode >= 400) {
+          reject(new Error(`HTTP ${res.statusCode}: ${body.substring(0, 500)}`));
+        } else {
+          resolve({ statusCode: res.statusCode, body });
+        }
+      });
+    });
+
+    req.on('error', reject);
+    req.setTimeout(30000, () => {
+      req.destroy(new Error('Request timeout (30s)'));
+    });
+
+    if (options.body) req.write(options.body);
+    req.end();
+  });
+}
+
+module.exports = { chat, name: 'claude' };

package/src/ai/providers/hunyuan.js

@@ -0,0 +1,87 @@
+/**
+ * 腾讯混元 provider (Tencent Hunyuan via TokenHub)
+ *
+ * 混元已迁移至 TokenHub 平台，提供 OpenAI 兼容接口。
+ * 文档: https://cloud.tencent.com/document/product/266/115968
+ *
+ * 配置:
+ *   baseUrl: https://tokenhub.tencentmaas.com/v1  (TokenHub 境内)
+ *   model:   hy3-preview | hunyuan-2.0-instruct-20251111 | hunyuan-role-latest 等
+ *   apiKey:  TokenHub API Key (sk-xxx，在 TokenHub 控制台创建)
+ *
+ * 注意：原混元 endpoint https://api.hunyuan.cloud.tencent.com/v1 已逐步停用，
+ *       新创建的 Key（ak-前缀）只能在 TokenHub endpoint 使用。
+ *
+ * 环境变量: HUNYUAN_API_KEY
+ */
+
+const https = require('https');
+const http = require('http');
+const { URL } = require('url');
+
+async function chat(messages, options) {
+  const baseUrl = options.baseUrl || 'https://tokenhub.tencentmaas.com/v1';
+  const model = options.model || 'hy3-preview';
+  const apiKey = options.apiKey;
+
+  if (!apiKey) {
+    throw new Error('混元 API密钥未配置。请设置 HUNYUAN_API_KEY 环境变量，或在 ai-config.json 中填写 apiKey');
+  }
+
+  const url = new URL(`${baseUrl}/chat/completions`);
+  const body = JSON.stringify({
+    model,
+    messages,
+    temperature: options.temperature ?? 0.1,
+    max_tokens: options.maxTokens || 2000,
+  });
+
+  const response = await request(url, {
+    method: 'POST',
+    headers: {
+      'Content-Type': 'application/json',
+      'Authorization': `Bearer ${apiKey}`,
+    },
+    body,
+  });
+
+  const data = JSON.parse(response.body);
+  return {
+    content: data.choices?.[0]?.message?.content || '',
+    usage: data.usage || {},
+    model: data.model || model,
+  };
+}
+
+/**
+ * 通用 HTTP 请求（零外部依赖，使用内置 http/https 模块）
+ */
+function request(url, options) {
+  return new Promise((resolve, reject) => {
+    const lib = url.protocol === 'https:' ? https : http;
+    const req = lib.request(url, {
+      method: options.method || 'GET',
+      headers: options.headers || {},
+    }, (res) => {
+      let body = '';
+      res.on('data', (chunk) => body += chunk);
+      res.on('end', () => {
+        if (res.statusCode >= 400) {
+          reject(new Error(`HTTP ${res.statusCode}: ${body.substring(0, 500)}`));
+        } else {
+          resolve({ statusCode: res.statusCode, body });
+        }
+      });
+    });
+
+    req.on('error', reject);
+    req.setTimeout(90000, () => {
+      req.destroy(new Error('请求超时 (90s)'));
+    });
+
+    if (options.body) req.write(options.body);
+    req.end();
+  });
+}
+
+module.exports = { chat, name: 'hunyuan' };

package/src/ai/providers/openai.js

@@ -0,0 +1,74 @@
+/**
+ * OpenAI provider (GPT-4, GPT-3.5, etc.)
+ *
+ * API: https://platform.openai.com/docs/api-reference/chat
+ * Uses the standard OpenAI chat completions API.
+ */
+
+const https = require('https');
+const http = require('http');
+const { URL } = require('url');
+
+async function chat(messages, options) {
+  const baseUrl = options.baseUrl || 'https://api.openai.com';
+  const model = options.model || 'gpt-4o-mini';
+  const apiKey = options.apiKey;
+
+  if (!apiKey) {
+    throw new Error('OpenAI API key required. Set OPENAI_API_KEY or configure in ai-config.json');
+  }
+
+  const url = new URL(`${baseUrl}/v1/chat/completions`);
+  const body = JSON.stringify({
+    model,
+    messages,
+    temperature: options.temperature ?? 0.1,
+    max_tokens: options.maxTokens || 2000,
+  });
+
+  const response = await request(url, {
+    method: 'POST',
+    headers: {
+      'Content-Type': 'application/json',
+      'Authorization': `Bearer ${apiKey}`,
+    },
+    body,
+  });
+
+  const data = JSON.parse(response.body);
+  return {
+    content: data.choices?.[0]?.message?.content || '',
+    usage: data.usage || {},
+    model: data.model || model,
+  };
+}
+
+function request(url, options) {
+  return new Promise((resolve, reject) => {
+    const lib = url.protocol === 'https:' ? https : http;
+    const req = lib.request(url, {
+      method: options.method || 'GET',
+      headers: options.headers || {},
+    }, (res) => {
+      let body = '';
+      res.on('data', (chunk) => body += chunk);
+      res.on('end', () => {
+        if (res.statusCode >= 400) {
+          reject(new Error(`HTTP ${res.statusCode}: ${body.substring(0, 500)}`));
+        } else {
+          resolve({ statusCode: res.statusCode, body });
+        }
+      });
+    });
+
+    req.on('error', reject);
+    req.setTimeout(30000, () => {
+      req.destroy(new Error('Request timeout (30s)'));
+    });
+
+    if (options.body) req.write(options.body);
+    req.end();
+  });
+}
+
+module.exports = { chat, name: 'openai' };