cfix 1.0.0

package/cli/lib/formatter.js

@@ -0,0 +1,224 @@
+/**
+ * 输出格式化工具
+ * 支持: interactive, json, quiet, table
+ */
+
+/**
+ * 格式化器
+ */
+class Formatter {
+  constructor(format = 'interactive') {
+    this.format = format;
+  }
+
+  /**
+   * 输出数据
+   */
+  output(data, options = {}) {
+    switch (this.format) {
+      case 'json':
+        this.outputJSON(data);
+        break;
+      case 'quiet':
+        this.outputQuiet(data, options);
+        break;
+      case 'table':
+        this.outputTable(data, options);
+        break;
+      case 'interactive':
+      default:
+        this.outputInteractive(data, options);
+        break;
+    }
+  }
+
+  /**
+   * 交互式输出（默认）
+   */
+  outputInteractive(data, options) {
+    if (options.title) {
+      console.log(options.title);
+      console.log('');
+    }
+
+    if (typeof data === 'object') {
+      console.log(JSON.stringify(data, null, 2));
+    } else {
+      console.log(data);
+    }
+  }
+
+  /**
+   * JSON 输出
+   */
+  outputJSON(data) {
+    console.log(JSON.stringify(data, null, 2));
+  }
+
+  /**
+   * 静默输出
+   */
+  outputQuiet(data, options) {
+    if (options.quietValue) {
+      // 只输出特定值
+      const value = this.getNestedValue(data, options.quietValue);
+      if (value !== undefined) {
+        console.log(value);
+      }
+    } else if (options.quietField) {
+      // 只输出特定字段
+      if (data[options.quietField] !== undefined) {
+        console.log(data[options.quietField]);
+      }
+    } else {
+      // 输出基本值
+      if (typeof data === 'object') {
+        // 如果是对象，输出 id 或第一个字段
+        console.log(data.id || data.taskId || data.status || JSON.stringify(data));
+      } else {
+        console.log(data);
+      }
+    }
+  }
+
+  /**
+   * 表格输出
+   */
+  outputTable(data, options) {
+    const items = Array.isArray(data) ? data : [data];
+
+    if (items.length === 0) {
+      console.log('暂无数据');
+      return;
+    }
+
+    const columns = options.columns || this.detectColumns(items[0]);
+
+    // 计算列宽
+    const widths = {};
+    columns.forEach(col => {
+      widths[col] = col.length;
+      items.forEach(item => {
+        const value = String(this.getNestedValue(item, col) || '');
+        widths[col] = Math.max(widths[col], value.length);
+      });
+    });
+
+    // 输出表头
+    const header = columns.map(col => col.padEnd(widths[col])).join(' | ');
+    console.log(header);
+    console.log('-'.repeat(header.length));
+
+    // 输出数据行
+    items.forEach(item => {
+      const row = columns.map(col => {
+        const value = String(this.getNestedValue(item, col) || '');
+        return value.padEnd(widths[col]);
+      }).join(' | ');
+      console.log(row);
+    });
+  }
+
+  /**
+   * 检测对象列
+   */
+  detectColumns(obj) {
+    if (!obj || typeof obj !== 'object') {
+      return ['value'];
+    }
+
+    return Object.keys(obj).filter(key =>
+      !['changes', 'result', 'error'].includes(key)
+    );
+  }
+
+  /**
+   * 获取嵌套值
+   */
+  getNestedValue(obj, path) {
+    const keys = path.split('.');
+    let value = obj;
+
+    for (const key of keys) {
+      if (value && typeof value === 'object') {
+        value = value[key];
+      } else {
+        return undefined;
+      }
+    }
+
+    return value;
+  }
+
+  /**
+   * 格式化错误
+   */
+  error(message, error) {
+    if (this.format === 'json') {
+      console.log(JSON.stringify({
+        success: false,
+        error: message,
+        details: error?.message
+      }, null, 2));
+    } else if (this.format === 'quiet') {
+      console.error(message);
+    } else {
+      console.error(`❌ ${message}`);
+      if (error?.message) {
+        console.error(`   ${error.message}`);
+      }
+    }
+  }
+
+  /**
+   * 格式化成功
+   */
+  success(message, data) {
+    if (this.format === 'json') {
+      console.log(JSON.stringify({
+        success: true,
+        message,
+        data
+      }, null, 2));
+    } else if (this.format === 'quiet') {
+      console.log(message);
+    } else {
+      console.log(`✅ ${message}`);
+    }
+  }
+
+  /**
+   * 格式化警告
+   */
+  warning(message) {
+    if (this.format === 'json') {
+      console.log(JSON.stringify({
+        warning: message
+      }, null, 2));
+    } else if (this.format !== 'quiet') {
+      console.log(`⚠️  ${message}`);
+    }
+  }
+
+  /**
+   * 格式化信息
+   */
+  info(message) {
+    if (this.format === 'json') {
+      console.log(JSON.stringify({
+        info: message
+      }, null, 2));
+    } else if (this.format !== 'quiet') {
+      console.log(`ℹ️  ${message}`);
+    }
+  }
+}
+
+/**
+ * 创建格式化器
+ */
+function createFormatter(format) {
+  return new Formatter(format);
+}
+
+module.exports = { Formatter, createFormatter };

