@becrafter/prompt-manager 0.0.8

package/packages/server/manager.js

@@ -0,0 +1,473 @@
+import fs from 'fs-extra';
+import path from 'path';
+import YAML from 'yaml';
+import { z } from 'zod';
+import crypto from 'crypto';
+import { logger } from './logger.js';
+import { config } from './config.js';
+
+/**
+ * Prompt数据结构验证schema
+ */
+const PromptSchema = z.object({
+  name: z.string().min(1, 'Prompt名称不能为空'),
+  description: z.string().optional(),
+  messages: z.array(z.object({
+    role: z.enum(['user', 'assistant', 'system']),
+    content: z.object({
+      text: z.string()
+    })
+  })).optional(),
+  arguments: z.array(z.object({
+    name: z.string().min(1, '参数名不能为空'),
+    description: z.string().optional(),
+    type: z.enum(['string', 'number', 'boolean']).optional().default('string'),
+    required: z.boolean().optional().default(true)
+  })).optional().default([]),
+  // 元数据字段（可选，用于远程服务）
+  uniqueId: z.string().optional(),
+  filePath: z.string().optional(),
+  fileName: z.string().optional(),
+  relativePath: z.string().optional()
+});
+
+/**
+ * Prompt管理器类
+ */
+export class PromptManager {
+  constructor(promptsDir) {
+    this.promptsDir = promptsDir;
+    this.loadedPrompts = new Map();
+    this.loadErrors = new Map();
+    this.idToPathMap = new Map(); // ID到文件路径的映射
+  }
+
+  /**
+   * 基于文件路径生成固定长度的唯一ID
+   * @param {string} relativePath - 相对于prompts目录的路径
+   * @returns {string} 固定长度的唯一ID字符串（8位）
+   */
+  generateUniqueId(relativePath) {
+    // 使用SHA-256哈希算法生成固定长度的ID
+    const hash = crypto.createHash('sha256');
+    hash.update(relativePath);
+    const hashHex = hash.digest('hex');
+    
+    // 取前8位作为ID，保证长度一致
+    // 8位十六进制可以表示 16^8 = 4,294,967,296 种不同的值，足够保证唯一性
+    const shortId = hashHex.substring(0, 8);
+    
+    return shortId;
+  }
+
+  /**
+   * 基于文件路径生成固定长度的唯一ID（可配置长度版本）
+   * @param {string} relativePath - 相对于prompts目录的路径
+   * @param {number} length - ID长度，默认为8
+   * @returns {string} 固定长度的唯一ID字符串
+   */
+  generateUniqueIdWithLength(relativePath, length = 8) {
+    const hash = crypto.createHash('sha256');
+    hash.update(relativePath);
+    const hashHex = hash.digest('hex');
+    
+    // 取指定长度的字符作为ID
+    const shortId = hashHex.substring(0, length);
+    
+    return shortId;
+  }
+
+  /**
+   * 基于ID反解文件路径
+   * @param {string} id - 唯一ID
+   * @returns {string|null} 文件路径，如果找不到则返回null
+   */
+  getIdToPath(id) {
+    return this.idToPathMap.get(id) || null;
+  }
+
+  /**
+   * 读取组元数据的函数 
+   * @param {string} dir - 目录路径
+   * @returns {Object} 组元数据
+   */
+  readGroupMeta(dir) {
+    const GROUP_META_FILENAME = '.groupmeta.json';
+    try {
+      const metaPath = path.join(dir, GROUP_META_FILENAME);
+      if (!fs.existsSync(metaPath)) {
+        return { enabled: true };
+      }
+      const raw = fs.readFileSync(metaPath, 'utf8');
+      const data = JSON.parse(raw);
+      return {
+        enabled: data.enabled !== false
+      };
+    } catch (error) {
+      console.warn('读取类目元数据失败:', error);
+      return { enabled: true };
+    }
+  }
+
+  /**
+   * 注册ID到路径的映射
+   * @param {string} id - 唯一ID
+   * @param {string} relativePath - 相对路径
+   */
+  registerIdPathMapping(id, relativePath) {
+    this.idToPathMap.set(id, relativePath);
+  }
+
+  /**
+   * 从远程服务器加载prompts
+   */
+  async loadRemotePrompts() {
+    try {
+      logger.info(`开始从远程服务器 ${config.remoteUrl} 加载prompts`);
+
+      const headers = {
+        'Content-Type': 'application/json',
+        ...(config.remoteHeaders || {})
+      };
+
+      const response = await fetch(config.remoteUrl, { headers });
+      
+      if (!response.ok) {
+        throw new Error(`远程服务器返回错误: ${response.status} ${response.statusText}`);
+      }
+
+      const data = await response.json();
+      
+      // 清空之前的加载结果
+      this.loadedPrompts.clear();
+      this.loadErrors.clear();
+
+      let successCount = 0;
+      let errorCount = 0;
+
+      // 处理远程数据
+      for (const promptData of data) {
+        try {
+          const validatedPrompt = PromptSchema.parse(promptData);
+          
+          // 检查远程服务是否提供了uniqueId
+          if (promptData.uniqueId) {
+            // 远程服务提供了uniqueId，直接使用
+            validatedPrompt.uniqueId = promptData.uniqueId;
+            
+            // 可选：如果提供了其他元数据字段就使用，没提供就设置默认值
+            validatedPrompt.filePath = promptData.filePath || `remote://${validatedPrompt.name}`;
+            validatedPrompt.fileName = promptData.fileName || `${validatedPrompt.name}.yaml`;
+            validatedPrompt.relativePath = promptData.relativePath || `${validatedPrompt.name}.yaml`;
+            
+            // 注册ID到路径的映射
+            this.registerIdPathMapping(promptData.uniqueId, validatedPrompt.relativePath);
+            
+            // 使用唯一ID作为存储键
+            this.loadedPrompts.set(promptData.uniqueId, validatedPrompt);
+            logger.debug(`使用远程服务提供的uniqueId: ${validatedPrompt.name} -> ID: ${promptData.uniqueId}`);
+          } else {
+            // 远程服务未提供uniqueId，使用兼容模式
+            const virtualPath = `${validatedPrompt.name}.yaml`;
+            const uniqueId = this.generateUniqueId(virtualPath);
+            validatedPrompt.uniqueId = uniqueId;
+            validatedPrompt.filePath = `remote://${validatedPrompt.name}`;
+            validatedPrompt.fileName = `${validatedPrompt.name}.yaml`;
+            validatedPrompt.relativePath = virtualPath;
+            
+            // 注册ID到路径的映射
+            this.registerIdPathMapping(uniqueId, virtualPath);
+            
+            // 使用唯一ID作为存储键
+            this.loadedPrompts.set(uniqueId, validatedPrompt);
+            logger.debug(`使用兼容模式加载远程prompt: ${validatedPrompt.name} -> ID: ${uniqueId}`);
+          }
+          
+          successCount++;
+        } catch (error) {
+          errorCount++;
+          this.loadErrors.set(promptData.name || 'unknown', error.message);
+          logger.error(`验证远程prompt失败:`, error.message);
+        }
+      }
+
+      logger.info(`远程Prompt加载完成: 成功 ${successCount} 个, 失败 ${errorCount} 个`);
+      
+      return {
+        success: successCount,
+        errorCount: errorCount,
+        prompts: Array.from(this.loadedPrompts.values()),
+        loadErrors: Object.fromEntries(this.loadErrors)
+      };
+    } catch (error) {
+      logger.error('加载远程prompts时发生错误:', error);
+      throw error;
+    }
+  }
+
+  /**
+   * 递归扫描目录，获取所有prompt文件
+   * 
+   * @param {string} currentPath  - 当前目录路径
+   * @param {string} relativePath - 相对于当前目录的路径
+   * @returns {Array} 所有prompt文件
+   */
+  async scanPromptFiles(currentPath, relativePath = '') {
+    const promptFiles = [];
+
+    if (relativePath) {
+      // console.log('读取组元数据:', "{relativePath:", relativePath, ", currentPath:", currentPath, "}");
+      const meta = this.readGroupMeta(path.join(currentPath, relativePath));
+      if (meta.enabled === false) {
+        return [];
+      }
+    }
+    
+    try {
+      const items = await fs.readdir(currentPath, { withFileTypes: true });
+      // console.log('扫描目录:', "{currentPath:", currentPath, ", items:", items, "}");
+      
+      for (const item of items) {
+        const itemPath = path.join(currentPath, item.name);                                     // 文件的绝对路径，相对于当前目录，如：/home/work/prompt-manager/prompts/xxx/xxx.yaml
+        const itemRelativePath = relativePath ? path.join(relativePath, item.name) : item.name; // 文件的相对路径，相对于当前目录，如：xxx/xxx.yaml
+
+        if (item.isDirectory()) {
+          // 递归扫描子目录
+          const subFiles = await this.scanPromptFiles(itemPath, itemRelativePath);
+          promptFiles.push(...subFiles);
+        } else if (item.isFile()) {
+          // 检查文件扩展名
+          const ext = path.extname(item.name).toLowerCase();
+          if (['.yaml', '.yml', '.json'].includes(ext)) {
+            promptFiles.push({
+              fileName: item.name,
+              filePath: itemPath,
+              relativePath: itemRelativePath
+            });
+          }
+        }
+      }
+    } catch (error) {
+      logger.warn(`扫描目录 ${currentPath} 时发生错误:`, error.message);
+    }
+    
+    return promptFiles;
+  }
+
+  /**
+   * 加载所有prompts
+   */
+  async loadPrompts() {
+    // 如果配置了远程URL，则从远程加载
+    if (config.remoteUrl) {
+      return await this.loadRemotePrompts();
+    }
+
+    try {
+      logger.info(`开始从 ${this.promptsDir} 加载prompts`);
+      
+      // 确保目录存在
+      await fs.ensureDir(this.promptsDir);
+      
+      // 根据配置决定是否递归扫描
+      let promptFiles;
+      if (config.recursiveScan) {
+        promptFiles = await this.scanPromptFiles(this.promptsDir);
+      } else {
+        // 只扫描根目录
+        const files = await fs.readdir(this.promptsDir);
+        promptFiles = files
+          .filter(file => {
+            const ext = path.extname(file).toLowerCase();
+            return ['.yaml', '.yml', '.json'].includes(ext);
+          })
+          .map(file => ({
+            fileName: file,
+            filePath: path.join(this.promptsDir, file),
+            relativePath: file
+          }));
+      }
+      
+      logger.debug(`找到 ${promptFiles.length} 个prompt文件`);
+
+      // 清空之前的加载结果
+      this.loadedPrompts.clear();
+      this.loadErrors.clear();
+
+      // 并行加载所有文件
+      const loadPromises = promptFiles.map(fileInfo => this.loadPromptFile(fileInfo));
+      const results = await Promise.allSettled(loadPromises);
+
+      // 统计加载结果
+      let successCount = 0;
+      let errorCount = 0;
+
+      let loadedCount   = 0;
+      let disabledCount = 0;
+
+      results.forEach((result, index) => {
+        if (result.status === 'fulfilled') {
+          successCount++;
+          if (result.value !== null) {
+            loadedCount++;
+          }else{
+            disabledCount++;
+          }
+        } else {
+          errorCount++;
+          const fileInfo = promptFiles[index];
+          const errorKey = fileInfo.relativePath || fileInfo.fileName;
+          this.loadErrors.set(errorKey, result.reason.message);
+          logger.error(`加载prompt文件 ${errorKey} 失败:`, result.reason.message);
+        }
+      });
+
+      logger.info(`本地Prompt加载完成: 启用 ${loadedCount} 个, 禁用 ${disabledCount} 个, 失败 ${errorCount} 个`);
+      
+      return {
+        success: loadedCount,
+        errorCount: errorCount,
+        prompts: Array.from(this.loadedPrompts.values()),
+        loadErrors: Object.fromEntries(this.loadErrors)
+      };
+    } catch (error) {
+      logger.error('加载prompts时发生错误:', error);
+      throw error;
+    }
+  }
+
+  /**
+   * 加载单个prompt文件
+   */
+  async loadPromptFile(fileInfo) {
+    // 支持旧的字符串参数格式（向后兼容）
+    const fileName = typeof fileInfo === 'string' ? fileInfo : fileInfo.fileName;
+    const filePath = typeof fileInfo === 'string' ? path.join(this.promptsDir, fileInfo) : fileInfo.filePath;
+    const relativePath = typeof fileInfo === 'string' ? fileInfo : fileInfo.relativePath;
+    
+    try {
+      const content = await fs.readFile(filePath, 'utf8');
+      const ext = path.extname(fileName).toLowerCase();
+      
+      let promptData;
+      if (ext === '.json') {
+        promptData = JSON.parse(content);
+      } else {
+        promptData = YAML.parse(content);
+      }
+
+      if (promptData.enabled !== true) {
+        logger.debug(`skipped loading prompt: ${promptData.name} -> disabled`);
+        return null;
+      }
+      logger.debug(`loaded prompt: ${promptData.name} -> ${filePath}`);
+
+      // 验证prompt数据结构
+      const validatedPrompt = PromptSchema.parse(promptData);
+      
+      // 添加文件路径信息
+      validatedPrompt.filePath = filePath;
+      validatedPrompt.fileName = fileName;
+      validatedPrompt.relativePath = relativePath;
+      
+      // 生成基于文件路径的唯一ID
+      const uniqueId = this.generateUniqueId(relativePath);
+      validatedPrompt.uniqueId = uniqueId;
+      
+      // 注册ID到路径的映射
+      this.registerIdPathMapping(uniqueId, relativePath);
+      
+      // 使用唯一ID作为存储键
+      this.loadedPrompts.set(uniqueId, validatedPrompt);
+      logger.debug(`成功加载prompt: ${validatedPrompt.name} -> ID: ${uniqueId} (${relativePath})`);
+      
+      return validatedPrompt;
+    } catch (error) {
+      if (error instanceof z.ZodError) {
+        const errorMessage = `数据验证失败: ${error.errors.map(e => e.message).join(', ')}`;
+        throw new Error(errorMessage);
+      }
+      throw error;
+    }
+  }
+
+  /**
+   * 获取所有已加载的prompts
+   */
+  getPrompts() {
+    return Array.from(this.loadedPrompts.values());
+  }
+
+  /**
+   * 根据ID获取prompt
+   * @param {string} id - 唯一ID或原始名称（向后兼容）
+   */
+  getPrompt(id) {
+    // 首先尝试直接匹配唯一ID
+    if (this.loadedPrompts.has(id)) {
+      return this.loadedPrompts.get(id);
+    }
+    
+    // 如果直接匹配失败，尝试匹配原始名称（向后兼容）
+    for (const [key, prompt] of this.loadedPrompts.entries()) {
+      if (prompt.name === id || prompt.relativePath === id) {
+        return prompt;
+      }
+    }
+    
+    return null;
+  }
+
+  /**
+   * 根据名称获取prompt（向后兼容方法）
+   * @deprecated 建议使用 getPrompt(id) 方法
+   */
+  getPromptByName(name) {
+    return this.getPrompt(name);
+  }
+
+  /**
+   * 获取prompt ID列表
+   */
+  getPromptNames() {
+    return Array.from(this.loadedPrompts.keys());
+  }
+
+  /**
+   * 验证prompt数据结构
+   * @param {Object} promptData - 要验证的prompt数据
+   * @returns {Object} 验证后的prompt数据
+   */
+  validatePromptData(promptData) {
+    return PromptSchema.parse(promptData);
+  }
+
+  /**
+   * 获取所有prompt的ID和路径映射
+   */
+  getIdPathMappings() {
+    return Object.fromEntries(this.idToPathMap);
+  }
+
+  /**
+   * 检查prompt是否存在
+   */
+  hasPrompt(name) {
+    return this.loadedPrompts.has(name);
+  }
+
+  /**
+   * 获取加载错误信息
+   */
+  getLoadErrors() {
+    return Object.fromEntries(this.loadErrors);
+  }
+
+  /**
+   * 重新加载prompts
+   */
+  async reloadPrompts() {
+    logger.info('重新加载prompts');
+    return await this.loadPrompts();
+  }
+}

