@cuebot/skill 1.0.5

package/src/core/taskManager.js

@@ -0,0 +1,212 @@
+/**
+ * 任务管理
+ * 管理研究任务的创建、更新和查询
+ */
+
+import fs from 'fs-extra';
+import path from 'path';
+import { getTaskFilePath, listJsonFiles, ensureDir, getUserDir } from '../utils/fileUtils.js';
+import { createLogger } from './logger.js';
+
+const logger = createLogger('TaskManager');
+
+/**
+ * 任务状态枚举
+ */
+export const TaskStatus = {
+  RUNNING: 'running',
+  COMPLETED: 'completed',
+  FAILED: 'failed',
+  TIMEOUT: 'timeout'
+};
+
+/**
+ * 任务管理类
+ */
+export class TaskManager {
+  constructor(chatId) {
+    this.chatId = chatId;
+    this.tasksDir = path.join(getUserDir(chatId), 'tasks');
+  }
+
+  /**
+   * 创建任务
+   * @param {Object} taskData - 任务数据
+   * @returns {Promise<Object>}
+   */
+  async createTask(taskData) {
+    const { taskId, topic, mode = 'default' } = taskData;
+    
+    await ensureDir(this.tasksDir);
+    
+    const task = {
+      task_id: taskId,
+      topic,
+      mode,
+      chat_id: this.chatId,
+      status: TaskStatus.RUNNING,
+      created_at: new Date().toISOString(),
+      progress: '初始化',
+      ...taskData
+    };
+    
+    const filePath = getTaskFilePath(this.chatId, taskId);
+    await fs.writeJson(filePath, task, { spaces: 2 });
+    
+    await logger.info(`Task created: ${taskId}`);
+    return task;
+  }
+
+  /**
+   * 更新任务状态
+   * @param {string} taskId - 任务 ID
+   * @param {Object} updates - 更新数据
+   * @returns {Promise<Object|null>}
+   */
+  async updateTask(taskId, updates) {
+    const filePath = getTaskFilePath(this.chatId, taskId);
+    
+    try {
+      const task = await fs.readJson(filePath);
+      const updatedTask = { ...task, ...updates };
+      
+      if (updates.status === TaskStatus.COMPLETED) {
+        updatedTask.completed_at = new Date().toISOString();
+      }
+      
+      await fs.writeJson(filePath, updatedTask, { spaces: 2 });
+      await logger.info(`Task updated: ${taskId}`);
+      return updatedTask;
+    } catch (error) {
+      await logger.error(`Failed to update task ${taskId}`, error);
+      return null;
+    }
+  }
+
+  /**
+   * 更新任务进度
+   * @param {string} taskId - 任务 ID
+   * @param {string} progress - 进度描述
+   * @param {number} percent - 进度百分比
+   */
+  async updateTaskProgress(taskId, progress, percent) {
+    return await this.updateTask(taskId, {
+      progress,
+      percent,
+      last_updated: new Date().toISOString()
+    });
+  }
+
+  /**
+   * 标记任务为完成
+   * @param {string} taskId - 任务 ID
+   * @param {Object} result - 结果数据
+   */
+  async completeTask(taskId, result = {}) {
+    const task = await this.getTask(taskId);
+    if (!task) return null;
+    
+    const startTime = new Date(task.created_at);
+    const endTime = new Date();
+    const durationMinutes = Math.round((endTime - startTime) / (1000 * 60));
+    
+    return await this.updateTask(taskId, {
+      status: TaskStatus.COMPLETED,
+      completed_at: endTime.toISOString(),
+      duration: durationMinutes,
+      result,
+      progress: '已完成',
+      percent: 100
+    });
+  }
+
+  /**
+   * 标记任务为失败
+   * @param {string} taskId - 任务 ID
+   * @param {string} error - 错误信息
+   */
+  async failTask(taskId, error) {
+    return await this.updateTask(taskId, {
+      status: TaskStatus.FAILED,
+      error,
+      completed_at: new Date().toISOString()
+    });
+  }
+
+  /**
+   * 标记任务为超时
+   * @param {string} taskId - 任务 ID
+   */
+  async timeoutTask(taskId) {
+    return await this.updateTask(taskId, {
+      status: TaskStatus.TIMEOUT,
+      completed_at: new Date().toISOString()
+    });
+  }
+
+  /**
+   * 获取任务
+   * @param {string} taskId - 任务 ID
+   * @returns {Promise<Object|null>}
+   */
+  async getTask(taskId) {
+    const filePath = getTaskFilePath(this.chatId, taskId);
+    
+    try {
+      return await fs.readJson(filePath);
+    } catch (error) {
+      if (error.code === 'ENOENT') {
+        return null;
+      }
+      throw error;
+    }
+  }
+
+  /**
+   * 获取任务列表
+   * @param {number} limit - 限制数量
+   * @returns {Promise<Array>}
+   */
+  async getTasks(limit = 10) {
+    const files = await listJsonFiles(this.tasksDir);
+    const tasks = [];
+    
+    for (const file of files.slice(0, limit)) {
+      try {
+        const task = await fs.readJson(path.join(this.tasksDir, file));
+        tasks.push(task);
+      } catch (error) {
+        await logger.error(`Failed to read task ${file}`, error);
+      }
+    }
+    
+    return tasks;
+  }
+
+  /**
+   * 获取运行中的任务
+   * @returns {Promise<Array>}
+   */
+  async getRunningTasks() {
+    const tasks = await this.getTasks(100);
+    return tasks.filter(t => t.status === TaskStatus.RUNNING);
+  }
+
+  /**
+   * 获取最近的任务
+   * @returns {Promise<Object|null>}
+   */
+  async getLatestTask() {
+    const tasks = await this.getTasks(1);
+    return tasks[0] || null;
+  }
+}
+
+/**
+ * 创建任务管理器实例
+ * @param {string} chatId
+ * @returns {TaskManager}
+ */
+export function createTaskManager(chatId) {
+  return new TaskManager(chatId);
+}

