@cuebot/skill 1.0.5

package/src/core/backgroundExecutor.js

@@ -0,0 +1,331 @@
+/**
+ * 后台执行管理器
+ * 管理研究任务的后台运行、进度推送和完成检测
+ */
+
+import { spawn } from 'child_process';
+import { createLogger } from './logger.js';
+import { createTaskManager } from './taskManager.js';
+import { sendProgressNotification, sendResearchCompleteNotification, sendMonitorSuggestionNotification } from '../notifier/index.js';
+import { getReportContent, extractReportInsights, generateMonitorSuggestions } from '../api/cuecueClient.js';
+
+const logger = createLogger('BackgroundExecutor');
+
+// 行业关键词映射
+const industryKeywords = {
+  '新能源': [宁德时代, '比亚迪', '光伏', '锂电', '储能', '电动车', '特斯拉'],
+  '半导体': [芯片, '集成电路', '中芯国际', '华为', 'AI芯片', 'GPU', '英伟达'],
+  '医药': [药, '医疗', '生物', '疫苗', '创新药', '恒瑞'],
+  '消费': [茅台, '五粮液', '食品', '饮料', '家电', '零售'],
+  '金融': [银行, '保险', '证券', '理财', '基金', 'A股'],
+  '地产': [房地产, '万科', '碧桂园', '保利', '房价'],
+  '汽车': [汽车, '整车', '上险量', '销量', '车企']
+};
+
+/**
+ * 更新用户关注行业
+ */
+function updateFocusIndustries(chatId, topic) {
+  try {
+    const fs = require('fs');
+    const path = require('path');
+    const profilePath = path.join(process.env.HOME || '/root', ' .cuecue', chatId, 'profile.json');
+    if (!fs.existsSync(profilePath)) return;
+    
+    const profile = JSON.parse(fs.readFileSync(profilePath, 'utf-8'));
+    const industries = profile.focus_industries || [];
+    
+    for (const [industry, keywords] of Object.entries(industryKeywords)) {
+      for (const kw of keywords) {
+        if (topic.includes(kw) && !industries.includes(industry)) {
+          industries.push(industry);
+          break;
+        }
+      }
+    }
+    
+    if (industries.length > 0) {
+      profile.focus_industries = industries;
+      profile.updated_at = new Date().toISOString();
+      fs.writeFileSync(profilePath, JSON.stringify(profile, null, 2), 'utf-8');
+    }
+  } catch (e) {
+    // 忽略
+  }
+}
+
+// 存储正在运行的任务
+const runningTasks = new Map();
+
+/**
+ * 启动后台研究任务
+ * @param {Object} options
+ * @param {string} options.taskId - 任务 ID
+ * @param {string} options.topic - 研究主题
+ * @param {string} options.mode - 研究模式
+ * @param {string} options.chatId - 聊天 ID
+ * @param {string} options.apiKey - API Key
+ * @returns {Promise<Object>}
+ */
+export async function startBackgroundResearch({
+  userProfile = null,
+  taskId,
+  topic,
+  mode,
+  chatId,
+  apiKey
+}) {
+  try {
+    await logger.info(`Starting background research: ${taskId}`);
+    
+    const taskManager = createTaskManager(chatId);
+    
+    // 启动研究进程（API Key 通过环境变量传递，避免命令行暴露）
+    const researchProcess = spawn('node', [
+      'src/cron/research-worker.js',
+      taskId,
+      topic,
+      mode,
+      chatId
+    ], {
+      detached: true,
+      stdio: 'ignore',
+      env: {
+        ...process.env,
+        CUECUE_USER_PROFILE: JSON.stringify(userProfile),
+        CUECUE_API_KEY: apiKey
+      }
+    });
+    
+    // 保存进程信息
+    runningTasks.set(taskId, {
+      pid: researchProcess.pid,
+      startTime: Date.now(),
+      chatId,
+      topic
+    });
+    
+    // 保存 PID 到任务文件
+    await taskManager.updateTask(taskId, {
+      pid: researchProcess.pid,
+      status: 'running'
+    });
+    
+    // 启动进度推送定时器
+    startProgressNotifier(taskId, chatId, topic);
+    
+    // 启动完成检测（传递 apiKey 以便获取报告）
+    startCompletionWatcher(taskId, chatId, topic, researchProcess, apiKey);
+    
+    await logger.info(`Background research started: ${taskId} (PID: ${researchProcess.pid})`);
+    
+    return {
+      taskId,
+      pid: researchProcess.pid,
+      status: 'started'
+    };
+  } catch (error) {
+    await logger.error(`Failed to start background research: ${taskId}`, error);
+    throw error;
+  }
+}
+
+/**
+ * 启动进度推送定时器
+ * @param {string} taskId - 任务 ID
+ * @param {string} chatId - 聊天 ID
+ * @param {string} topic - 研究主题
+ */
+function startProgressNotifier(taskId, chatId, topic) {
+  const startTime = Date.now();
+  
+  // 每5分钟推送一次进度
+  const intervalId = setInterval(async () => {
+    try {
+      // 检查任务是否还在运行
+      if (!runningTasks.has(taskId)) {
+        clearInterval(intervalId);
+        return;
+      }
+      
+      const elapsedMinutes = Math.round((Date.now() - startTime) / (1000 * 60));
+      
+      // 超过60分钟自动停止
+      if (elapsedMinutes >= 60) {
+        clearInterval(intervalId);
+        return;
+      }
+      
+      // 发送进度通知
+      await sendProgressNotification({
+        chatId,
+        taskId,
+        topic,
+        progress: getStageDescription(elapsedMinutes),
+        elapsedMinutes
+      });
+      
+      await logger.info(`Progress notification sent: ${taskId} (${elapsedMinutes}min)`);
+    } catch (error) {
+      await logger.error(`Progress notification failed: ${taskId}`, error);
+    }
+  }, 5 * 60 * 1000); // 5分钟
+}
+
+/**
+ * 启动完成检测
+ * @param {string} taskId - 任务 ID
+ * @param {string} chatId - 聊天 ID
+ * @param {string} topic - 研究主题
+ * @param {Object} process - 子进程
+ * @param {string} apiKey - API Key
+ */
+function startCompletionWatcher(taskId, chatId, topic, process, apiKey) {
+  const startTime = Date.now();
+  const timeoutMs = 60 * 60 * 1000; // 60分钟超时
+  
+  process.on('exit', async (code) => {
+    try {
+      const elapsedMinutes = Math.round((Date.now() - startTime) / (1000 * 60));
+      const taskManager = createTaskManager(chatId);
+      
+      runningTasks.delete(taskId);
+      
+      if (code === 0) {
+        // 成功完成 - 获取报告内容
+        try {
+          // 从任务管理器获取 conversation_id
+          const task = await taskManager.getTask(taskId);
+          const conversationId = task?.conversation_id;
+          
+          if (!conversationId) {
+            throw new Error('conversation_id not found in task');
+          }
+          
+          // 使用传入的 apiKey 参数
+          const report = await getReportContent(conversationId, apiKey);
+          const insights = extractReportInsights(report);
+          const monitorSuggestions = generateMonitorSuggestions(insights, topic);
+          
+          // 保存报告内容到任务
+          await taskManager.completeTask(taskId, {
+            conversation_id: conversationId,
+            report_url: `https://cuecue.cn/c/${conversationId}`,
+            summary: insights.summary,
+            key_points: insights.keyPoints,
+            monitor_suggestions: monitorSuggestions
+          });
+          
+          // 清理运行中任务记录
+          runningTasks.delete(taskId);
+          
+          // 发送完成通知（带监控建议）
+          await updateFocusIndustries(chatId, topic);
+          await sendResearchCompleteNotification({
+            chatId,
+            taskId,
+            topic,
+            reportUrl: `https://cuecue.cn/c/${conversationId}`,
+            duration: elapsedMinutes,
+            monitorSuggestions: monitorSuggestions.map(s => s.title)
+          });
+          
+          // 发送监控建议通知
+          if (monitorSuggestions.length > 0) {
+            await sendMonitorSuggestionNotification({
+              chatId,
+              taskId,
+              topic,
+              suggestions: monitorSuggestions
+            });
+          }
+          
+          await logger.info(`Research completed with report: ${taskId}`);
+        } catch (reportError) {
+          // 如果获取报告失败，仍然标记完成
+          await logger.error(`Failed to get report content: ${taskId}`, reportError);
+          
+          // 尝试从任务获取 conversation_id
+          const task = await taskManager.getTask(taskId);
+          const conversationId = task?.conversation_id || 'unknown';
+          
+          await taskManager.completeTask(taskId, {
+            conversation_id: conversationId,
+            report_url: `https://cuecue.cn/c/${conversationId}`
+          });
+          
+          // 清理运行中任务记录
+          runningTasks.delete(taskId);
+          await updateFocusIndustries(chatId, topic);
+          await sendResearchCompleteNotification({
+            chatId,
+            taskId,
+            topic,
+            reportUrl: `https://cuecue.cn/c/${conversationId}`,
+            duration: elapsedMinutes
+          });
+        }
+      } else {
+        // 失败
+        await taskManager.failTask(taskId, `Process exited with code ${code}`);
+        await logger.error(`Research failed: ${taskId} (code: ${code})`);
+      }
+    } catch (error) {
+      await logger.error(`Completion handling failed: ${taskId}`, error);
+    }
+  });
+  
+  // 超时检测
+  setTimeout(async () => {
+    if (runningTasks.has(taskId)) {
+      try {
+        process.kill();
+        runningTasks.delete(taskId);
+        
+        const taskManager = createTaskManager(chatId);
+        await taskManager.timeoutTask(taskId);
+        
+        await logger.warn(`Research timeout: ${taskId}`);
+      } catch (error) {
+        await logger.error(`Timeout handling failed: ${taskId}`, error);
+      }
+    }
+  }, timeoutMs);
+}
+
+/**
+ * 获取阶段描述
+ * @param {number} elapsedMinutes - 已耗时（分钟）
+ * @returns {string}
+ */
+function getStageDescription(elapsedMinutes) {
+  if (elapsedMinutes < 10) {
+    return '全网信息搜集与初步筛选';
+  } else if (elapsedMinutes < 30) {
+    return '多源交叉验证与事实核查';
+  } else if (elapsedMinutes < 50) {
+    return '深度分析与逻辑推理';
+  } else {
+    return '报告生成与质量检查';
+  }
+}
+
+/**
+ * 检查任务是否正在运行
+ * @param {string} taskId - 任务 ID
+ * @returns {boolean}
+ */
+export function isTaskRunning(taskId) {
+  return runningTasks.has(taskId);
+}
+
+/**
+ * 获取运行中的任务列表
+ * @returns {Array}
+ */
+export function getRunningTasks() {
+  return Array.from(runningTasks.entries()).map(([taskId, info]) => ({
+    taskId,
+    ...info
+  }));
+}

