@becrafter/prompt-manager 0.1.21 → 0.1.31

package/packages/server/mcp/sequential-thinking.handler.js

@@ -1,318 +0,0 @@
-/**
- * Sequential Thinking 工具处理器
- * 
- * 参考: https://github.com/spences10/mcp-sequentialthinking-tools
- * 
- * 功能：
- * - 通过顺序思维实现动态和反思性的问题解决
- * - 支持思维过程的分支和修订
- * - 帮助将复杂问题分解为可管理的步骤
- */
-
-import { logger } from '../utils/logger.js';
-
-/**
- * 思考状态管理
- */
-class ThinkingState {
-  constructor() {
-    this.thoughts = [];
-    this.currentThoughtNumber = 0;
-    this.branches = new Map();
-    this.revisions = [];
-  }
-
-  addThought(thought, metadata = {}) {
-    const thoughtObj = {
-      number: this.currentThoughtNumber + 1,
-      content: thought,
-      timestamp: new Date().toISOString(),
-      ...metadata
-    };
-    
-    this.thoughts.push(thoughtObj);
-    this.currentThoughtNumber = thoughtObj.number;
-    
-    return thoughtObj;
-  }
-
-  reviseThought(thoughtNumber, newThought) {
-    const originalThought = this.thoughts.find(t => t.number === thoughtNumber);
-    if (!originalThought) {
-      throw new Error(`思考 ${thoughtNumber} 不存在`);
-    }
-
-    const revision = {
-      originalNumber: thoughtNumber,
-      newContent: newThought,
-      timestamp: new Date().toISOString()
-    };
-    
-    this.revisions.push(revision);
-    originalThought.revised = true;
-    originalThought.revision = revision;
-    
-    return revision;
-  }
-
-  createBranch(fromThoughtNumber, branchId, branchThought) {
-    const branch = {
-      fromThought: fromThoughtNumber,
-      branchId: branchId,
-      thoughts: [branchThought],
-      timestamp: new Date().toISOString()
-    };
-    
-    this.branches.set(branchId, branch);
-    return branch;
-  }
-
-  getThoughts() {
-    return this.thoughts;
-  }
-
-  getBranches() {
-    return Array.from(this.branches.values());
-  }
-
-  getRevisions() {
-    return this.revisions;
-  }
-
-  getSummary() {
-    return {
-      totalThoughts: this.thoughts.length,
-      totalBranches: this.branches.size,
-      totalRevisions: this.revisions.length,
-      currentThought: this.currentThoughtNumber
-    };
-  }
-
-  reset() {
-    this.thoughts = [];
-    this.currentThoughtNumber = 0;
-    this.branches.clear();
-    this.revisions = [];
-  }
-}
-
-// 全局思考状态（可以根据需要改为按会话管理）
-const thinkingState = new ThinkingState();
-
-/**
- * 处理 sequential thinking 工具调用
- * @param {object} args - 参数对象
- * @returns {object} MCP 格式的返回结果
- */
-export async function handleSequentialThinking(args) {
-  const {
-    thought,
-    nextThoughtNeeded = true,
-    thoughtNumber,
-    totalThoughts = 10,
-    isRevision = false,
-    revisesThought,
-    branchFromThought,
-    branchId,
-    needsMoreThoughts = false
-  } = args;
-
-  try {
-    if (!thought) {
-      throw new Error('缺少必需参数: thought');
-    }
-
-    // 处理思考记录
-    let thoughtRecord;
-    
-    if (isRevision && revisesThought) {
-      // 修订现有思考
-      thinkingState.reviseThought(revisesThought, thought);
-      thoughtRecord = {
-        number: revisesThought,
-        type: 'revision',
-        revisesThought: revisesThought,
-        content: thought
-      };
-    } else if (branchFromThought && branchId) {
-      // 创建分支
-      const branch = thinkingState.createBranch(branchFromThought, branchId, thought);
-      thoughtRecord = {
-        number: branchFromThought,
-        type: 'branch',
-        branchFromThought: branchFromThought,
-        branchId: branchId,
-        content: thought
-      };
-    } else {
-      // 添加新思考
-      const addedThought = thinkingState.addThought(thought, {
-        thoughtNumber: thoughtNumber,
-        totalThoughts: totalThoughts,
-        nextThoughtNeeded: nextThoughtNeeded,
-        needsMoreThoughts: needsMoreThoughts
-      });
-      thoughtRecord = {
-        number: addedThought.number,
-        type: 'regular',
-        content: thought
-      };
-    }
-
-    // 获取当前状态摘要
-    const summary = thinkingState.getSummary();
-    const allThoughts = thinkingState.getThoughts();
-    const branches = thinkingState.getBranches();
-    const revisions = thinkingState.getRevisions();
-
-    // 构建响应
-    const response = {
-      success: true,
-      thought: thoughtRecord,
-      summary: summary,
-      progress: {
-        current: thoughtNumber || summary.currentThought,
-        total: totalThoughts,
-        percentage: Math.round(((thoughtNumber || summary.currentThought) / totalThoughts) * 100)
-      },
-      nextThoughtNeeded: nextThoughtNeeded || needsMoreThoughts,
-      thoughts: allThoughts.map(t => ({
-        number: t.number,
-        content: t.content,
-        revised: t.revised || false
-      })),
-      ...(branches.length > 0 && { branches: branches }),
-      ...(revisions.length > 0 && { revisions: revisions })
-    };
-
-    // 如果不需要更多思考，可以生成最终总结
-    if (!nextThoughtNeeded && !needsMoreThoughts) {
-      response.finalSummary = generateFinalSummary(allThoughts, branches, revisions);
-    }
-
-    logger.debug('Sequential thinking result:', response);
-
-    return {
-      content: [
-        {
-          type: "text",
-          text: formatThinkingOutput(response)
-        }
-      ]
-    };
-
-  } catch (error) {
-    logger.error('Sequential thinking error:', error);
-    throw error;
-  }
-}
-
-/**
- * 生成最终总结
- */
-function generateFinalSummary(thoughts, branches, revisions) {
-  const summary = {
-    totalSteps: thoughts.length,
-    keyInsights: [],
-    conclusions: [],
-    recommendations: []
-  };
-
-  // 提取关键洞察（可以根据需要改进逻辑）
-  thoughts.forEach(thought => {
-    if (thought.content.includes('关键') || thought.content.includes('重要') || thought.content.includes('结论')) {
-      summary.keyInsights.push({
-        step: thought.number,
-        content: thought.content
-      });
-    }
-  });
-
-  // 提取结论
-  const lastThoughts = thoughts.slice(-3);
-  summary.conclusions = lastThoughts.map(t => ({
-    step: t.number,
-    content: t.content
-  }));
-
-  return summary;
-}
-
-/**
- * 格式化思考输出
- */
-function formatThinkingOutput(response) {
-  let output = '';
-  
-  output += '━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\n';
-  output += '🧠 **顺序思考工具**\n';
-  output += '━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\n\n';
-
-  // 当前思考
-  output += `**思考 ${response.thought.number || response.summary.currentThought}**\n`;
-  output += `${response.thought.content}\n\n`;
-
-  // 进度信息
-  output += `**进度**: ${response.progress.current}/${response.progress.total} (${response.progress.percentage}%)\n\n`;
-
-  // 思考历史
-  if (response.thoughts && response.thoughts.length > 0) {
-    output += '**思考历史**:\n';
-    response.thoughts.forEach(t => {
-      const marker = t.revised ? '↩️' : '•';
-      output += `${marker} [${t.number}] ${t.content.substring(0, 100)}${t.content.length > 100 ? '...' : ''}\n`;
-    });
-    output += '\n';
-  }
-
-  // 分支信息
-  if (response.branches && response.branches.length > 0) {
-    output += '**分支**:\n';
-    response.branches.forEach(branch => {
-      output += `  └─ 分支 ${branch.branchId} (来自思考 ${branch.fromThought})\n`;
-    });
-    output += '\n';
-  }
-
-  // 修订信息
-  if (response.revisions && response.revisions.length > 0) {
-    output += '**修订**:\n';
-    response.revisions.forEach(rev => {
-      output += `  ↻ 思考 ${rev.originalNumber} 已修订\n`;
-    });
-    output += '\n';
-  }
-
-  // 下一步
-  if (response.nextThoughtNeeded) {
-    output += '**下一步**: 继续思考...\n';
-  } else {
-    output += '**状态**: 思考完成\n';
-    if (response.finalSummary) {
-      output += '\n**最终总结**:\n';
-      output += `- 总步骤数: ${response.finalSummary.totalSteps}\n`;
-      if (response.finalSummary.keyInsights.length > 0) {
-        output += '- 关键洞察:\n';
-        response.finalSummary.keyInsights.forEach(insight => {
-          output += `  • [步骤 ${insight.step}] ${insight.content}\n`;
-        });
-      }
-    }
-  }
-
-  output += '\n━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\n';
-
-  return output;
-}
-
-/**
- * 重置思考状态（可选功能）
- */
-export function resetThinkingState() {
-  thinkingState.reset();
-  return {
-    success: true,
-    message: '思考状态已重置'
-  };
-}
-