package/src/core/userState.js

@@ -0,0 +1,114 @@
+/**
+ * 用户状态管理
+ * 管理用户初始化状态和版本信息
+ */
+
+import fs from 'fs-extra';
+import path from 'path';
+import { getUserDir, ensureDir } from '../utils/fileUtils.js';
+import { createLogger } from './logger.js';
+
+const logger = createLogger('UserState');
+
+const CURRENT_VERSION = '1.0.4';
+
+/**
+ * 用户状态类
+ */
+export class UserState {
+  constructor(chatId) {
+    this.chatId = chatId;
+    this.userDir = getUserDir(chatId);
+    this.initializedFile = path.join(this.userDir, '.initialized');
+    this.versionFile = path.join(this.userDir, '.version');
+  }
+
+  /**
+   * 检查是否首次使用
+   * @returns {Promise<boolean>}
+   */
+  async isFirstTime() {
+    try {
+      await fs.access(this.initializedFile);
+      return false;
+    } catch {
+      return true;
+    }
+  }
+
+  /**
+   * 标记用户已初始化
+   */
+  async markInitialized() {
+    await ensureDir(this.userDir);
+    await fs.writeFile(this.initializedFile, '');
+    await fs.writeFile(this.versionFile, CURRENT_VERSION);
+    await logger.info(`User ${this.chatId} initialized`);
+  }
+
+  /**
+   * 检查版本状态
+   * @returns {Promise<'first_time'|'updated'|'normal'>}
+   */
+  async checkVersion() {
+    // 首次使用
+    if (await this.isFirstTime()) {
+      return 'first_time';
+    }
+
+    // 检查版本
+    try {
+      const savedVersion = await fs.readFile(this.versionFile, 'utf-8');
+      if (savedVersion.trim() !== CURRENT_VERSION) {
+        // 版本更新
+        await fs.writeFile(this.versionFile, CURRENT_VERSION);
+        return 'updated';
+      }
+    } catch (error) {
+      await logger.error('Failed to read version file', error);
+    }
+
+    return 'normal';
+  }
+
+  /**
+   * 获取用户数据目录
+   * @returns {string}
+   */
+  getUserDir() {
+    return this.userDir;
+  }
+
+  /**
+   * 获取任务目录
+   * @returns {string}
+   */
+  getTasksDir() {
+    return path.join(this.userDir, 'tasks');
+  }
+
+  /**
+   * 获取监控目录
+   * @returns {string}
+   */
+  getMonitorsDir() {
+    return path.join(this.userDir, 'monitors');
+  }
+
+  /**
+   * 获取通知目录
+   * @returns {string}
+   */
+  getNotificationsDir() {
+    return path.join(this.userDir, 'notifications');
+  }
+}
+
+/**
+ * 创建用户状态实例
+ * @param {string} chatId
+ * @returns {UserState}
+ */
+export function createUserState(chatId) {
+  return new UserState(chatId);
+}

