@becrafter/prompt-manager 0.0.15 → 0.0.18

package/packages/server/{manager.js → services/manager.js}

@@ -3,8 +3,9 @@ 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';
+import { logger } from '../utils/logger.js';
+import { config } from '../utils/config.js';
+import { GROUP_META_FILENAME } from '../utils/util.js';
 
 /**
  * Prompt数据结构验证schema
@@ -34,7 +35,7 @@ const PromptSchema = z.object({
 /**
  * Prompt管理器类
  */
-export class PromptManager {
+class PromptManager {
   constructor(promptsDir) {
     this.promptsDir = promptsDir;
     this.loadedPrompts = new Map();
@@ -92,7 +93,6 @@ export class PromptManager {
    * @returns {Object} 组元数据
    */
   readGroupMeta(dir) {
-    const GROUP_META_FILENAME = '.groupmeta.json';
     try {
       const metaPath = path.join(dir, GROUP_META_FILENAME);
       if (!fs.existsSync(metaPath)) {
@@ -322,7 +322,7 @@ export class PromptManager {
         }
       });
 
-      logger.info(`本地Prompt加载完成: 启用 ${loadedCount} 个, 禁用 ${disabledCount} 个, 失败 ${errorCount} 个`);
+      logger.info(`本地Prompt加载完成: 启用 ${loadedCount} 个, 禁用 ${disabledCount} 个, 失败 ${errorCount} 个\n`);
       
       return {
         success: loadedCount,
@@ -345,6 +345,11 @@ export class PromptManager {
     const filePath = typeof fileInfo === 'string' ? path.join(this.promptsDir, fileInfo) : fileInfo.filePath;
     const relativePath = typeof fileInfo === 'string' ? fileInfo : fileInfo.relativePath;
     
+    if (fileName === GROUP_META_FILENAME) {
+      // 跳过组元数据文件
+      return null;
+    }
+
     try {
       const content = await fs.readFile(filePath, 'utf8');
       const ext = path.extname(fileName).toLowerCase();
@@ -471,3 +476,6 @@ export class PromptManager {
     return await this.loadPrompts();
   }
 }
+
+// 创建全局PromptManager实例
+export const promptManager = new PromptManager(config.getPromptsDir());

package/packages/server/{config.js → utils/config.js}

@@ -15,10 +15,10 @@ const DEFAULT_PROMPTS_DIR = path.join(DEFAULT_HOME_DIR, 'prompts');
 function parseCommandLineArgs() {
   const args = process.argv.slice(2);
   const options = {};
-  
+
   for (let i = 0; i < args.length; i++) {
     const arg = args[i];
-    
+
     if (arg === '--prompts-dir' || arg === '-p') {
       options.promptsDir = args[i + 1];
       i++; // 跳过下一个参数
@@ -35,7 +35,7 @@ function parseCommandLineArgs() {
       options[key] = value;
     }
   }
-  
+
   return options;
 }
 
@@ -61,7 +61,7 @@ MCP Prompt Server - 智能 Prompt 管理服务器
   PROMPTS_DIR                Prompts目录路径
   MCP_SERVER_VERSION         服务器版本
   LOG_LEVEL                  日志级别 (默认: info)
-  MAX_PROMPTS                最大prompt数量限制 (默认: 100)
+  MAX_PROMPTS                最大prompt数量限制 (默认: 1000)
   RECURSIVE_SCAN             是否启用递归扫描子目录 (默认: true)
 
 示例:
@@ -77,34 +77,34 @@ MCP Prompt Server - 智能 Prompt 管理服务器
 export class Config {
   constructor() {
     const cliArgs = parseCommandLineArgs();
-    
+
     // 处理帮助和版本信息
     if (cliArgs.help) {
       showHelp();
       process.exit(0);
     }
-    
+
     // 确定prompts目录
-    this.promptsDir = cliArgs.promptsDir || 
-                     process.env.PROMPTS_DIR || 
-                     DEFAULT_PROMPTS_DIR;
+    this.promptsDir = cliArgs.promptsDir ||
+      process.env.PROMPTS_DIR ||
+      DEFAULT_PROMPTS_DIR;
     this.configHome = path.dirname(this.promptsDir);
-    
+
     // 服务器端口
     this.port = cliArgs.port || process.env.SERVER_PORT || 5621;
-    
+
     // 其他配置
     this.serverName = process.env.MCP_SERVER_NAME || 'prompt-manager';
-    this.serverVersion = process.env.MCP_SERVER_VERSION || '0.0.15';
+    this.serverVersion = process.env.MCP_SERVER_VERSION || '0.0.18';
     this.logLevel = process.env.LOG_LEVEL || 'info';
-    this.maxPrompts = parseInt(process.env.MAX_PROMPTS) || 100;
+    this.maxPrompts = parseInt(process.env.MAX_PROMPTS) || 1000;
     this.recursiveScan = process.env.RECURSIVE_SCAN !== 'false'; // 默认启用递归扫描
-    
+
     // 管理员配置
     this.adminEnable = process.env.ADMIN_ENABLE !== 'false'; // 默认启用管理员功能
     this.adminPath = process.env.ADMIN_PATH || '/admin';
     this.exportToken = process.env.EXPORT_TOKEN || crypto.randomBytes(32).toString('hex');
-    
+
     // 管理员账户（从环境变量或默认值）
     const adminUsername = process.env.ADMIN_USERNAME || 'admin';
     const adminPassword = process.env.ADMIN_PASSWORD || 'admin';
@@ -116,7 +116,7 @@ export class Config {
         token: process.env.ADMIN_TOKEN || crypto.randomBytes(32).toString('hex')
       }
     ];
-    
+
     if (cliArgs.version) {
       process.stderr.write(this.serverVersion + '\n');
       process.exit(0);
@@ -254,10 +254,10 @@ export class Config {
       if (!exists) {
         throw new Error(`Prompts目录不存在: ${this.promptsDir}`);
       }
-      
+
       // 检查目录是否可读
       await fs.access(this.promptsDir, fs.constants.R_OK);
-      
+
       return true;
     } catch (error) {
       throw new Error(`配置验证失败: ${error.message}`);
@@ -268,15 +268,15 @@ export class Config {
    * 显示当前配置（输出到 stderr，不干扰 MCP 通信）
    */
   showConfig() {
-    process.stderr.write('===== 服务器配置 =====\n');
-    process.stderr.write(`服务名称: ${this.serverName}\n`);
-    process.stderr.write(`服务版本: ${this.serverVersion}\n`);
-    process.stderr.write(`服务端口: ${this.port}\n`);
-    process.stderr.write(`日志级别: ${this.logLevel}\n`);
-    process.stderr.write(`递归扫描: ${this.recursiveScan ? '启用' : '禁用'}\n`);
-    process.stderr.write(`Prompts目录: ${this.promptsDir}\n`);
-    process.stderr.write(`最大Prompt数量: ${this.maxPrompts}\n`);
-    process.stderr.write('=====================\n');
+    process.stderr.write('===================================== 服务器配置 =====================================\n');
+    process.stderr.write(`   服务名称: ${this.serverName}\n`);
+    process.stderr.write(`   服务版本: ${this.serverVersion}\n`);
+    process.stderr.write(`   服务端口: ${this.port}\n`);
+    process.stderr.write(`   日志级别: ${this.logLevel}\n`);
+    process.stderr.write(`   递归扫描: ${this.recursiveScan ? '启用' : '禁用'}\n`);
+    process.stderr.write(`   Prompts目录: ${this.promptsDir}\n`);
+    process.stderr.write(`   最大Prompt数量: ${this.maxPrompts}\n`);
+    process.stderr.write('======================================================================================\n\n');
   }
 }
 

package/packages/server/utils/util.js

@@ -0,0 +1,356 @@
+import crypto from 'crypto';
+import fs from 'fs';
+import os from 'os';
+import path from 'path';
+import fse from 'fs-extra';
+import yaml from 'js-yaml';
+import { fileURLToPath } from 'url';
+import { logger } from './logger.js';
+
+export const GROUP_META_FILENAME = '.groupmeta.json';
+export const GROUP_NAME_REGEX = /^[a-zA-Z0-9-_\u4e00-\u9fa5]{1,64}$/;
+
+// 获取当前文件的目录路径
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = path.dirname(__filename);
+const projectRoot = path.resolve(__dirname, '../../..');
+const examplesPromptsRoot = path.join(projectRoot, 'examples', 'prompts');
+const promptsDir = path.join(os.homedir(), '.prompt-manager', 'prompts');
+
+let _promptManager;
+
+export class Util {
+    /**
+     * 检查并初始化prompts目录，如果目录为空则从示例目录复制内容
+     * @returns 
+     */
+    async seedPromptsIfEmpty() {
+        try {
+            const entries = await fse.readdir(promptsDir);
+            if (entries.length > 0) {
+                return;
+            }
+        } catch (error) {
+            logger.warn('读取Prompts目录失败，尝试同步示例数据:', error.message);
+        }
+
+        try {
+            const exists = await fse.pathExists(examplesPromptsRoot);
+            if (!exists) {
+                return;
+            }
+            await fse.copy(examplesPromptsRoot, promptsDir, {
+                overwrite: false,
+                errorOnExist: false,
+                recursive: true
+            });
+            logger.info(`已将示例Prompts同步到 ${promptsDir}`);
+        } catch (error) {
+            logger.warn('同步示例Prompts失败:', error.message);
+        }
+    }
+
+    /**
+     * 生成文件唯一标识码
+     * @param {*} relativePath 
+     * @returns 
+     */
+    generateUniqueId(relativePath) {
+        const hash = crypto.createHash('sha256');
+        hash.update(relativePath);
+        const hashHex = hash.digest('hex');
+        return hashHex.substring(0, 8);
+    }
+
+    /**
+     * 从文件中读取提示词
+     * @returns 
+     */
+    getPromptsFromFiles() {
+        const prompts = [];
+
+        const traverseDir = (currentPath, relativeDir = '', inheritedEnabled = true) => {
+            let currentEnabled = inheritedEnabled;
+            if (relativeDir) {
+                const meta = this.readGroupMeta(currentPath);
+                currentEnabled = currentEnabled && (meta.enabled !== false);
+            }
+
+            try {
+                const entries = fs.readdirSync(currentPath, { withFileTypes: true });
+                for (const entry of entries) {
+                    const fullPath = path.join(currentPath, entry.name);
+                    if (entry.isDirectory()) {
+                        const childRelativePath = relativeDir ? `${relativeDir}/${entry.name}` : entry.name;
+                        traverseDir(fullPath, childRelativePath, currentEnabled);
+                    } else if (entry.isFile() && entry.name.endsWith('.yaml')) {
+                        try {
+                            const fileContent = fs.readFileSync(fullPath, 'utf8');
+                            const prompt = yaml.load(fileContent);
+                            if (prompt && prompt.name) {
+                                const relativePath = path.relative(promptsDir, fullPath);
+                                const normalizedRelativePath = relativePath.split(path.sep).join('/');
+                                const relativeDirForFile = path.dirname(normalizedRelativePath);
+                                const topLevelGroup = relativeDirForFile && relativeDirForFile !== '.' ? relativeDirForFile.split('/')[0] : (prompt.group || 'default');
+                                const groupPath = relativeDirForFile && relativeDirForFile !== '.' ? relativeDirForFile : topLevelGroup;
+                                prompts.push({
+                                    ...prompt,
+                                    uniqueId: this.generateUniqueId(prompt.name + '.yaml'),
+                                    fileName: entry.name,
+                                    relativePath: normalizedRelativePath,
+                                    group: topLevelGroup,
+                                    groupPath,
+                                    groupEnabled: currentEnabled
+                                });
+                            }
+                        } catch (error) {
+                            logger.error(`Error processing file ${fullPath}:`, error);
+                        }
+                    }
+                }
+            } catch (error) {
+                logger.error(`Error reading directory ${currentPath}:`, error);
+            }
+        }
+
+        traverseDir(promptsDir);
+        return prompts;
+    }
+
+    /**
+     * 计算搜索关键词与prompt的相似度得分
+     * @param {string} searchTerm - 搜索关键词
+     * @param {Object} prompt - prompt对象
+     * @returns {number} 相似度得分 (0-100)
+     */
+    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 = util.getStringMatchScore(searchLower, prompt.name.toLowerCase());
+            totalScore += nameScore * fieldWeights.name;
+        }
+
+        // 计算description匹配得分
+        if (prompt.description) {
+            const descScore = util.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)
+     */
+    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;
+    }
+
+    /**
+     * 更新目录元数据
+     * @param {*} dir 
+     * @param {*} meta 
+     */
+    writeGroupMeta(dir, meta = {}) {
+        const metaPath = this.getGroupMetaPath(dir);
+        const data = {
+            enabled: meta.enabled !== false
+        };
+        fs.writeFileSync(metaPath, JSON.stringify(data, null, 2), 'utf8');
+    }
+
+    /**
+     * 验证目录名称是否有效
+     * @param {*} name 
+     * @returns 
+     */
+    isValidGroupName(name) {
+        return GROUP_NAME_REGEX.test(name);
+    }
+
+    /**
+     * 验证目录名称
+     * @param {*} relativePath 
+     * @returns 
+     */
+    validateGroupPath(relativePath) {
+        if (!relativePath || typeof relativePath !== 'string') {
+            return null;
+        }
+        const segments = relativePath.split('/').filter(Boolean);
+        if (!segments.length) {
+            return null;
+        }
+        for (const segment of segments) {
+            if (!this.isValidGroupName(segment)) {
+                return null;
+            }
+        }
+        return segments;
+    }
+
+    /**
+     * 
+     * @param {*} relativePath 
+     * @returns 
+     */
+    resolveGroupDir(relativePath) {
+        const segments = this.validateGroupPath(relativePath);
+        if (!segments) return null;
+        const targetPath = path.resolve(promptsDir, ...segments);
+        const normalizedPromptsDir = path.resolve(promptsDir);
+        if (!targetPath.startsWith(normalizedPromptsDir)) {
+            return null;
+        }
+        return { dir: targetPath, segments };
+    }
+
+    /**
+     * 获取目录元数据文件路径
+     * @param {*} dir 
+     * @returns 
+     */
+    getGroupMetaPath(dir) {
+        return path.join(dir, GROUP_META_FILENAME);
+    }
+
+    /**
+     * 读取目录元数据
+     * @param {*} dir 
+     * @returns 
+     */
+    readGroupMeta(dir) {
+        try {
+            const metaPath = this.getGroupMetaPath(dir);
+            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) {
+            logger.warn('读取类目元数据失败:', error);
+            return { enabled: true };
+        }
+    }
+
+    /**
+     * 获取所有分组（直接从目录读取）
+     * @param {*} baseDir 
+     * @param {*} relativePath 
+     * @returns 
+     */
+    buildGroupTree(baseDir, relativePath = '') {
+        const nodes = [];
+        try {
+            const entries = fs.readdirSync(baseDir, { withFileTypes: true });
+            for (const entry of entries) {
+                if (!entry.isDirectory()) continue;
+                if (entry.name.startsWith('.')) continue;
+                const childRelativePath = relativePath ? `${relativePath}/${entry.name}` : entry.name;
+                const childDir = path.join(baseDir, entry.name);
+                const children = this.buildGroupTree(childDir, childRelativePath);
+                const meta = this.readGroupMeta(childDir);
+                nodes.push({
+                    name: entry.name,
+                    path: childRelativePath,
+                    children,
+                    enabled: meta.enabled !== false
+                });
+            }
+        } catch (error) {
+            logger.error('读取分组目录失败:', error);
+        }
+        nodes.sort((a, b) => a.name.localeCompare(b.name, 'zh-CN'));
+        return nodes;
+    }
+
+    async processPromptContent(prompt, args) {
+      let content = '';
+      
+      if (prompt.messages && Array.isArray(prompt.messages)) {
+        const userMessages = prompt.messages.filter(msg => msg.role === 'user');
+        
+        for (const message of userMessages) {
+          if (message.content && typeof message.content.text === 'string') {
+            let text = message.content.text;
+            
+            // Replace arguments
+            if (args) {
+                for (const [key, value] of Object.entries(args)) {
+                    const placeholder = new RegExp(`{{${key}}}`, 'g');
+                    text = text.replace(placeholder, String(value));
+                }
+            }
+            
+            content += text + '\n\n';
+          }
+        }
+      }
+      
+      return content.trim();
+    }
+
+    /**
+     * 获取admin-ui目录的绝对路径
+     * @returns {string} admin-ui目录的绝对路径
+     */
+    getAdminUiRoot() {
+        const __filename = fileURLToPath(import.meta.url);
+        const __dirname = path.dirname(path.dirname(__filename));
+        return path.join(__dirname, '..', 'admin-ui');
+    };
+
+    async getPromptManager() {
+    if (!_promptManager) {
+        const serviceModule = await import('../services/manager.js');
+        _promptManager = serviceModule.promptManager;
+    }
+    return _promptManager;
+    }
+}
+
+export const util = new Util()