cfix 1.0.0

package/src/database/manager.js

@@ -0,0 +1,391 @@
+const sqlite3 = require('sqlite3').verbose();
+const { open } = require('sqlite');
+const path = require('path');
+const { logger } = require('../logger');
+
+/**
+ * 数据库管理器
+ * 支持 SQLite 数据库操作
+ */
+class DatabaseManager {
+  constructor() {
+    this.db = null;
+    this.dbPath = path.join(__dirname, '../../data/tasks.db');
+  }
+
+  /**
+   * 初始化数据库
+   */
+  async initialize() {
+    try {
+      // 打开数据库连接
+      this.db = await open({
+        filename: this.dbPath,
+        driver: sqlite3.Database
+      });
+
+      logger.info(`✅ 数据库已连接: ${this.dbPath}`);
+
+      // 创建表结构
+      await this.createTables();
+
+      // 创建索引
+      await this.createIndexes();
+
+      logger.info('✅ 数据库初始化完成');
+
+    } catch (error) {
+      logger.error('数据库初始化失败:', error);
+      throw error;
+    }
+  }
+
+  /**
+   * 创建表结构
+   */
+  async createTables() {
+    // 任务表
+    await this.db.exec(`
+      CREATE TABLE IF NOT EXISTS tasks (
+        id TEXT PRIMARY KEY,
+        status TEXT NOT NULL DEFAULT 'pending',
+        requirement TEXT NOT NULL,
+        project_path TEXT,
+        repo_url TEXT,
+        run_tests BOOLEAN DEFAULT 0,
+        auto_push BOOLEAN DEFAULT 1,
+        ai_engine TEXT,
+        base_branch TEXT,
+        create_new_branch BOOLEAN DEFAULT 1,
+        username TEXT DEFAULT 'system',
+        merge_to_alpha BOOLEAN DEFAULT 0,
+        merge_to_beta BOOLEAN DEFAULT 0,
+        merge_to_master BOOLEAN DEFAULT 0,
+        created_at TEXT NOT NULL,
+        started_at TEXT,
+        completed_at TEXT,
+        duration TEXT,
+        error TEXT,
+        UNIQUE(id)
+      );
+    `);
+
+    // 任务结果表
+    await this.db.exec(`
+      CREATE TABLE IF NOT EXISTS task_results (
+        id INTEGER PRIMARY KEY AUTOINCREMENT,
+        task_id TEXT NOT NULL,
+        success BOOLEAN NOT NULL,
+        project_name TEXT,
+        branch TEXT,
+        base_branch TEXT,
+        changed_files TEXT,
+        summary TEXT,
+        conversation_turns INTEGER,
+        tests_passed BOOLEAN,
+        pushed BOOLEAN,
+        merge_results TEXT,
+        created_at TEXT NOT NULL,
+        FOREIGN KEY (task_id) REFERENCES tasks(id) ON DELETE CASCADE
+      );
+    `);
+
+    // 任务进度表
+    await this.db.exec(`
+      CREATE TABLE IF NOT EXISTS task_progress (
+        id INTEGER PRIMARY KEY AUTOINCREMENT,
+        task_id TEXT NOT NULL,
+        step TEXT NOT NULL,
+        message TEXT NOT NULL,
+        created_at TEXT NOT NULL,
+        FOREIGN KEY (task_id) REFERENCES tasks(id) ON DELETE CASCADE
+      );
+    `);
+
+    // 性能指标表
+    await this.db.exec(`
+      CREATE TABLE IF NOT EXISTS metrics (
+        id INTEGER PRIMARY KEY AUTOINCREMENT,
+        metric_type TEXT NOT NULL,
+        metric_key TEXT NOT NULL,
+        metric_value REAL NOT NULL,
+        metadata TEXT,
+        created_at TEXT NOT NULL
+      );
+    `);
+
+    logger.info('✅ 数据表创建完成');
+  }
+
+  /**
+   * 创建索引
+   */
+  async createIndexes() {
+    await this.db.exec(`
+      CREATE INDEX IF NOT EXISTS idx_tasks_status ON tasks(status);
+      CREATE INDEX IF NOT EXISTS idx_tasks_created_at ON tasks(created_at DESC);
+      CREATE INDEX IF NOT EXISTS idx_task_progress_task_id ON task_progress(task_id);
+      CREATE INDEX IF NOT EXISTS idx_metrics_type ON metrics(metric_type, created_at DESC);
+    `);
+
+    logger.info('✅ 数据库索引创建完成');
+  }
+
+  /**
+   * 创建任务
+   */
+  async createTask(taskData) {
+    const {
+      id,
+      requirement,
+      projectPath,
+      repoUrl,
+      runTests,
+      autoPush,
+      aiEngine,
+      baseBranch,
+      createNewBranch,
+      username,
+      mergeToAlpha,
+      mergeToBeta,
+      mergeToMaster,
+    } = taskData;
+
+    await this.db.run(`
+      INSERT INTO tasks (
+        id, status, requirement, project_path, repo_url,
+        run_tests, auto_push, ai_engine, base_branch,
+        create_new_branch, username,
+        merge_to_alpha, merge_to_beta, merge_to_master,
+        created_at
+      ) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
+    `, [
+      id, 'pending', requirement, projectPath, repoUrl,
+      runTests ? 1 : 0, autoPush ? 1 : 0, aiEngine, baseBranch,
+      createNewBranch ? 1 : 0, username,
+      mergeToAlpha ? 1 : 0, mergeToBeta ? 1 : 0, mergeToMaster ? 1 : 0,
+      new Date().toISOString()
+    ]);
+
+    logger.debug(`任务已保存到数据库: ${id}`);
+  }
+
+  /**
+   * 更新任务状态
+   */
+  async updateTaskStatus(taskId, status, data = {}) {
+    const updates = {
+      status,
+      ...data
+    };
+
+    const fields = Object.keys(updates)
+      .map(key => `${this.camelToSnake(key)} = ?`)
+      .join(', ');
+
+    const values = Object.values(updates);
+    values.push(taskId);
+
+    await this.db.run(
+      `UPDATE tasks SET ${fields} WHERE id = ?`,
+      values
+    );
+
+    logger.debug(`任务状态已更新: ${taskId} -> ${status}`);
+  }
+
+  /**
+   * 添加任务进度
+   */
+  async addTaskProgress(taskId, step, message) {
+    await this.db.run(`
+      INSERT INTO task_progress (task_id, step, message, created_at)
+      VALUES (?, ?, ?, ?)
+    `, [taskId, step, message, new Date().toISOString()]);
+  }
+
+  /**
+   * 保存任务结果
+   */
+  async saveTaskResult(taskId, result) {
+    await this.db.run(`
+      INSERT INTO task_results (
+        task_id, success, project_name, branch, base_branch,
+        changed_files, summary, conversation_turns,
+        tests_passed, pushed, merge_results, created_at
+      ) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
+    `, [
+      taskId,
+      result.success ? 1 : 0,
+      result.projectName,
+      result.branch,
+      result.baseBranch,
+      JSON.stringify(result.changedFiles || []),
+      result.summary,
+      result.conversationTurns,
+      result.testsPassed ? 1 : 0,
+      result.pushed ? 1 : 0,
+      JSON.stringify(result.mergeResults || {}),
+      new Date().toISOString()
+    ]);
+  }
+
+  /**
+   * 获取任务
+   */
+  async getTask(taskId) {
+    const task = await this.db.get(
+      'SELECT * FROM tasks WHERE id = ?',
+      [taskId]
+    );
+
+    if (!task) return null;
+
+    return this.snakeToCamelObject(task);
+  }
+
+  /**
+   * 获取任务列表
+   */
+  async getTasks(options = {}) {
+    const {
+      status,
+      limit = 20,
+      offset = 0,
+      orderBy = 'created_at DESC'
+    } = options;
+
+    let query = 'SELECT * FROM tasks';
+    const params = [];
+
+    if (status) {
+      query += ' WHERE status = ?';
+      params.push(status);
+    }
+
+    query += ` ORDER BY ${orderBy} LIMIT ? OFFSET ?`;
+    params.push(limit, offset);
+
+    const tasks = await this.db.all(query, params);
+
+    return tasks.map(task => this.snakeToCamelObject(task));
+  }
+
+  /**
+   * 获取任务统计
+   */
+  async getTaskStats() {
+    const stats = await this.db.get(`
+      SELECT
+        COUNT(*) as total,
+        SUM(CASE WHEN status = 'pending' THEN 1 ELSE 0 END) as pending,
+        SUM(CASE WHEN status = 'running' THEN 1 ELSE 0 END) as running,
+        SUM(CASE WHEN status = 'completed' THEN 1 ELSE 0 END) as completed,
+        SUM(CASE WHEN status = 'failed' THEN 1 ELSE 0 END) as failed,
+        SUM(CASE WHEN status = 'cancelled' THEN 1 ELSE 0 END) as cancelled
+      FROM tasks
+    `);
+
+    return stats;
+  }
+
+  /**
+   * 获取任务进度历史
+   */
+  async getTaskProgress(taskId) {
+    const progress = await this.db.all(
+      'SELECT * FROM task_progress WHERE task_id = ? ORDER BY created_at ASC',
+      [taskId]
+    );
+
+    return progress.map(p => this.snakeToCamelObject(p));
+  }
+
+  /**
+   * 保存性能指标
+   */
+  async saveMetric(metricType, metricKey, metricValue, metadata = null) {
+    await this.db.run(`
+      INSERT INTO metrics (metric_type, metric_key, metric_value, metadata, created_at)
+      VALUES (?, ?, ?, ?, ?)
+    `, [
+      metricType,
+      metricKey,
+      metricValue,
+      metadata ? JSON.stringify(metadata) : null,
+      new Date().toISOString()
+    ]);
+  }
+
+  /**
+   * 获取性能指标
+   */
+  async getMetrics(metricType, limit = 100) {
+    const metrics = await this.db.all(`
+      SELECT * FROM metrics
+      WHERE metric_type = ?
+      ORDER BY created_at DESC
+      LIMIT ?
+    `, [metricType, limit]);
+
+    return metrics.map(m => ({
+      ...m,
+      metadata: m.metadata ? JSON.parse(m.metadata) : null
+    }));
+  }
+
+  /**
+   * 清理旧数据
+   */
+  async cleanup(daysToKeep = 30) {
+    const cutoffDate = new Date();
+    cutoffDate.setDate(cutoffDate.getDate() - daysToKeep);
+
+    const result = await this.db.run(`
+      DELETE FROM tasks
+      WHERE created_at < ?
+      AND status IN ('completed', 'failed', 'cancelled')
+    `, [cutoffDate.toISOString()]);
+
+    logger.info(`✅ 清理了 ${result.changes} 条旧任务记录`);
+
+    return result.changes;
+  }
+
+  /**
+   * 驼峰转下划线
+   */
+  camelToSnake(str) {
+    return str.replace(/[A-Z]/g, letter => `_${letter.toLowerCase()}`);
+  }
+
+  /**
+   * 下划线转驼峰
+   */
+  snakeToCamel(str) {
+    return str.replace(/_([a-z])/g, (_, letter) => letter.toUpperCase());
+  }
+
+  /**
+   * 对象字段转驼峰
+   */
+  snakeToCamelObject(obj) {
+    const result = {};
+    for (const key in obj) {
+      result[this.snakeToCamel(key)] = obj[key];
+    }
+    return result;
+  }
+
+  /**
+   * 关闭数据库连接
+   */
+  async close() {
+    if (this.db) {
+      await this.db.close();
+      logger.info('数据库连接已关闭');
+    }
+  }
+}
+
+module.exports = new DatabaseManager();

