closer-code 1.0.0

package/src/ai-client-legacy.js

@@ -0,0 +1,171 @@
+// OpenAI 客户端
+export class OpenAIClient {
+  constructor(config) {
+    this.apiKey = config.apiKey;
+    this.baseURL = config.baseURL || 'https://api.openai.com/v1';
+    this.model = config.model || 'gpt-4o';
+    this.maxTokens = config.maxTokens || 4096;
+  }
+
+  async chat(messages, options = {}) {
+    const system = options.system || 'You are a helpful AI programming assistant.';
+    const tools = options.tools || [];
+    const temperature = options.temperature ?? 0.7;
+
+    // 添加系统消息
+    const formattedMessages = [
+      { role: 'system', content: system },
+      ...messages.map(m => ({
+        role: m.role,
+        content: m.content
+      }))
+    ];
+
+    const requestBody = {
+      model: this.model,
+      messages: formattedMessages,
+      temperature,
+      max_tokens: this.maxTokens
+    };
+
+    if (tools.length > 0) {
+      requestBody.tools = tools.map(tool => ({
+        type: 'function',
+        function: {
+          name: tool.name,
+          description: tool.description,
+          parameters: tool.inputSchema
+        }
+      }));
+    }
+
+    const response = await fetch(`${this.baseURL}/chat/completions`, {
+      method: 'POST',
+      headers: {
+        'Content-Type': 'application/json',
+        'Authorization': `Bearer ${this.apiKey}`
+      },
+      body: JSON.stringify(requestBody)
+    });
+
+    if (!response.ok) {
+      const error = await response.text();
+      throw new Error(`OpenAI API error: ${response.status} - ${error}`);
+    }
+
+    const data = await response.json();
+    return this.parseResponse(data);
+  }
+
+  parseResponse(data) {
+    const choice = data.choices[0];
+    const message = {
+      role: 'assistant',
+      content: [],
+      model: data.model,
+      finishReason: choice.finish_reason
+    };
+
+    if (choice.message.content) {
+      message.content.push({
+        type: 'text',
+        text: choice.message.content
+      });
+    }
+
+    if (choice.message.tool_calls) {
+      for (const toolCall of choice.message.tool_calls) {
+        message.content.push({
+          type: 'tool_use',
+          id: toolCall.id,
+          name: toolCall.function.name,
+          input: JSON.parse(toolCall.function.arguments)
+        });
+      }
+    }
+
+    return message;
+  }
+}
+
+// Ollama 客户端（本地运行）
+export class OllamaClient {
+  constructor(config) {
+    this.baseURL = config.baseURL || 'http://localhost:11434';
+    this.model = config.model || 'llama3.1';
+    this.maxTokens = config.maxTokens || 4096;
+  }
+
+  async chat(messages, options = {}) {
+    const system = options.system || 'You are a helpful AI programming assistant.';
+    const temperature = options.temperature ?? 0.7;
+
+    const formattedMessages = [
+      { role: 'system', content: system },
+      ...messages.map(m => ({
+        role: m.role,
+        content: m.content
+      }))
+    ];
+
+    const response = await fetch(`${this.baseURL}/api/chat`, {
+      method: 'POST',
+      headers: { 'Content-Type': 'application/json' },
+      body: JSON.stringify({
+        model: this.model,
+        messages: formattedMessages,
+        stream: false,
+        options: { temperature }
+      })
+    });
+
+    if (!response.ok) {
+      const error = await response.text();
+      throw new Error(`Ollama error: ${response.status} - ${error}`);
+    }
+
+    const data = await response.json();
+    return {
+      role: 'assistant',
+      content: [{ type: 'text', text: data.message.content }],
+      model: this.model
+    };
+  }
+}
+
+// 客户端工厂
+export function createAIClient(config) {
+  const { provider, anthropic, openai, ollama } = config.ai;
+
+  switch (provider) {
+    case 'anthropic':
+      return new AnthropicClient(anthropic);
+    case 'openai':
+      return new OpenAIClient(openai);
+    case 'ollama':
+      return new OllamaClient(ollama);
+    default:
+      throw new Error(`Unknown AI provider: ${provider}`);
+  }
+}
+
+// 检查 API 配置
+export function checkConfig(config) {
+  const { provider, anthropic, openai, ollama } = config.ai;
+
+  switch (provider) {
+    case 'anthropic':
+      if (!anthropic.apiKey) {
+        throw new Error('Anthropic API key not configured. Set CLOSER_ANTHROPIC_API_KEY environment variable.');
+      }
+      break;
+    case 'openai':
+      if (!openai.apiKey) {
+        throw new Error('OpenAI API key not configured. Set CLOSER_OPENAI_API_KEY environment variable.');
+      }
+      break;
+    case 'ollama':
+      // Ollama 不需要密钥，但需要本地运行
+      break;
+  }
+}