package/src/cron/monitor-daemon.js

@@ -0,0 +1,279 @@
+/**
+ * 监控守护进程
+ * 优先复用 OpenClaw Cron（Gateway 模式），降级使用内部调度
+ */
+
+import cron from 'node-cron';
+import { createLogger } from '../core/logger.js';
+import { createMonitorManager } from '../core/monitorManager.js';
+import { sendMonitorTriggerNotification } from '../notifier/index.js';
+import { evaluateSmartTrigger } from '../utils/smartTrigger.js';
+import { isOpenClawGateway, registerCronTask } from '../utils/openclawUtils.js';
+import { execSync } from 'child_process';
+
+const logger = createLogger('MonitorDaemon');
+
+/**
+ * 检查单个监控项
+ * @param {Object} monitor - 监控项
+ * @param {string} chatId - 聊天 ID
+ */
+async function checkMonitor(monitor, chatId) {
+  try {
+    await logger.info(`Checking monitor: ${monitor.monitor_id}`);
+    
+    // 获取触发条件
+    const trigger = monitor.semantic_trigger || monitor.trigger;
+    if (!trigger) {
+      await logger.warn(`Monitor ${monitor.monitor_id} has no trigger condition`);
+      return;
+    }
+    
+    // 执行搜索检查（使用 Tavily 或 QVeris）
+    const searchResult = await searchForTrigger(trigger, monitor);
+    
+    // 使用智能触发评估
+    const evaluation = await evaluateSmartTrigger(
+      trigger,
+      searchResult.content || JSON.stringify(searchResult),
+      { useLLM: true, threshold: 0.6 }
+    );
+    
+    if (evaluation.shouldTrigger) {
+      await logger.info(`Monitor triggered: ${monitor.monitor_id} (confidence: ${evaluation.confidence})`);
+      
+      // 发送通知
+      await sendMonitorTriggerNotification({
+        chatId,
+        monitorId: monitor.monitor_id,
+        monitorTitle: monitor.title,
+        message: `${evaluation.reason}\n\n相关内容：${searchResult.content?.slice(0, 200) || '详见报告'}...`,
+        category: monitor.category || 'Data'
+      });
+      
+      // 更新监控触发记录
+      const monitorManager = createMonitorManager(chatId);
+      await monitorManager.updateMonitor(monitor.monitor_id, {
+        last_triggered_at: new Date().toISOString(),
+        trigger_count: (monitor.trigger_count || 0) + 1
+      });
+    }
+  } catch (error) {
+    await logger.error(`Failed to check monitor ${monitor.monitor_id}`, error);
+  }
+}
+
+/**
+ * 搜索触发相关内容
+ * @param {string} trigger - 触发条件描述
+ * @param {Object} monitor - 监控项
+ * @returns {Promise<Object>}
+ */
+async function searchForTrigger(trigger, monitor) {
+  try {
+    let searchResult;
+    
+    // 方法1: 使用 Tavily 搜索
+    if (process.env.TAVILY_API_KEY) {
+      searchResult = await searchWithTavily(trigger);
+    }
+    // 方法2: 使用 QVeris
+    else if (process.env.QVERIS_API_KEY) {
+      searchResult = await searchWithQVeris(trigger);
+    }
+    // 方法3: 降级到空结果
+    else {
+      return { content: '', results: [] };
+    }
+    
+    // 合并搜索结果为文本
+    const content = searchResult.results
+      ?.map(r => `${r.title} ${r.content}`)
+      .join(' ') || '';
+    
+    return {
+      content,
+      results: searchResult.results || []
+    };
+  } catch (error) {
+    await logger.error('Trigger search failed', error);
+    return { content: '', results: [] };
+  }
+}
+
+/**
+ * 使用 Tavily 搜索
+ * @param {string} query - 查询
+ * @returns {Promise<Object>}
+ */
+async function searchWithTavily(query) {
+  const response = await fetch('https://api.tavily.com/search', {
+    method: 'POST',
+    headers: {
+      'Content-Type': 'application/json',
+      'Authorization': `Bearer ${process.env.TAVILY_API_KEY}`
+    },
+    body: JSON.stringify({
+      query,
+      search_depth: 'basic',
+      max_results: 5
+    })
+  });
+  
+  return await response.json();
+}
+
+/**
+ * 使用 QVeris 搜索
+ * @param {string} query - 查询
+ * @returns {Promise<Object>}
+ */
+async function searchWithQVeris(query) {
+  const response = await fetch('https://api.qveris.ai/v1/search', {
+    method: 'POST',
+    headers: {
+      'Content-Type': 'application/json',
+      'Authorization': `Bearer ${process.env.QVERIS_API_KEY}`
+    },
+    body: JSON.stringify({
+      query,
+      max_results: 5
+    })
+  });
+  
+  return await response.json();
+}
+
+/**
+ * 分析搜索结果
+ * @param {Object} result - 搜索结果
+ * @param {string} trigger - 触发条件
+ * @returns {boolean}
+ */
+function analyzeSearchResult(result, trigger) {
+  // 简化实现：检查结果中是否包含关键词
+  const results = result.results || [];
+  const triggerKeywords = trigger.toLowerCase().split(/\s+/);
+  
+  for (const item of results) {
+    const content = (item.content || item.title || '').toLowerCase();
+    const matchCount = triggerKeywords.filter(kw => content.includes(kw)).length;
+    
+    // 如果匹配超过一半关键词，认为触发
+    if (matchCount >= triggerKeywords.length / 2) {
+      return true;
+    }
+  }
+  
+  return false;
+}
+
+/**
+ * 运行监控检查（单次）
+ * @param {string} chatId - 聊天 ID
+ */
+export async function runMonitorCheck(chatId) {
+  await logger.info(`Running monitor check for ${chatId}`);
+  
+  const monitorManager = createMonitorManager(chatId);
+  const monitors = await monitorManager.getActiveMonitors();
+  
+  if (monitors.length === 0) {
+    await logger.info('No active monitors found');
+    return;
+  }
+  
+  await logger.info(`Found ${monitors.length} active monitors`);
+  
+  for (const monitor of monitors) {
+    await checkMonitor(monitor, chatId);
+  }
+  
+  await logger.info('Monitor check completed');
+}
+
+/**
+ * 启动监控守护进程（使用 node-cron）
+ * @param {string} chatId - 聊天 ID
+ * @returns {Object} cron job
+ */
+export async function startMonitorDaemon(chatId) {
+  await logger.info(`Starting monitor daemon for ${chatId}`);
+  
+  // 优先尝试 OpenClaw Gateway 模式
+  if (isOpenClawGateway()) {
+    await logger.info('OpenClaw Gateway detected, registering cron task...');
+    const registered = await registerCronTask({
+      name: `cue-monitor-${chatId}`,
+      message: `cue-monitor-check ${chatId}`,
+      cron: '*/30 * * * *',
+      chatId
+    });
+    
+    if (registered) {
+      await logger.info(`OpenClaw cron registered successfully for ${chatId}`);
+      return { mode: 'openclaw', chatId };
+    }
+  }
+  
+  // 降级：使用内部 node-cron
+  await logger.info('Using internal node-cron scheduler');
+  const job = cron.schedule('*/30 * * * *', async () => {
+    await runMonitorCheck(chatId);
+  });
+  
+  return { mode: 'internal', job, chatId };
+}
+
+/**
+ * 使用 OpenClaw 外部 cron（备用方案）
+ * @param {string} chatId - 聊天 ID
+ */
+
+/**
+ * 使用浏览器获取动态网页数据
+ * @param {string} url - 网页 URL
+ * @returns {Promise<string>}
+ */
+async function fetchWithBrowser(url) {
+  try {
+    const { execSync } = await import('child_process');
+    const cmd = `openclaw browser snapshot --url "${url}" --format text`;
+    const result = execSync(cmd, { encoding: 'utf-8', timeout: 30000 });
+    return result || '';
+  } catch (error) {
+    logger.error('Browser fetch failed:', error.message);
+    return null;
+  }
+}
+
+/**
+ * 智能数据获取
+ * 1. 搜索 → 2. 浏览器获取
+ * @param {string} trigger - 触发条件
+ * @param {Object} monitor - 监控项
+ * @returns {Promise<Object>}
+ */
+async function smartFetchData(trigger, monitor) {
+  // 第一步：搜索
+  const searchResult = await searchForTrigger(trigger, monitor);
+  
+  // 检查搜索结果是否足够
+  const hasContent = searchResult.content && searchResult.content.length > 100;
+  
+  if (hasContent) {
+    return { source: 'search', data: searchResult };
+  }
+  
+  // 第二步：需要浏览器获取
+  if (monitor.target_url) {
+    logger.info('Search insufficient, trying browser fetch...');
+    const browserContent = await fetchWithBrowser(monitor.target_url);
+    
+    if (browserContent) {
+      return { source: 'browser', data: { content: browserContent } };
+    }
+  }
+  
+  return { source: 'none', data: searchResult };
+}