package/packages/server/mcp.js

@@ -0,0 +1,234 @@
+// 导入自定义模块
+import { config } from './config.js';
+import { logger } from './logger.js';
+
+// 处理 get_prompt 工具调用
+export async function handleGetPrompt(args, promptManager) {
+  // 注意：这里为了兼容性，我们同时支持prompt_id和name参数
+  const promptId = args.prompt_id || args.name;
+  
+  if (!promptId) {
+    throw new Error("缺少必需参数: prompt_id 或 name");
+  }
+  
+  const prompt = promptManager.getPrompt(promptId);
+  if (!prompt) {
+    throw new Error(`未找到ID为 "${promptId}" 的prompt`);
+  }
+  
+  // 返回完整的prompt信息
+  const promptInfo = {
+    id: prompt.uniqueId,        // 使用基于文件路径的唯一ID
+    name: prompt.name,
+    description: prompt.description || `Prompt: ${prompt.name}`,
+    messages: prompt.messages || [],
+    arguments: prompt.arguments || [],
+    filePath: prompt.relativePath,  // 添加文件路径信息
+  };
+
+  if (config.getLogLevel() === 'debug') {
+    promptInfo.metadata = {
+      uniqueId: prompt.uniqueId,
+      fileName: prompt.fileName,
+      fullPath: prompt.filePath,
+    };
+  }
+
+  return convertToText({
+    success: true,
+    prompt: promptInfo
+  });
+}
+
+// 处理 search_prompts 工具调用
+export async function handleSearchPrompts(args, promptManager) {
+  // 注意：这里为了兼容性，我们同时支持title和name参数
+  const searchTerm = args.title || args.name;
+  
+  const logLevel = config.getLogLevel();
+  const allPrompts = promptManager.getPrompts();
+
+  // 如果搜索词为空，则返回所有提示词
+  if (!searchTerm) {
+    let simplifiedPrompts = formatResults(allPrompts);
+
+    return convertToText({
+      success: true,
+      query: searchTerm || '',
+      count: simplifiedPrompts.length,
+      results: simplifiedPrompts
+    });
+  }
+  
+  // 实现相似度匹配算法
+  const searchResults = allPrompts.map(prompt => {
+    prompt.description = prompt.description || `Prompt: ${prompt.name}`;
+    prompt.arguments = prompt.arguments || [];
+    prompt.hasArguments = prompt.arguments && prompt.arguments.length > 0;
+    return {
+      prompt: prompt,
+      score: calculateSimilarityScore(searchTerm, prompt),
+    };
+  })
+  .filter(result => result.score > 0) // 只返回有匹配的结果
+  .sort((a, b) => b.score - a.score); // 按相似度得分降序排列
+  
+
+  let result = {
+    success: true,
+    query: searchTerm || '',
+    count: searchResults.length,
+    results: formatResults(searchResults),
+  }
+
+  if (logLevel === 'debug') {
+    result.debug = {
+      scores: searchResults.map(result => ({
+        id: result.prompt.id,
+        name: result.prompt.name,
+        score: result.score,
+        fullPath: result.prompt.filePath,
+      }))
+    }
+  }
+
+  return convertToText(result);
+}
+
+/**
+ * 处理 reload_prompts 工具调用
+ */
+export async function handleReloadPrompts(promptManager) {
+  logger.info('重新加载prompts...');
+  
+  const result = await promptManager.reloadPrompts();
+  
+  return {
+    content: [
+      {
+        type: "text",
+        text: JSON.stringify({
+          success: true,
+          message: `重新加载完成: 成功 ${result.success} 个, 失败 ${result.errorCount} 个`,
+          result: formatResults(result.prompts)
+        }, null, 2)
+      }
+    ]
+  };
+}
+
+/**
+ * 格式化搜索结果
+ * @param {*} results 
+ * @returns 
+ */
+function formatResults(results = []) {
+  if (!Array.isArray(results)) return [];
+
+  // console.log(results);
+
+  return results.map(result => {
+    const prompt = result.prompt ? result.prompt : result;
+    const baseItem = {
+      id: prompt.id || prompt.uniqueId || '',
+      name: prompt.name || 'Unnamed Prompt',
+      description: prompt.description || `Prompt: ${prompt.name || 'Unnamed'}`
+    };
+
+    if (config.getLogLevel() === 'debug') {
+      return {
+        ...baseItem,
+        metadata: {
+          fullPath: prompt.filePath || ''
+        }
+      };
+    }
+    return baseItem;
+  });
+}
+
+/**
+ * 将对象转换为text类型
+ * @param {*} object 
+ * @returns 
+ */
+function convertToText(result) {
+  return {
+    content: [
+      {
+        type: "text",
+        text: JSON.stringify(result, null, 2)
+      }
+    ]
+  };
+}
+
+/**
+ * 计算搜索关键词与prompt的相似度得分
+ * @param {string} searchTerm - 搜索关键词
+ * @param {Object} prompt - prompt对象
+ * @returns {number} 相似度得分 (0-100)
+ */
+function calculateSimilarityScore(searchTerm, prompt) {
+  let totalScore = 0;
+  const searchLower = searchTerm ? searchTerm.toLowerCase() : '';
+  
+  // 搜索字段权重配置（专注于内容搜索，不包含ID检索）
+  const fieldWeights = {
+    name: 60,         // 名称权重高，是主要匹配字段
+    description: 40   // 描述权重适中，是辅助匹配字段
+  };
+  
+  // 计算name匹配得分
+  if (prompt && prompt.name && typeof prompt.name === 'string') {
+    const nameScore = getStringMatchScore(searchLower, prompt.name.toLowerCase());
+    totalScore += nameScore * fieldWeights.name;
+  }
+  
+  // 计算description匹配得分
+  if (prompt.description) {
+    const descScore = getStringMatchScore(searchLower, prompt.description.toLowerCase());
+    totalScore += descScore * fieldWeights.description;
+  }
+  
+  // 标准化得分到0-100范围
+  const maxPossibleScore = Object.values(fieldWeights).reduce((sum, weight) => sum + weight, 0);
+  return Math.round((totalScore / maxPossibleScore) * 100);
+}
+
+/**
+ * 计算两个字符串的匹配得分
+ * @param {string} search - 搜索词 (已转小写)
+ * @param {string} target - 目标字符串 (已转小写)
+ * @returns {number} 匹配得分 (0-1)
+ */
+function getStringMatchScore(search, target) {
+  if (!search || !target) return 0;
+  
+  // 完全匹配得分最高
+  if (target === search) return 1.0;
+  
+  // 完全包含得分较高
+  if (target.includes(search)) return 0.8;
+  
+  // 部分词匹配
+  const searchWords = search.split(/\s+/).filter(word => word.length > 0);
+  const targetWords = target.split(/\s+/).filter(word => word.length > 0);
+  
+  let matchedWords = 0;
+  for (const searchWord of searchWords) {
+    for (const targetWord of targetWords) {
+      if (targetWord.includes(searchWord) || searchWord.includes(targetWord)) {
+        matchedWords++;
+        break;
+      }
+    }
+  }
+  
+  if (searchWords.length > 0) {
+    const wordMatchRatio = matchedWords / searchWords.length;
+    return wordMatchRatio * 0.6; // 部分词匹配得分
+  }
+  
+  return 0;
+}