package/packages/server/mcp/think-plan.handler.js

@@ -1,274 +0,0 @@
-/**
- * Think Plan 工具处理器
- * 
- * 功能：
- * - 系统化思考与规划工具
- * - 支持分阶段梳理思考、规划和行动步骤
- * - 强调思考（thought）、计划（plan）与实际行动（action）的结合
- * - 通过编号（thoughtNumber）追踪过程
- * - 不会获取新信息或更改数据库，只会将想法附加到记忆中
- */
-
-import { logger } from '../utils/logger.js';
-
-/**
- * 思考和规划条目
- */
-class ThinkPlanEntry {
-  constructor(thoughtNumber, thought, plan, action) {
-    this.thoughtNumber = thoughtNumber;
-    this.thought = thought;
-    this.plan = plan;
-    this.action = action;
-    this.timestamp = new Date();
-  }
-
-  toJSON() {
-    return {
-      thoughtNumber: this.thoughtNumber,
-      thought: this.thought,
-      plan: this.plan,
-      action: this.action,
-      timestamp: this.timestamp.toISOString()
-    };
-  }
-}
-
-/**
- * 思考和规划内存管理
- */
-class ThinkPlanMemory {
-  constructor() {
-    this.entries = [];
-    this.mutex = new Map(); // 用于会话级别的并发控制
-  }
-
-  /**
-   * 添加新的思考和规划条目
-   */
-  addEntry(thoughtNumber, thought, plan, action, sessionId = 'default') {
-    const entry = new ThinkPlanEntry(thoughtNumber, thought, plan, action);
-    
-    if (!this.mutex.has(sessionId)) {
-      this.mutex.set(sessionId, []);
-    }
-    
-    this.mutex.get(sessionId).push(entry);
-    this.entries.push(entry);
-    
-    logger.debug(`ThinkPlan Entry [${thoughtNumber}] added:`, {
-      thought: thought.substring(0, 50) + '...',
-      plan: plan.substring(0, 50) + '...',
-      action: action.substring(0, 50) + '...'
-    });
-    
-    return entry;
-  }
-
-  /**
-   * 获取所有记录
-   */
-  getAllEntries(sessionId = 'default') {
-    if (sessionId === 'default') {
-      return [...this.entries];
-    }
-    return [...(this.mutex.get(sessionId) || [])];
-  }
-
-  /**
-   * 根据编号获取特定记录
-   */
-  getEntryByNumber(thoughtNumber, sessionId = 'default') {
-    const entries = sessionId === 'default' ? this.entries : (this.mutex.get(sessionId) || []);
-    return entries.find(entry => entry.thoughtNumber === thoughtNumber) || null;
-  }
-
-  /**
-   * 以 JSON 格式获取所有记录
-   */
-  getEntriesAsJSON(sessionId = 'default') {
-    const entries = this.getAllEntries(sessionId);
-    return JSON.stringify(entries.map(e => e.toJSON()), null, 2);
-  }
-
-  /**
-   * 清空所有记录
-   */
-  clearEntries(sessionId = 'default') {
-    if (sessionId === 'default') {
-      this.entries = [];
-      this.mutex.clear();
-    } else {
-      this.mutex.delete(sessionId);
-      // 从全局 entries 中移除该会话的记录
-      this.entries = this.entries.filter(e => {
-        // 这里简化处理，实际可能需要更复杂的会话追踪
-        return true; // 保留所有记录，只清除会话特定记录
-      });
-    }
-    logger.info(`ThinkPlan memory cleared for session: ${sessionId}`);
-  }
-
-  /**
-   * 获取思考和规划过程的摘要
-   */
-  getSummary(sessionId = 'default') {
-    const entries = this.getAllEntries(sessionId);
-    
-    if (entries.length === 0) {
-      return '暂无思考和规划记录';
-    }
-
-    let summary = `思考和规划过程摘要 (共 ${entries.length} 个步骤):\n\n`;
-    
-    entries.forEach((entry, index) => {
-      summary += `${index + 1}. [${entry.thoughtNumber}] ${entry.thought}\n`;
-      if (index < entries.length - 1) {
-        summary += '\n';
-      }
-    });
-
-    return summary;
-  }
-
-  /**
-   * 获取当前记录数量
-   */
-  getCount(sessionId = 'default') {
-    const entries = this.getAllEntries(sessionId);
-    return entries.length;
-  }
-}
-
-// 全局内存实例
-const thinkPlanMemory = new ThinkPlanMemory();
-
-/**
- * 处理 think_and_plan 工具调用
- * @param {object} args - 参数对象
- * @returns {object} MCP 格式的返回结果
- */
-export async function handleThinkPlan(args) {
-  const {
-    thought,
-    plan,
-    action,
-    thoughtNumber,
-    sessionId = 'default'
-  } = args;
-
-  try {
-    // 验证必需参数
-    if (!thought || thought.trim().length === 0) {
-      throw new Error('缺少必需参数: thought');
-    }
-    if (!plan || plan.trim().length === 0) {
-      throw new Error('缺少必需参数: plan');
-    }
-    if (!action || action.trim().length === 0) {
-      throw new Error('缺少必需参数: action');
-    }
-    if (!thoughtNumber || thoughtNumber.trim().length === 0) {
-      throw new Error('缺少必需参数: thoughtNumber');
-    }
-
-    // 添加新条目
-    const entry = thinkPlanMemory.addEntry(thoughtNumber, thought, plan, action, sessionId);
-    const currentCount = thinkPlanMemory.getCount(sessionId);
-
-    // 构建响应内容
-    const response = formatThinkPlanOutput(entry, currentCount);
-
-    logger.info(`ThinkPlan Entry [${thoughtNumber}] recorded`);
-
-    return {
-      content: [
-        {
-          type: "text",
-          text: response
-        }
-      ]
-    };
-
-  } catch (error) {
-    logger.error('ThinkPlan error:', error);
-    throw error;
-  }
-}
-
-/**
- * 格式化思考和规划输出
- */
-function formatThinkPlanOutput(entry, currentCount) {
-  const timestamp = entry.timestamp.toLocaleString('zh-CN', {
-    year: 'numeric',
-    month: '2-digit',
-    day: '2-digit',
-    hour: '2-digit',
-    minute: '2-digit',
-    second: '2-digit'
-  });
-
-  let output = '';
-  output += '━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\n';
-  output += '🧠 **思考和规划记录**\n';
-  output += '━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\n\n';
-  
-  output += `**思考编号**: [${entry.thoughtNumber}]\n\n`;
-  
-  output += '🤔 **思考内容**:\n';
-  output += `${entry.thought}\n\n`;
-  
-  output += '📋 **规划方案**:\n';
-  output += `${entry.plan}\n\n`;
-  
-  output += '🎯 **下一步行动**:\n';
-  output += `${entry.action}\n\n`;
-  
-  output += `⏰ **记录时间**: ${timestamp}\n\n`;
-  output += `📊 **当前已记录**: ${currentCount} 个思考步骤\n`;
-  
-  output += '\n━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\n';
-
-  return output;
-}
-
-/**
- * 获取所有思考和规划记录
- */
-export function getThinkPlanMemory(sessionId = 'default') {
-  return thinkPlanMemory.getAllEntries(sessionId);
-}
-
-/**
- * 根据编号获取特定的思考和规划记录
- */
-export function getThinkPlanMemoryByNumber(thoughtNumber, sessionId = 'default') {
-  return thinkPlanMemory.getEntryByNumber(thoughtNumber, sessionId);
-}
-
-/**
- * 以 JSON 格式获取所有记录
- */
-export function getThinkPlanMemoryAsJSON(sessionId = 'default') {
-  return thinkPlanMemory.getEntriesAsJSON(sessionId);
-}
-
-/**
- * 清空所有记录
- */
-export function clearThinkPlanMemory(sessionId = 'default') {
-  thinkPlanMemory.clearEntries(sessionId);
-  return {
-    success: true,
-    message: `思考和规划记录已清空 (会话: ${sessionId})`
-  };
-}
-
-/**
- * 获取思考和规划过程的摘要
- */
-export function getThinkPlanSummary(sessionId = 'default') {
-  return thinkPlanMemory.getSummary(sessionId);
-}
-