package/src/core/logger.js

@@ -0,0 +1,130 @@
+/**
+ * 日志系统
+ * 提供统一的日志记录功能
+ */
+
+import fs from 'fs-extra';
+import path from 'path';
+import { getLogDir } from '../utils/fileUtils.js';
+
+/**
+ * 日志级别
+ */
+export const LogLevel = {
+  DEBUG: 0,
+  INFO: 1,
+  WARN: 2,
+  ERROR: 3
+};
+
+/**
+ * 日志类
+ */
+export class Logger {
+  constructor(moduleName) {
+    this.moduleName = moduleName;
+    this.logDir = getLogDir();
+    this.level = LogLevel.INFO;
+  }
+
+  /**
+   * 获取日志文件路径
+   * @returns {string}
+   */
+  getLogFilePath() {
+    const today = new Date().toISOString().slice(0, 10);
+    return path.join(this.logDir, `cue-${today}.log`);
+  }
+
+  /**
+   * 格式化日志消息
+   * @param {string} level - 日志级别
+   * @param {string} message - 消息
+   * @returns {string}
+   */
+  formatMessage(level, message) {
+    const timestamp = new Date().toISOString();
+    return `[${timestamp}] [${level}] [${this.moduleName}] ${message}`;
+  }
+
+  /**
+   * 写入日志
+   * @param {string} level - 日志级别
+   * @param {string} message - 消息
+   */
+  async log(level, message) {
+    try {
+      await fs.ensureDir(this.logDir);
+      const logLine = this.formatMessage(level, message) + '\n';
+      await fs.appendFile(this.getLogFilePath(), logLine);
+    } catch (error) {
+      console.error('Failed to write log:', error);
+    }
+  }
+
+  /**
+   * 调试日志
+   * @param {string} message
+   */
+  async debug(message) {
+    if (this.level <= LogLevel.DEBUG) {
+      await this.log('DEBUG', message);
+    }
+  }
+
+  /**
+   * 信息日志
+   * @param {string} message
+   */
+  async info(message) {
+    if (this.level <= LogLevel.INFO) {
+      await this.log('INFO', message);
+      console.log(message);
+    }
+  }
+
+  /**
+   * 警告日志
+   * @param {string} message
+   */
+  async warn(message) {
+    if (this.level <= LogLevel.WARN) {
+      await this.log('WARN', message);
+      console.warn('⚠️', message);
+    }
+  }
+
+  /**
+   * 错误日志
+   * @param {string} message
+   * @param {Error} [error]
+   */
+  async error(message, error = null) {
+    if (this.level <= LogLevel.ERROR) {
+      const fullMessage = error ? `${message}: ${error.message}` : message;
+      await this.log('ERROR', fullMessage);
+      console.error('❌', fullMessage);
+      
+      if (error?.stack) {
+        await this.log('ERROR', error.stack);
+      }
+    }
+  }
+
+  /**
+   * 设置日志级别
+   * @param {number} level
+   */
+  setLevel(level) {
+    this.level = level;
+  }
+}
+
+/**
+ * 创建日志实例
+ * @param {string} moduleName - 模块名称
+ * @returns {Logger}
+ */
+export function createLogger(moduleName) {
+  return new Logger(moduleName);
+}

