inspiration-agent 0.0.1

package/dist/services/database.service.js

@@ -0,0 +1,697 @@
+const sqlite3 = require("sqlite3").verbose();
+const path = require("path");
+const fs = require("fs");
+
+/**
+ * 数据库服务类
+ * 负责所有数据库操作，包括对话历史、智能体配置和长期记忆
+ */
+class DatabaseService {
+  constructor() {
+    const dbPathFromEnv = process.env.DATABASE_PATH || "./data/ai_agent.db";
+    this.dbPath = path.resolve(dbPathFromEnv);
+    this.db = null;
+  }
+
+  /**
+   * 连接数据库
+   * @returns {Promise<void>}
+   */
+  async connect() {
+    const dbDir = path.dirname(this.dbPath);
+    if (!fs.existsSync(dbDir)) {
+      fs.mkdirSync(dbDir, { recursive: true });
+    }
+
+    return new Promise((resolve, reject) => {
+      this.db = new sqlite3.Database(this.dbPath, (err) => {
+        if (err) {
+          reject(err);
+        } else {
+          resolve();
+        }
+      });
+    });
+  }
+
+  /**
+   * 初始化所有数据表
+   * @returns {Promise<void>}
+   */
+  async initTables() {
+    const createConversationTableSQL = `
+      CREATE TABLE IF NOT EXISTS conversation_history (
+        id INTEGER PRIMARY KEY AUTOINCREMENT,
+        role TEXT NOT NULL,
+        content TEXT NOT NULL,
+        created_at DATETIME DEFAULT CURRENT_TIMESTAMP
+      )
+    `;
+
+    const createLongTermMemoryTableSQL = `
+      CREATE TABLE IF NOT EXISTS long_term_memory (
+        id INTEGER PRIMARY KEY AUTOINCREMENT,
+        type TEXT NOT NULL,
+        content TEXT NOT NULL,
+        keywords TEXT,
+        importance INTEGER DEFAULT 0,
+        access_count INTEGER DEFAULT 0,
+        created_at DATETIME DEFAULT CURRENT_TIMESTAMP,
+        last_accessed DATETIME DEFAULT CURRENT_TIMESTAMP
+      )
+    `;
+
+    const createMemoryTypeIndexSQL = `
+      CREATE INDEX IF NOT EXISTS idx_memory_type ON long_term_memory(type)
+    `;
+
+    const createMemoryImportanceIndexSQL = `
+      CREATE INDEX IF NOT EXISTS idx_memory_importance ON long_term_memory(importance DESC)
+    `;
+
+    const createScheduledTasksTableSQL = `
+      CREATE TABLE IF NOT EXISTS scheduled_tasks (
+        id INTEGER PRIMARY KEY AUTOINCREMENT,
+        name TEXT NOT NULL,
+        description TEXT,
+        cron_expression TEXT NOT NULL,
+        prompt TEXT NOT NULL,
+        enabled INTEGER DEFAULT 1,
+        last_run_at DATETIME,
+        next_run_at DATETIME,
+        run_count INTEGER DEFAULT 0,
+        created_at DATETIME DEFAULT CURRENT_TIMESTAMP,
+        updated_at DATETIME DEFAULT CURRENT_TIMESTAMP
+      )
+    `;
+
+    const createScheduledTasksIndexSQL = `
+      CREATE INDEX IF NOT EXISTS idx_scheduled_tasks_enabled ON scheduled_tasks(enabled)
+    `;
+
+    const createTokenUsageTableSQL = `
+      CREATE TABLE IF NOT EXISTS token_usage (
+        id INTEGER PRIMARY KEY AUTOINCREMENT,
+        date TEXT NOT NULL UNIQUE,
+        input_tokens INTEGER DEFAULT 0,
+        output_tokens INTEGER DEFAULT 0,
+        total_tokens INTEGER DEFAULT 0,
+        request_count INTEGER DEFAULT 0,
+        created_at DATETIME DEFAULT CURRENT_TIMESTAMP,
+        updated_at DATETIME DEFAULT CURRENT_TIMESTAMP
+      )
+    `;
+
+    const createTokenUsageDateIndexSQL = `
+      CREATE INDEX IF NOT EXISTS idx_token_usage_date ON token_usage(date)
+    `;
+
+    return new Promise((resolve, reject) => {
+      this.db.serialize(() => {
+        this.db.run(createConversationTableSQL, (err) => {
+          if (err) {
+            reject(err);
+          }
+        });
+
+        this.db.run(createLongTermMemoryTableSQL, (err) => {
+          if (err) {
+            reject(err);
+          }
+        });
+
+        this.db.run(createScheduledTasksTableSQL, (err) => {
+          if (err) {
+            reject(err);
+          }
+        });
+
+        this.db.run(createTokenUsageTableSQL, (err) => {
+          if (err) {
+            reject(err);
+          }
+        });
+
+        this.db.run(createMemoryTypeIndexSQL, (err) => {
+          if (err) {
+            reject(err);
+          }
+        });
+
+        this.db.run(createMemoryImportanceIndexSQL, (err) => {
+          if (err) {
+            reject(err);
+          }
+        });
+
+        this.db.run(createScheduledTasksIndexSQL, (err) => {
+          if (err) {
+            reject(err);
+          }
+        });
+
+        this.db.run(createTokenUsageDateIndexSQL, (err) => {
+          if (err) {
+            reject(err);
+          } else {
+            resolve();
+          }
+        });
+      });
+    });
+  }
+
+  /**
+   * 保存对话消息
+   * @param {string} role - 消息角色（user/assistant）
+   * @param {string} content - 消息内容
+   * @returns {Promise<{id: number}>} 插入的记录 ID
+   */
+  async saveMessage(role, content) {
+    const sql = `INSERT INTO conversation_history (role, content) VALUES (?, ?)`;
+
+    return new Promise((resolve, reject) => {
+      this.db.run(sql, [role, content], function (err) {
+        if (err) {
+          reject(err);
+        } else {
+          resolve({ id: this.lastID });
+        }
+      });
+    });
+  }
+
+  /**
+   * 获取所有对话消息
+   * @returns {Promise<Array>} 消息数组
+   */
+  async getAllMessages() {
+    const sql = `SELECT role, content, created_at FROM conversation_history ORDER BY id ASC`;
+
+    return new Promise((resolve, reject) => {
+      this.db.all(sql, [], (err, rows) => {
+        if (err) {
+          reject(err);
+        } else {
+          resolve(rows);
+        }
+      });
+    });
+  }
+
+  /**
+   * 清空对话历史
+   * @returns {Promise<void>}
+   */
+  async clearHistory() {
+    const sql = `DELETE FROM conversation_history`;
+
+    return new Promise((resolve, reject) => {
+      this.db.run(sql, (err) => {
+        if (err) {
+          reject(err);
+        } else {
+          resolve();
+        }
+      });
+    });
+  }
+
+  /**
+   * 保存长期记忆
+   * @param {Object} memoryData - 记忆数据
+   * @param {string} memoryData.type - 记忆类型
+   * @param {string} memoryData.content - 记忆内容
+   * @param {Array<string>} memoryData.keywords - 关键词数组
+   * @param {number} memoryData.importance - 重要性分数（默认 0）
+   * @returns {Promise<{id: number}>} 插入的记录 ID
+   */
+  async saveLongTermMemory(memoryData) {
+    const { type, content, keywords, importance = 0 } = memoryData;
+    const sql = `
+      INSERT INTO long_term_memory (type, content, keywords, importance)
+      VALUES (?, ?, ?, ?)
+    `;
+
+    return new Promise((resolve, reject) => {
+      this.db.run(sql, [type, content, JSON.stringify(keywords || []), importance], function (err) {
+        if (err) {
+          reject(err);
+        } else {
+          resolve({ id: this.lastID });
+        }
+      });
+    });
+  }
+
+  /**
+   * 获取长期记忆
+   * @param {string|null} type - 记忆类型过滤，null 表示不过滤
+   * @param {number} limit - 返回结果数量限制，默认 20
+   * @returns {Promise<Array>} 记忆数组
+   */
+  async getLongTermMemories(type = null, limit = 20) {
+    let sql = `SELECT * FROM long_term_memory`;
+    const params = [];
+
+    if (type) {
+      sql += ` WHERE type = ?`;
+      params.push(type);
+    } else {
+      sql += ` WHERE type != 'conversation'`;
+    }
+
+    sql += ` ORDER BY importance DESC, last_accessed DESC LIMIT ?`;
+    params.push(limit);
+
+    return new Promise((resolve, reject) => {
+      this.db.all(sql, params, (err, rows) => {
+        if (err) {
+          reject(err);
+        } else {
+          const memories = rows.map((row) => ({
+            id: row.id,
+            type: row.type,
+            content: row.content,
+            keywords: JSON.parse(row.keywords || "[]"),
+            importance: row.importance,
+            access_count: row.access_count,
+            created_at: row.created_at,
+            last_accessed: row.last_accessed,
+          }));
+          resolve(memories);
+        }
+      });
+    });
+  }
+
+  /**
+   * 搜索长期记忆
+   * @param {string} query - 搜索关键词
+   * @param {number} limit - 返回结果数量限制，默认 10
+   * @returns {Promise<Array>} 匹配的记忆数组
+   */
+  async searchLongTermMemories(query, limit = 10) {
+    const sql = `
+      SELECT * FROM long_term_memory
+      WHERE (content LIKE ? OR keywords LIKE ?) AND type != 'conversation'
+      ORDER BY importance DESC, last_accessed DESC
+      LIMIT ?
+    `;
+
+    const searchPattern = `%${query}%`;
+
+    return new Promise((resolve, reject) => {
+      this.db.all(sql, [searchPattern, searchPattern, limit], (err, rows) => {
+        if (err) {
+          reject(err);
+        } else {
+          const memories = rows.map((row) => ({
+            id: row.id,
+            type: row.type,
+            content: row.content,
+            keywords: JSON.parse(row.keywords || "[]"),
+            importance: row.importance,
+            access_count: row.access_count,
+            created_at: row.created_at,
+            last_accessed: row.last_accessed,
+          }));
+          resolve(memories);
+        }
+      });
+    });
+  }
+
+  /**
+   * 更新记忆访问记录
+   * @param {number} id - 记忆 ID
+   * @returns {Promise<void>}
+   */
+  async updateMemoryAccess(id) {
+    const sql = `
+      UPDATE long_term_memory
+      SET access_count = access_count + 1,
+          last_accessed = CURRENT_TIMESTAMP
+      WHERE id = ?
+    `;
+
+    return new Promise((resolve, reject) => {
+      this.db.run(sql, [id], (err) => {
+        if (err) {
+          reject(err);
+        } else {
+          resolve();
+        }
+      });
+    });
+  }
+
+  /**
+   * 删除长期记忆
+   * @param {number} id - 记忆 ID
+   * @returns {Promise<{deleted: boolean}>} 是否删除成功
+   */
+  async deleteLongTermMemory(id) {
+    const sql = `DELETE FROM long_term_memory WHERE id = ?`;
+
+    return new Promise((resolve, reject) => {
+      this.db.run(sql, [id], function (err) {
+        if (err) {
+          reject(err);
+        } else {
+          resolve({ deleted: this.changes > 0 });
+        }
+      });
+    });
+  }
+
+  async saveScheduledTask(taskData) {
+    const { name, description, cronExpression, prompt, enabled = true, nextRunAt } = taskData;
+    const sql = `
+      INSERT INTO scheduled_tasks (name, description, cron_expression, prompt, enabled, next_run_at)
+      VALUES (?, ?, ?, ?, ?, ?)
+    `;
+
+    return new Promise((resolve, reject) => {
+      this.db.run(
+        sql,
+        [name, description || "", cronExpression, prompt, enabled ? 1 : 0, nextRunAt || null],
+        function (err) {
+          if (err) {
+            reject(err);
+          } else {
+            resolve({ id: this.lastID });
+          }
+        }
+      );
+    });
+  }
+
+  async getAllScheduledTasks() {
+    const sql = `SELECT * FROM scheduled_tasks ORDER BY created_at ASC`;
+
+    return new Promise((resolve, reject) => {
+      this.db.all(sql, [], (err, rows) => {
+        if (err) {
+          reject(err);
+        } else {
+          const tasks = rows.map((row) => ({
+            id: row.id,
+            name: row.name,
+            description: row.description,
+            cronExpression: row.cron_expression,
+            prompt: row.prompt,
+            enabled: row.enabled === 1,
+            lastRunAt: row.last_run_at,
+            nextRunAt: row.next_run_at,
+            runCount: row.run_count,
+            createdAt: row.created_at,
+            updatedAt: row.updated_at,
+          }));
+          resolve(tasks);
+        }
+      });
+    });
+  }
+
+  async getScheduledTaskById(id) {
+    const sql = `SELECT * FROM scheduled_tasks WHERE id = ?`;
+
+    return new Promise((resolve, reject) => {
+      this.db.get(sql, [id], (err, row) => {
+        if (err) {
+          reject(err);
+        } else if (row) {
+          const task = {
+            id: row.id,
+            name: row.name,
+            description: row.description,
+            cronExpression: row.cron_expression,
+            prompt: row.prompt,
+            enabled: row.enabled === 1,
+            lastRunAt: row.last_run_at,
+            nextRunAt: row.next_run_at,
+            runCount: row.run_count,
+            createdAt: row.created_at,
+            updatedAt: row.updated_at,
+          };
+          resolve(task);
+        } else {
+          resolve(null);
+        }
+      });
+    });
+  }
+
+  async updateScheduledTask(id, taskData) {
+    const { name, description, cronExpression, prompt, enabled, nextRunAt } = taskData;
+    const updates = [];
+    const values = [];
+
+    if (name !== undefined) {
+      updates.push("name = ?");
+      values.push(name);
+    }
+    if (description !== undefined) {
+      updates.push("description = ?");
+      values.push(description);
+    }
+    if (cronExpression !== undefined) {
+      updates.push("cron_expression = ?");
+      values.push(cronExpression);
+    }
+    if (prompt !== undefined) {
+      updates.push("prompt = ?");
+      values.push(prompt);
+    }
+    if (enabled !== undefined) {
+      updates.push("enabled = ?");
+      values.push(enabled ? 1 : 0);
+    }
+    if (nextRunAt !== undefined) {
+      updates.push("next_run_at = ?");
+      values.push(nextRunAt);
+    }
+
+    if (updates.length === 0) {
+      return { updated: false };
+    }
+
+    updates.push("updated_at = CURRENT_TIMESTAMP");
+    values.push(id);
+
+    const sql = `UPDATE scheduled_tasks SET ${updates.join(", ")} WHERE id = ?`;
+
+    return new Promise((resolve, reject) => {
+      this.db.run(sql, values, function (err) {
+        if (err) {
+          reject(err);
+        } else {
+          resolve({ updated: this.changes > 0, id: id });
+        }
+      });
+    });
+  }
+
+  async updateTaskRunInfo(id, lastRunAt, nextRunAt) {
+    const sql = `
+      UPDATE scheduled_tasks
+      SET last_run_at = ?,
+          next_run_at = ?,
+          run_count = run_count + 1,
+          updated_at = CURRENT_TIMESTAMP
+      WHERE id = ?
+    `;
+
+    return new Promise((resolve, reject) => {
+      this.db.run(sql, [lastRunAt, nextRunAt, id], function (err) {
+        if (err) {
+          reject(err);
+        } else {
+          resolve({ updated: this.changes > 0 });
+        }
+      });
+    });
+  }
+
+  async deleteScheduledTask(id) {
+    const sql = `DELETE FROM scheduled_tasks WHERE id = ?`;
+
+    return new Promise((resolve, reject) => {
+      this.db.run(sql, [id], function (err) {
+        if (err) {
+          reject(err);
+        } else {
+          resolve({ deleted: this.changes > 0 });
+        }
+      });
+    });
+  }
+
+  async getEnabledScheduledTasks() {
+    const sql = `SELECT * FROM scheduled_tasks WHERE enabled = 1 ORDER BY created_at ASC`;
+
+    return new Promise((resolve, reject) => {
+      this.db.all(sql, [], (err, rows) => {
+        if (err) {
+          reject(err);
+        } else {
+          const tasks = rows.map((row) => ({
+            id: row.id,
+            name: row.name,
+            description: row.description,
+            cronExpression: row.cron_expression,
+            prompt: row.prompt,
+            enabled: row.enabled === 1,
+            lastRunAt: row.last_run_at,
+            nextRunAt: row.next_run_at,
+            runCount: row.run_count,
+            createdAt: row.created_at,
+            updatedAt: row.updated_at,
+          }));
+          resolve(tasks);
+        }
+      });
+    });
+  }
+
+  _getLocalDateString() {
+    const now = new Date();
+    const year = now.getFullYear();
+    const month = String(now.getMonth() + 1).padStart(2, "0");
+    const day = String(now.getDate()).padStart(2, "0");
+    return `${year}-${month}-${day}`;
+  }
+
+  async recordTokenUsage(inputTokens, outputTokens) {
+    const today = this._getLocalDateString();
+    const sql = `
+      INSERT INTO token_usage (date, input_tokens, output_tokens, total_tokens, request_count)
+      VALUES (?, ?, ?, ?, 1)
+      ON CONFLICT(date) DO UPDATE SET
+        input_tokens = input_tokens + ?,
+        output_tokens = output_tokens + ?,
+        total_tokens = total_tokens + ?,
+        request_count = request_count + 1,
+        updated_at = CURRENT_TIMESTAMP
+    `;
+
+    const totalTokens = inputTokens + outputTokens;
+
+    return new Promise((resolve, reject) => {
+      this.db.run(
+        sql,
+        [today, inputTokens, outputTokens, totalTokens, inputTokens, outputTokens, totalTokens],
+        function (err) {
+          if (err) {
+            reject(err);
+          } else {
+            resolve({ success: true });
+          }
+        }
+      );
+    });
+  }
+
+  async getTodayTokenUsage() {
+    const today = this._getLocalDateString();
+    const sql = `SELECT * FROM token_usage WHERE date = ?`;
+
+    return new Promise((resolve, reject) => {
+      this.db.get(sql, [today], (err, row) => {
+        if (err) {
+          reject(err);
+        } else if (row) {
+          resolve({
+            date: row.date,
+            inputTokens: row.input_tokens,
+            outputTokens: row.output_tokens,
+            totalTokens: row.total_tokens,
+            requestCount: row.request_count,
+          });
+        } else {
+          resolve({
+            date: today,
+            inputTokens: 0,
+            outputTokens: 0,
+            totalTokens: 0,
+            requestCount: 0,
+          });
+        }
+      });
+    });
+  }
+
+  async getTotalTokenUsage() {
+    const sql = `
+      SELECT 
+        SUM(input_tokens) as total_input_tokens,
+        SUM(output_tokens) as total_output_tokens,
+        SUM(total_tokens) as total_tokens,
+        SUM(request_count) as total_request_count
+      FROM token_usage
+    `;
+
+    return new Promise((resolve, reject) => {
+      this.db.get(sql, [], (err, row) => {
+        if (err) {
+          reject(err);
+        } else {
+          resolve({
+            totalInputTokens: row.total_input_tokens || 0,
+            totalOutputTokens: row.total_output_tokens || 0,
+            totalTokens: row.total_tokens || 0,
+            totalRequestCount: row.total_request_count || 0,
+          });
+        }
+      });
+    });
+  }
+
+  async getTokenUsageByDateRange(startDate, endDate) {
+    const sql = `
+      SELECT * FROM token_usage 
+      WHERE date >= ? AND date <= ? 
+      ORDER BY date ASC
+    `;
+
+    return new Promise((resolve, reject) => {
+      this.db.all(sql, [startDate, endDate], (err, rows) => {
+        if (err) {
+          reject(err);
+        } else {
+          const usage = rows.map((row) => ({
+            date: row.date,
+            inputTokens: row.input_tokens,
+            outputTokens: row.output_tokens,
+            totalTokens: row.total_tokens,
+            requestCount: row.request_count,
+          }));
+          resolve(usage);
+        }
+      });
+    });
+  }
+
+  /**
+   * 关闭数据库连接
+   * @returns {Promise<void>}
+   */
+  async close() {
+    return new Promise((resolve, reject) => {
+      if (this.db) {
+        this.db.close((err) => {
+          if (err) {
+            reject(err);
+          } else {
+            resolve();
+          }
+        });
+      } else {
+        resolve();
+      }
+    });
+  }
+}
+
+module.exports = DatabaseService;