package/src/ai-client.js

@@ -0,0 +1,221 @@
+/**
+ * AI 客户端模块 - 使用 @anthropic-ai/sdk
+ *
+ * 相比之前实现的优势：
+ * - 代码量减少 70%
+ * - 自动类型检查
+ * - 内置错误处理和重试
+ * - 无需手工解析 SSE
+ * - 原生支持工具调用循环（toolRunner）
+ */
+
+import Anthropic from '@anthropic-ai/sdk';
+
+/**
+ * Anthropic 客户端（使用 SDK）
+ */
+export class AnthropicClient {
+  constructor(config) {
+    this.client = new Anthropic({
+      apiKey: config.apiKey,
+      baseURL: config.baseURL || 'https://api.anthropic.com',
+      timeout: 60000,  // 默认 10 分钟，这里设置为 60 秒
+      maxRetries: 2    // 默认重试 2 次
+    });
+    this.model = config.model || 'claude-sonnet-4-5-20250929';
+    this.maxTokens = config.maxTokens || 8192;
+  }
+
+  /**
+   * 发送消息（非流式）
+   * @param {Array} messages - 消息数组（SDK 自动处理格式）
+   * @param {Object} options - 选项（system, tools, temperature）
+   * @returns {Promise} API 响应
+   */
+  async chat(messages, options = {}) {
+    return await this.client.messages.create({
+      model: this.model,
+      max_tokens: this.maxTokens,
+      system: options.system,
+      messages: messages,  // SDK 自动处理格式转换
+      tools: options.tools,
+      temperature: options.temperature,
+      thinking: options.thinking || { type: 'enabled', budget_tokens: 20000 }
+    });
+  }
+
+  /**
+   * 发送消息（流式）
+   * 使用 SDK 的事件监听器 API，符合 Extended Thinking 官方示例
+   *
+   * @param {Array} messages - 消息数组
+   * @param {Object} options - 选项
+   * @param {Function} onChunk - 流式回调函数
+   * @returns {Promise} 最终消息
+   */
+  async chatStream(messages, options = {}, onChunk) {
+    const stream = this.client.messages.stream({
+      model: this.model,
+      max_tokens: this.maxTokens,
+      system: options.system,
+      messages: messages,
+      tools: options.tools,
+      temperature: options.temperature,
+      thinking: options.thinking || { type: 'enabled', budget_tokens: 20000 }
+    });
+
+    // 使用 SDK 的事件监听器 API（官方推荐方式）
+    // 参考: examples/thinking-stream.ts
+    stream.on('thinking', (thinkingDelta, thinkingSnapshot) => {
+      // thinkingDelta: 增量的 thinking 内容
+      // thinkingSnapshot: 完整的 thinking 内容快照
+      if (typeof onChunk === 'function') {
+        onChunk({
+          type: 'thinking',
+          delta: thinkingDelta,
+          snapshot: thinkingSnapshot
+        });
+      }
+    });
+
+    stream.on('text', (textDelta, textSnapshot) => {
+      // textDelta: 增量的文本内容
+      // textSnapshot: 完整的文本内容快照
+      if (typeof onChunk === 'function') {
+        onChunk({
+          type: 'text',
+          delta: textDelta,
+          snapshot: textSnapshot
+        });
+      }
+    });
+
+    stream.on('signature', (signature) => {
+      // signature: thinking 块的签名
+      if (typeof onChunk === 'function') {
+        onChunk({
+          type: 'signature',
+          signature: signature
+        });
+      }
+    });
+
+    // 监听所有原始事件
+    stream.on('content_block_start', (contentBlock) => {
+      if (typeof onChunk === 'function') {
+        onChunk({
+          type: 'content_block_start',
+          blockType: contentBlock.type,
+          block: contentBlock
+        });
+      }
+    });
+
+    stream.on('content_block_delta', (delta) => {
+      if (typeof onChunk === 'function') {
+        onChunk({
+          type: 'content_block_delta',
+          delta: delta.delta
+        });
+      }
+    });
+
+    // 获取最终消息
+    return await stream.finalMessage();
+  }
+
+  /**
+   * 使用 toolRunner 自动处理工具调用循环
+   * 这是 SDK 提供的高级功能，可以自动处理工具的调用和结果返回
+   *
+   * @param {Array} messages - 消息数组
+   * @param {Array} tools - 工具数组（使用 Zod 定义的 betaZodTool）
+   * @param {Object} options - 选项
+   * @returns {Promise} 最终消息（所有工具调用完成后）
+   */
+  async chatWithTools(messages, tools, options = {}) {
+    return await this.client.beta.messages.toolRunner({
+      model: this.model,
+      max_tokens: this.maxTokens,
+      system: options.system,
+      messages: messages,
+      tools: tools,
+      temperature: options.temperature
+    });
+  }
+
+  /**
+   * 获取消息的 token 计数（用于预估成本）
+   * @param {Array} messages - 消息数组
+   * @returns {Promise} Token 计数
+   */
+  async countTokens(messages) {
+    return await this.client.messages.countTokens({
+      model: this.model,
+      messages: messages
+    });
+  }
+}
+
+/**
+ * 创建 AI 客户端的工厂函数
+ *
+ * 注意：OpenAI 和 Ollama 仍然使用原有的实现
+ */
+export function createAIClient(config) {
+  const { provider, anthropic, openai, ollama } = config.ai;
+
+  switch (provider) {
+    case 'anthropic':
+      return new AnthropicClient(anthropic);
+    case 'openai':
+      // 导入原有的 OpenAI 客户端
+      return createOpenAIClient(openai);
+    case 'ollama':
+      // 导入原有的 Ollama 客户端
+      return createOllamaClient(ollama);
+    default:
+      throw new Error(`Unknown AI provider: ${provider}`);
+  }
+}
+
+/**
+ * OpenAI 客户端（保留原有实现）
+ */
+async function createOpenAIClient(config) {
+  // 动态导入以避免循环依赖
+  const { OpenAIClient } = await import('./ai-client-legacy.js');
+  return new OpenAIClient(config);
+}
+
+/**
+ * Ollama 客户端（保留原有实现）
+ */
+async function createOllamaClient(config) {
+  // 动态导入以避免循环依赖
+  const { OllamaClient } = await import('./ai-client-legacy.js');
+  return new OllamaClient(config);
+}
+
+/**
+ * 检查 API 配置
+ */
+export function checkConfig(config) {
+  const { provider, anthropic, openai, ollama } = config.ai;
+
+  switch (provider) {
+    case 'anthropic':
+      if (!anthropic.apiKey) {
+        throw new Error('Anthropic API key not configured. Set CLOSER_ANTHROPIC_API_KEY environment variable.');
+      }
+      break;
+    case 'openai':
+      if (!openai.apiKey) {
+        throw new Error('OpenAI API key not configured. Set CLOSER_OPENAI_API_KEY environment variable.');
+      }
+      break;
+    case 'ollama':
+      // Ollama 不需要密钥，但需要本地运行
+      break;
+  }
+}