package/src/database/migration.js

@@ -0,0 +1,252 @@
+const fs = require('fs');
+const path = require('path');
+const { logger } = require('../logger');
+const databaseManager = require('./manager');
+
+/**
+ * 数据迁移工具
+ * 将 JSON 文件数据迁移到 SQLite 数据库
+ */
+class MigrationTool {
+  constructor() {
+    this.jsonFilePath = path.join(__dirname, '../../data/tasks.json');
+    this.backupPath = path.join(__dirname, '../../data/tasks.json.backup');
+  }
+
+  /**
+   * 执行迁移
+   */
+  async migrate() {
+    try {
+      logger.info('开始数据迁移...');
+
+      // 1. 检查 JSON 文件是否存在
+      if (!fs.existsSync(this.jsonFilePath)) {
+        logger.info('未找到 JSON 文件，跳过迁移');
+        return {
+          success: true,
+          migrated: 0,
+          message: '未找到数据文件'
+        };
+      }
+
+      // 2. 读取 JSON 数据
+      const jsonData = this.readJsonFile();
+
+      if (!jsonData || jsonData.length === 0) {
+        logger.info('JSON 文件为空，跳过迁移');
+        return {
+          success: true,
+          migrated: 0,
+          message: '数据文件为空'
+        };
+      }
+
+      logger.info(`找到 ${jsonData.length} 条任务记录`);
+
+      // 3. 初始化数据库
+      await databaseManager.initialize();
+
+      // 4. 备份 JSON 文件
+      this.backupJsonFile();
+
+      // 5. 迁移数据
+      let migrated = 0;
+      let failed = 0;
+
+      for (const task of jsonData) {
+        try {
+          await this.migrateTask(task);
+          migrated++;
+        } catch (error) {
+          logger.error(`迁移任务失败: ${task.id}`, error);
+          failed++;
+        }
+      }
+
+      logger.info(`✅ 数据迁移完成: 成功 ${migrated} 条, 失败 ${failed} 条`);
+
+      return {
+        success: true,
+        migrated,
+        failed,
+        total: jsonData.length
+      };
+
+    } catch (error) {
+      logger.error('数据迁移失败:', error);
+      throw error;
+    }
+  }
+
+  /**
+   * 迁移单个任务
+   */
+  async migrateTask(task) {
+    // 创建任务记录
+    await databaseManager.createTask({
+      id: task.id,
+      requirement: task.requirement,
+      projectPath: task.projectPath,
+      repoUrl: task.repoUrl,
+      runTests: task.runTests,
+      autoPush: task.autoPush,
+      aiEngine: task.aiEngine,
+      baseBranch: task.baseBranch,
+      createNewBranch: task.createNewBranch,
+      username: task.username,
+      mergeToAlpha: task.mergeToAlpha,
+      mergeToBeta: task.mergeToBeta,
+      mergeToMaster: task.mergeToMaster,
+    });
+
+    // 更新任务状态
+    await databaseManager.updateTaskStatus(task.id, task.status, {
+      startedAt: task.startedAt,
+      completedAt: task.completedAt,
+      duration: task.duration,
+      error: task.error,
+    });
+
+    // 保存任务结果
+    if (task.result) {
+      await databaseManager.saveTaskResult(task.id, task.result);
+    }
+
+    // 保存任务进度
+    if (task.progress) {
+      await databaseManager.addTaskProgress(
+        task.id,
+        task.progress.step || 'unknown',
+        task.progress.message || ''
+      );
+    }
+  }
+
+  /**
+   * 读取 JSON 文件
+   */
+  readJsonFile() {
+    try {
+      const data = fs.readFileSync(this.jsonFilePath, 'utf-8');
+      return JSON.parse(data);
+    } catch (error) {
+      logger.error('读取 JSON 文件失败:', error);
+      return null;
+    }
+  }
+
+  /**
+   * 备份 JSON 文件
+   */
+  backupJsonFile() {
+    try {
+      const timestamp = new Date().toISOString().replace(/[:.]/g, '-');
+      const backupFile = `${this.backupPath}.${timestamp}`;
+
+      fs.copyFileSync(this.jsonFilePath, backupFile);
+      logger.info(`✅ JSON 文件已备份: ${backupFile}`);
+    } catch (error) {
+      logger.error('备份 JSON 文件失败:', error);
+    }
+  }
+
+  /**
+   * 验证迁移结果
+   */
+  async verify() {
+    try {
+      logger.info('验证迁移结果...');
+
+      const jsonData = this.readJsonFile();
+      if (!jsonData) {
+        logger.warn('无法读取 JSON 文件进行验证');
+        return false;
+      }
+
+      const dbStats = await databaseManager.getTaskStats();
+
+      logger.info('迁移验证:');
+      logger.info(`  JSON 文件任务数: ${jsonData.length}`);
+      logger.info(`  数据库任务总数: ${dbStats.total}`);
+
+      if (jsonData.length === dbStats.total) {
+        logger.info('✅ 验证通过：任务数量一致');
+        return true;
+      } else {
+        logger.warn('⚠️ 验证失败：任务数量不一致');
+        return false;
+      }
+
+    } catch (error) {
+      logger.error('验证迁移结果失败:', error);
+      return false;
+    }
+  }
+
+  /**
+   * 回滚迁移（恢复 JSON 文件）
+   */
+  async rollback() {
+    try {
+      logger.info('开始回滚迁移...');
+
+      // 查找最新的备份文件
+      const dataDir = path.dirname(this.jsonFilePath);
+      const files = fs.readdirSync(dataDir);
+      const backupFiles = files
+        .filter(f => f.startsWith('tasks.json.backup'))
+        .sort()
+        .reverse();
+
+      if (backupFiles.length === 0) {
+        logger.error('未找到备份文件');
+        return false;
+      }
+
+      const latestBackup = path.join(dataDir, backupFiles[0]);
+      fs.copyFileSync(latestBackup, this.jsonFilePath);
+
+      logger.info(`✅ 已从备份恢复: ${latestBackup}`);
+      return true;
+
+    } catch (error) {
+      logger.error('回滚迁移失败:', error);
+      return false;
+    }
+  }
+}
+
+// 如果直接运行此文件，执行迁移
+if (require.main === module) {
+  const migration = new MigrationTool();
+
+  (async () => {
+    try {
+      // 执行迁移
+      const result = await migration.migrate();
+
+      console.log('\n迁移结果:');
+      console.log(`  成功: ${result.migrated || 0} 条`);
+      console.log(`  失败: ${result.failed || 0} 条`);
+      console.log(`  总计: ${result.total || 0} 条`);
+
+      // 验证迁移
+      const verified = await migration.verify();
+
+      if (verified) {
+        console.log('\n✅ 迁移成功并已验证');
+        process.exit(0);
+      } else {
+        console.log('\n⚠️ 迁移完成但验证失败，建议检查数据');
+        process.exit(1);
+      }
+
+    } catch (error) {
+      console.error('\n❌ 迁移失败:', error.message);
+      process.exit(1);
+    }
+  })();
+}
+
+module.exports = MigrationTool;