package/cli/lib/process-manager.js

@@ -0,0 +1,233 @@
+/**
+ * 进程管理器
+ * 管理后台服务进程的启动、停止和监控
+ */
+
+const { spawn } = require('child_process');
+const path = require('path');
+const fs = require('fs');
+
+/**
+ * 进程管理器类
+ */
+class ProcessManager {
+  constructor(configManager) {
+    this.config = configManager;
+    this.pidFile = path.join(this.config.getConfigPath(), '..', '.service.pid');
+  }
+
+  /**
+   * 检查服务是否运行
+   * @returns {Promise<boolean>}
+   */
+  async isRunning() {
+    if (!fs.existsSync(this.pidFile)) {
+      return false;
+    }
+
+    try {
+      const pid = parseInt(fs.readFileSync(this.pidFile, 'utf-8'));
+      process.kill(pid, 0); // 检查进程是否存在
+      return true;
+    } catch {
+      // PID 文件存在但进程不存在，清理文件
+      fs.unlinkSync(this.pidFile);
+      return false;
+    }
+  }
+
+  /**
+   * 获取服务 PID
+   * @returns {number|null}
+   */
+  getPid() {
+    if (!fs.existsSync(this.pidFile)) {
+      return null;
+    }
+    return parseInt(fs.readFileSync(this.pidFile, 'utf-8'));
+  }
+
+  /**
+   * 启动服务
+   * @param {Object} options - 启动选项
+   * @returns {Promise<number>} 进程 PID
+   */
+  async start(options = {}) {
+    // 检查是否已运行
+    if (await this.isRunning()) {
+      const pid = this.getPid();
+      throw new Error(`服务已在运行 (PID: ${pid})`);
+    }
+
+    const rootDir = process.env.CFIX_ROOT || path.resolve(__dirname, '../..');
+    const serviceScript = path.join(rootDir, 'src', 'index.js');
+
+    // 检查服务脚本是否存在
+    if (!fs.existsSync(serviceScript)) {
+      throw new Error(`服务脚本不存在: ${serviceScript}`);
+    }
+
+    // 合并环境变量
+    const env = {
+      ...process.env,
+      NODE_ENV: options.daemon ? 'production' : 'development',
+      ...(options.env || {})
+    };
+
+    // 启动子进程
+    const child = spawn('node', [serviceScript], {
+      detached: options.daemon !== false, // 默认以守护进程方式运行
+      stdio: options.daemon === false ? 'inherit' : 'ignore',
+      cwd: rootDir,
+      env
+    });
+
+    // 保存 PID
+    fs.writeFileSync(this.pidFile, String(child.pid));
+
+    // 如果是守护进程，取消引用
+    if (options.daemon !== false) {
+      child.unref();
+    }
+
+    // 等待服务启动
+    if (options.wait) {
+      await this.waitForReady();
+    }
+
+    return child.pid;
+  }
+
+  /**
+   * 停止服务
+   * @param {Object} options - 停止选项
+   */
+  async stop(options = {}) {
+    if (!await this.isRunning()) {
+      if (!options.quiet) {
+        console.log('服务未运行');
+      }
+      return;
+    }
+
+    const pid = this.getPid();
+    if (!options.quiet) {
+      console.log(`正在停止服务 (PID: ${pid})...`);
+    }
+
+    try {
+      // 先尝试 SIGTERM
+      process.kill(pid, 'SIGTERM');
+
+      // 等待最多 10 秒
+      for (let i = 0; i < 10; i++) {
+        await this.sleep(1000);
+        try {
+          process.kill(pid, 0);
+        } catch {
+          // 进程已结束
+          fs.unlinkSync(this.pidFile);
+          if (!options.quiet) {
+            console.log('服务已停止');
+          }
+          return;
+        }
+      }
+
+      // 如果还在运行，强制终止
+      process.kill(pid, 'SIGKILL');
+      await this.sleep(500);
+      fs.unlinkSync(this.pidFile);
+
+      if (!options.quiet) {
+        console.log('服务已强制停止');
+      }
+    } catch (error) {
+      throw new Error(`停止服务失败: ${error.message}`);
+    }
+  }
+
+  /**
+   * 重启服务
+   * @param {Object} options - 重启选项
+   */
+  async restart(options = {}) {
+    if (await this.isRunning()) {
+      await this.stop({ quiet: true });
+    }
+
+    await this.sleep(1000);
+    return await this.start(options);
+  }
+
+  /**
+   * 等待服务就绪
+   * @param {number} timeout - 超时时间（毫秒）
+   */
+  async waitForReady(timeout = 30000) {
+    const serviceConfig = this.config.getServiceConfig();
+    const baseURL = `http://${serviceConfig.host}:${serviceConfig.port}`;
+
+    const start = Date.now();
+
+    while (Date.now() - start < timeout) {
+      try {
+        const axios = require('axios');
+        await axios.get(`${baseURL}/health`, { timeout: 1000 });
+        return true;
+      } catch {
+        await this.sleep(500);
+      }
+    }
+
+    throw new Error('服务启动超时');
+  }
+
+  /**
+   * 获取服务健康状态
+   */
+  async getHealthStatus() {
+    const serviceConfig = this.config.getServiceConfig();
+    const baseURL = `http://${serviceConfig.host}:${serviceConfig.port}`;
+
+    try {
+      const axios = require('axios');
+      const response = await axios.get(`${baseURL}/health`, { timeout: 3000 });
+      return response.data;
+    } catch (error) {
+      throw new Error(`无法连接到服务: ${error.message}`);
+    }
+  }
+
+  /**
+   * 发送信号到服务进程
+   * @param {string} signal - 信号名称
+   */
+  async sendSignal(signal) {
+    if (!await this.isRunning()) {
+      throw new Error('服务未运行');
+    }
+
+    const pid = this.getPid();
+    process.kill(pid, signal);
+  }
+
+  /**
+   * 睡眠函数
+   * @param {number} ms - 毫秒数
+   */
+  sleep(ms) {
+    return new Promise(resolve => setTimeout(resolve, ms));
+  }
+
+  /**
+   * 清理 PID 文件
+   */
+  cleanupPidFile() {
+    if (fs.existsSync(this.pidFile)) {
+      fs.unlinkSync(this.pidFile);
+    }
+  }
+}
+
+module.exports = ProcessManager;