package/src/bash-runner.js

@@ -0,0 +1,148 @@
+import { spawn } from 'child_process';
+
+/**
+ * 在 bash 进程中执行命令并返回结果
+ * @param {string} command - 要执行的 shell 命令
+ * @param {Object} options - 配置选项
+ * @param {string} options.shell - shell 路径，默认 'bash'
+ * @param {string} options.cwd - 工作目录
+ * @param {Object} options.env - 环境变量
+ * @param {number} options.timeout - 超时时间（毫秒）
+ * @returns {Promise<BashResult>} 执行结果
+ */
+export function executeBashCommand(command, options = {}) {
+  return new Promise((resolve, reject) => {
+    const {
+      shell = 'bash',
+      cwd = process.cwd(),
+      env = process.env,
+      timeout = 30000
+    } = options;
+
+    // 启动 bash 进程，使用 -c 参数直接执行命令
+    // 不使用 -i (interactive) 避免在没有 TTY 时产生作业控制错误
+    const bashProcess = spawn(shell, ['-c', command], {
+      cwd,
+      env,
+      stdio: ['pipe', 'pipe', 'pipe']
+    });
+
+    let stdout = '';
+    let stderr = '';
+    let timer = null;
+
+    // 设置超时
+    if (timeout > 0) {
+      timer = setTimeout(() => {
+        bashProcess.kill('SIGTERM');
+        reject(new BashResult({
+          command,
+          stdout,
+          stderr,
+          exitCode: null,
+          signal: 'SIGTERM',
+          timedOut: true,
+          error: `Command timed out after ${timeout}ms`
+        }));
+      }, timeout);
+    }
+
+    // 收集 stdout
+    bashProcess.stdout.on('data', (data) => {
+      stdout += data.toString();
+    });
+
+    // 收集 stderr
+    bashProcess.stderr.on('data', (data) => {
+      stderr += data.toString();
+    });
+
+    // 进程退出时的处理
+    bashProcess.on('close', (code, signal) => {
+      if (timer) clearTimeout(timer);
+
+      const result = new BashResult({
+        command,
+        stdout,
+        stderr,
+        exitCode: code,
+        signal,
+        timedOut: false
+      });
+
+      resolve(result);
+    });
+
+    // 错误处理
+    bashProcess.on('error', (error) => {
+      if (timer) clearTimeout(timer);
+      reject(new BashResult({
+        command,
+        stdout,
+        stderr,
+        exitCode: null,
+        error: error.message
+      }));
+    });
+  });
+}
+
+/**
+ * Bash 执行结果类
+ */
+export class BashResult {
+  constructor({
+    command,
+    stdout = '',
+    stderr = '',
+    exitCode = null,
+    signal = null,
+    timedOut = false,
+    error = null
+  }) {
+    this.command = command;
+    this.stdout = stdout;
+    this.stderr = stderr;
+    this.exitCode = exitCode;
+    this.signal = signal;
+    this.timedOut = timedOut;
+    this.error = error;
+    this.timestamp = new Date().toISOString();
+  }
+
+  /** 是否成功执行（退出码为0） */
+  get success() {
+    return this.exitCode === 0 && !this.error && !this.timedOut;
+  }
+
+  /** 获取完整的输出（stdout + stderr） */
+  get output() {
+    return this.stdout + this.stderr;
+  }
+
+  /** 转换为 JSON 格式 */
+  toJSON() {
+    return {
+      command: this.command,
+      stdout: this.stdout,
+      stderr: this.stderr,
+      exitCode: this.exitCode,
+      signal: this.signal,
+      success: this.success,
+      timedOut: this.timedOut,
+      error: this.error,
+      timestamp: this.timestamp
+    };
+  }
+
+  /** 格式化输出 */
+  toString() {
+    const parts = [];
+    parts.push(`Command: ${this.command}`);
+    parts.push(`Exit Code: ${this.exitCode}`);
+    if (this.stdout) parts.push(`\nStdout:\n${this.stdout}`);
+    if (this.stderr) parts.push(`\nStderr:\n${this.stderr}`);
+    if (this.error) parts.push(`\nError: ${this.error}`);
+    return parts.join('\n');
+  }
+}