package/src/core/monitorManager.js

@@ -0,0 +1,139 @@
+/**
+ * 监控管理
+ * 管理监控项的创建、更新和查询
+ */
+
+import fs from 'fs-extra';
+import path from 'path';
+import { getMonitorFilePath, listJsonFiles, ensureDir, getUserDir } from '../utils/fileUtils.js';
+import { createLogger } from './logger.js';
+
+const logger = createLogger('MonitorManager');
+
+/**
+ * 监控管理类
+ */
+export class MonitorManager {
+  constructor(chatId) {
+    this.chatId = chatId;
+    this.monitorsDir = path.join(getUserDir(chatId), 'monitors');
+  }
+
+  /**
+   * 创建监控项
+   * @param {Object} monitorData - 监控数据
+   * @returns {Promise<Object>}
+   */
+  async createMonitor(monitorData) {
+    const { monitorId, title, symbol, category, trigger } = monitorData;
+    
+    await ensureDir(this.monitorsDir);
+    
+    const monitor = {
+      monitor_id: monitorId,
+      title,
+      symbol,
+      category,
+      semantic_trigger: trigger,
+      is_active: true,
+      created_at: new Date().toISOString(),
+      ...monitorData
+    };
+    
+    const filePath = getMonitorFilePath(this.chatId, monitorId);
+    await fs.writeJson(filePath, monitor, { spaces: 2 });
+    
+    await logger.info(`Monitor created: ${monitorId}`);
+    return monitor;
+  }
+
+  /**
+   * 更新监控项
+   * @param {string} monitorId - 监控 ID
+   * @param {Object} updates - 更新数据
+   * @returns {Promise<Object|null>}
+   */
+  async updateMonitor(monitorId, updates) {
+    const filePath = getMonitorFilePath(this.chatId, monitorId);
+    
+    try {
+      const monitor = await fs.readJson(filePath);
+      const updatedMonitor = { ...monitor, ...updates };
+      await fs.writeJson(filePath, updatedMonitor, { spaces: 2 });
+      await logger.info(`Monitor updated: ${monitorId}`);
+      return updatedMonitor;
+    } catch (error) {
+      await logger.error(`Failed to update monitor ${monitorId}`, error);
+      return null;
+    }
+  }
+
+  /**
+   * 获取监控项
+   * @param {string} monitorId - 监控 ID
+   * @returns {Promise<Object|null>}
+   */
+  async getMonitor(monitorId) {
+    const filePath = getMonitorFilePath(this.chatId, monitorId);
+    
+    try {
+      return await fs.readJson(filePath);
+    } catch (error) {
+      if (error.code === 'ENOENT') {
+        return null;
+      }
+      throw error;
+    }
+  }
+
+  /**
+   * 获取监控列表
+   * @param {number} limit - 限制数量
+   * @returns {Promise<Array>}
+   */
+  async getMonitors(limit = 15) {
+    const files = await listJsonFiles(this.monitorsDir);
+    const monitors = [];
+    
+    for (const file of files.slice(0, limit)) {
+      try {
+        const monitor = await fs.readJson(path.join(this.monitorsDir, file));
+        monitors.push(monitor);
+      } catch (error) {
+        await logger.error(`Failed to read monitor ${file}`, error);
+      }
+    }
+    
+    return monitors;
+  }
+
+  /**
+   * 获取激活的监控
+   * @returns {Promise<Array>}
+   */
+  async getActiveMonitors() {
+    const monitors = await this.getMonitors(100);
+    return monitors.filter(m => m.is_active !== false);
+  }
+
+  /**
+   * 统计监控数量
+   * @returns {Promise<{total: number, active: number}>}
+   */
+  async getStats() {
+    const monitors = await this.getMonitors(1000);
+    return {
+      total: monitors.length,
+      active: monitors.filter(m => m.is_active !== false).length
+    };
+  }
+}
+
+/**
+ * 创建监控管理器实例
+ * @param {string} chatId
+ * @returns {MonitorManager}
+ */
+export function createMonitorManager(chatId) {
+  return new MonitorManager(chatId);
+}