package/cli/lib/service-client.js

@@ -0,0 +1,271 @@
+/**
+ * 服务通信客户端
+ * 与后台服务通信
+ */
+
+const axios = require('axios');
+const config = require('./config-manager');
+
+/**
+ * 服务客户端类
+ */
+class ServiceClient {
+  constructor() {
+    this.serviceConfig = config.getServiceConfig();
+    this.baseURL = `http://${this.serviceConfig.host}:${this.serviceConfig.port}`;
+    this.timeout = this.serviceConfig.timeout || 30000;
+  }
+
+  /**
+   * 创建 axios 实例
+   */
+  createInstance() {
+    return axios.create({
+      baseURL: this.baseURL,
+      timeout: this.timeout,
+      headers: {
+        'Content-Type': 'application/json'
+      }
+    });
+  }
+
+  /**
+   * 健康检查
+   */
+  async healthCheck() {
+    try {
+      const instance = this.createInstance();
+      const response = await instance.get('/health');
+      return response.data;
+    } catch (error) {
+      throw new Error(`服务健康检查失败: ${error.message}`);
+    }
+  }
+
+  /**
+   * 创建修复任务
+   */
+  async createFixTask(options) {
+    try {
+      const instance = this.createInstance();
+      const response = await instance.post('/api/fix-bug', {
+        projectPath: options.projectPath,
+        repoUrl: options.repoUrl,
+        requirement: options.requirement,
+        runTests: options.runTests,
+        mergeToAlpha: options.mergeToAlpha,
+        mergeToBeta: options.mergeToBeta,
+        autoConfirm: options.autoConfirm,
+        aiEngine: options.aiEngine,
+        maxTurns: options.maxTurns
+      });
+      return response.data;
+    } catch (error) {
+      if (error.response) {
+        throw new Error(`创建任务失败: ${error.response.data.message || error.message}`);
+      }
+      throw new Error(`创建任务失败: ${error.message}`);
+    }
+  }
+
+  /**
+   * 获取任务列表
+   */
+  async getTasks(filters = {}) {
+    try {
+      const instance = this.createInstance();
+      const response = await instance.get('/api/tasks', { params: filters });
+      return response.data;
+    } catch (error) {
+      throw new Error(`获取任务列表失败: ${error.message}`);
+    }
+  }
+
+  /**
+   * 获取任务详情
+   */
+  async getTask(taskId) {
+    try {
+      const instance = this.createInstance();
+      const response = await instance.get(`/api/tasks/${taskId}`);
+      return response.data;
+    } catch (error) {
+      if (error.response && error.response.status === 404) {
+        throw new Error(`任务不存在: ${taskId}`);
+      }
+      throw new Error(`获取任务详情失败: ${error.message}`);
+    }
+  }
+
+  /**
+   * 取消任务
+   */
+  async cancelTask(taskId) {
+    try {
+      const instance = this.createInstance();
+      const response = await instance.post(`/api/tasks/${taskId}/cancel`);
+      return response.data;
+    } catch (error) {
+      throw new Error(`取消任务失败: ${error.message}`);
+    }
+  }
+
+  /**
+   * 批准任务
+   */
+  async approveTask(taskId) {
+    try {
+      const instance = this.createInstance();
+      const response = await instance.post(`/api/tasks/${taskId}/approve`);
+      return response.data;
+    } catch (error) {
+      throw new Error(`批准任务失败: ${error.message}`);
+    }
+  }
+
+  /**
+   * 拒绝任务
+   */
+  async rejectTask(taskId, reason) {
+    try {
+      const instance = this.createInstance();
+      const response = await instance.post(`/api/tasks/${taskId}/reject`, { reason });
+      return response.data;
+    } catch (error) {
+      throw new Error(`拒绝任务失败: ${error.message}`);
+    }
+  }
+
+  /**
+   * 获取任务修改内容
+   */
+  async getTaskChanges(taskId) {
+    try {
+      const instance = this.createInstance();
+      const response = await instance.get(`/api/tasks/${taskId}/changes`);
+      return response.data;
+    } catch (error) {
+      throw new Error(`获取修改内容失败: ${error.message}`);
+    }
+  }
+
+  /**
+   * 获取队列统计
+   */
+  async getQueueStats() {
+    try {
+      const instance = this.createInstance();
+      const response = await instance.get('/api/queue/stats');
+      return response.data;
+    } catch (error) {
+      throw new Error(`获取队列统计失败: ${error.message}`);
+    }
+  }
+
+  /**
+   * 获取项目锁统计
+   */
+  async getProjectLocksStats() {
+    try {
+      const instance = this.createInstance();
+      const response = await instance.get('/api/project-locks/stats');
+      return response.data;
+    } catch (error) {
+      throw new Error(`获取项目锁统计失败: ${error.message}`);
+    }
+  }
+
+  /**
+   * 获取性能指标
+   */
+  async getMetrics() {
+    try {
+      const instance = this.createInstance();
+      const response = await instance.get('/api/metrics');
+      return response.data;
+    } catch (error) {
+      throw new Error(`获取性能指标失败: ${error.message}`);
+    }
+  }
+
+  /**
+   * 检查服务是否可用
+   */
+  async isAvailable() {
+    try {
+      await this.healthCheck();
+      return true;
+    } catch {
+      return false;
+    }
+  }
+
+  /**
+   * 等待服务就绪
+   */
+  async waitForReady(maxWait = 30000, interval = 500) {
+    const start = Date.now();
+
+    while (Date.now() - start < maxWait) {
+      if (await this.isAvailable()) {
+        return true;
+      }
+      await this.sleep(interval);
+    }
+
+    throw new Error('服务启动超时');
+  }
+
+  /**
+   * 等待任务完成
+   */
+  async waitForTask(taskId, options = {}) {
+    const {
+      timeout = 1800000,  // 30分钟
+      interval = 2000,     // 2秒
+      onProgress
+    } = options;
+
+    const start = Date.now();
+
+    while (Date.now() - start < timeout) {
+      const task = await this.getTask(taskId);
+
+      if (onProgress) {
+        onProgress(task);
+      }
+
+      // 任务完成
+      if (task.status === 'completed') {
+        return task;
+      }
+
+      // 任务失败
+      if (task.status === 'failed' || task.status === 'cancelled') {
+        throw new Error(`任务${task.status === 'failed' ? '失败' : '已取消'}`);
+      }
+
+      await this.sleep(interval);
+    }
+
+    throw new Error('等待任务超时');
+  }
+
+  /**
+   * 睡眠函数
+   */
+  sleep(ms) {
+    return new Promise(resolve => setTimeout(resolve, ms));
+  }
+
+  /**
+   * 更新服务配置（重新加载）
+   */
+  reloadConfig() {
+    this.serviceConfig = config.getServiceConfig();
+    this.baseURL = `http://${this.serviceConfig.host}:${this.serviceConfig.port}`;
+    this.timeout = this.serviceConfig.timeout || 30000;
+  }
+}
+
+module.exports = ServiceClient;