package/src/cron/research-worker.js

@@ -0,0 +1,97 @@
+#!/usr/bin/env node
+/**
+ * 研究工作进程
+ * 在后台执行实际的研究任务（使用流式 API）
+ */
+
+import { startResearch } from '../api/cuecueClient.js';
+import { createTaskManager } from '../core/taskManager.js';
+import { createLogger } from '../core/logger.js';
+
+const logger = createLogger('ResearchWorker');
+
+async function main() {
+  const [,, taskId, topic, mode, chatId] = process.argv;
+  const apiKey = process.env.CUECUE_API_KEY;
+  
+  if (!taskId || !topic || !apiKey) {
+    console.error('Usage: research-worker.js <taskId> <topic> <mode> <chatId>');
+    console.error('Requires CUECUE_API_KEY environment variable');
+    process.exit(1);
+  }
+  
+  try {
+    await logger.info(`Research worker started: ${taskId}`);
+    
+    const taskManager = createTaskManager(chatId);
+    
+    // 更新进度：初始化
+    await taskManager.updateTaskProgress(taskId, '正在连接 CueCue 服务...', 5);
+    
+    // 启动研究（使用流式 API）
+    const result = await startResearch({
+      topic,
+      mode: mode || 'default',
+      userProfile,
+      chatId,
+      apiKey,
+      onProgress: async (progress) => {
+        // 根据进度阶段更新任务状态
+        const progressMap = {
+          'start': { message: '正在启动研究...', percent: 10 },
+          'coordinator': { message: '正在分配研究任务...', percent: 15 },
+          'task': { message: progress.message, percent: 30 },
+          'report': { message: '正在生成报告...', percent: 70 },
+          'complete': { message: '报告生成完成', percent: 95 },
+          'final': { message: '研究完成', percent: 100 }
+        };
+        
+        const p = progressMap[progress.stage] || { message: progress.message, percent: 50 };
+        await taskManager.updateTaskProgress(taskId, p.message, p.percent);
+        
+        logger.info(`Progress: ${progress.stage} - ${progress.message}`);
+      }
+    });
+    
+    // 更新任务：已启动
+    await taskManager.updateTask(taskId, {
+      conversation_id: result.conversationId,
+      report_url: result.reportUrl,
+      progress: '研究进行中...',
+      percent: 50
+    });
+    
+    await logger.info(`Research started on CueCue: ${result.conversationId}`);
+    
+    // 注意：流式 API 会一直等待直到研究完成
+    // result 中已包含报告内容（如果流式已完成）
+    if (result.report) {
+      await taskManager.completeTask(taskId, {
+        conversation_id: result.conversationId,
+        report_url: result.reportUrl,
+        report: result.report,
+        tasks: result.tasks
+      });
+      logger.info(`Research completed with report: ${taskId}`);
+    } else {
+      // 如果没有报告内容，标记为完成但需要后续获取
+      await taskManager.completeTask(taskId, {
+        conversation_id: result.conversationId,
+        report_url: result.reportUrl,
+        tasks: result.tasks
+      });
+      logger.info(`Research stream completed, report pending: ${taskId}`);
+    }
+    
+    process.exit(0);
+  } catch (error) {
+    await logger.error(`Research worker failed: ${taskId}`, error);
+    
+    const taskManager = createTaskManager(chatId);
+    await taskManager.failTask(taskId, error.message);
+    
+    process.exit(1);
+  }
+}
+
+main();