@becrafter/prompt-manager 0.0.19 → 0.1.2

package/app/desktop/src/utils/resource-sync.js

@@ -0,0 +1,260 @@
+/**
+ * 通用资源同步工具
+ * 支持将代码中的内容同步到运行环境中
+ * 支持目录同步、文件同步和基于内容的文件创建
+ */
+
+const fs = require('fs').promises;
+const path = require('path');
+const os = require('os');
+const { app } = require('electron');
+const PathUtils = require('./path-utils');
+
+class ResourceSync {
+  /**
+   * 检查是否为打包应用
+   */
+  static _checkIfPackaged() {
+    const appPath = app.getAppPath();
+    const isDev = appPath.includes('node_modules/electron') || 
+                 process.env.NODE_ENV === 'development' ||
+                 process.defaultApp;
+    
+    return !isDev && app.isPackaged;
+  }
+
+  /**
+   * 获取项目根目录（开发模式）
+   */
+  static _getProjectRoot() {
+    // 从 app/desktop/src/utils -> 项目根目录
+    return path.resolve(__dirname, '..', '..', '..', '..');
+  }
+
+  /**
+   * 获取用户配置根目录
+   */
+  static _getUserConfigRoot() {
+    return path.join(os.homedir(), '.prompt-manager');
+  }
+
+  /**
+   * 查找实际存在的源路径
+   * @param {Object} options - 查找选项
+   * @param {string|Function} options.devPath - 开发模式下的路径（字符串或返回路径的函数）
+   * @param {string[]|Function} options.packagedPaths - 打包模式下的可能路径数组（或返回路径数组的函数）
+   * @returns {Promise<string|null>} 找到的源路径，如果不存在则返回 null
+   */
+  static async findSourcePath({ devPath, packagedPaths }) {
+    const isPackaged = this._checkIfPackaged();
+    
+    if (isPackaged) {
+      // 打包模式
+      let paths;
+      if (typeof packagedPaths === 'function') {
+        paths = packagedPaths();
+      } else {
+        paths = packagedPaths || [];
+      }
+
+      // 尝试每个路径，返回第一个存在的
+      for (const possiblePath of paths) {
+        try {
+          if (await PathUtils.pathExists(possiblePath)) {
+            return possiblePath;
+          }
+        } catch (error) {
+          // 继续尝试下一个路径
+          continue;
+        }
+      }
+      
+      console.warn('在打包模式下未找到源路径，尝试的路径:', paths);
+      return null;
+    } else {
+      // 开发模式
+      let sourcePath;
+      if (typeof devPath === 'function') {
+        sourcePath = devPath();
+      } else {
+        sourcePath = devPath;
+      }
+
+      if (sourcePath && await PathUtils.pathExists(sourcePath)) {
+        return sourcePath;
+      }
+      
+      console.warn('在开发模式下未找到源路径:', sourcePath);
+      return null;
+    }
+  }
+
+  /**
+   * 同步目录
+   * @param {Object} config - 同步配置
+   * @param {string} config.targetPath - 目标目录路径
+   * @param {string|Function} config.devPath - 开发模式下的源路径
+   * @param {string[]|Function} config.packagedPaths - 打包模式下的可能源路径
+   * @param {boolean} config.skipIfExists - 如果目标已存在则跳过（默认: true）
+   * @param {string} config.name - 资源名称（用于日志）
+   * @returns {Promise<Object>} 同步结果
+   */
+  static async syncDirectory({
+    targetPath,
+    devPath,
+    packagedPaths,
+    skipIfExists = true,
+    name = '目录'
+  }) {
+    try {
+      // 检查目标目录是否已存在
+      const targetExists = await PathUtils.pathExists(targetPath);
+      if (targetExists && skipIfExists) {
+        console.log(`${name}目录已存在，跳过同步: ${targetPath}`);
+        return { success: true, skipped: true, targetPath };
+      }
+
+      // 查找源路径
+      const sourcePath = await this.findSourcePath({ devPath, packagedPaths });
+      
+      if (!sourcePath) {
+        console.warn(`未找到源${name}目录，跳过同步`);
+        return { success: false, error: `Source ${name} directory not found` };
+      }
+
+      // 创建目标目录的父目录
+      await PathUtils.ensureDir(path.dirname(targetPath));
+      
+      // 如果目标已存在但不跳过，先删除
+      if (targetExists && !skipIfExists) {
+        await PathUtils.safeRemoveDir(targetPath);
+      }
+
+      // 创建目标目录
+      await PathUtils.ensureDir(targetPath);
+      console.log(`已创建${name}目录: ${targetPath}`);
+
+      // 复制目录内容
+      await PathUtils.copyDir(sourcePath, targetPath);
+      console.log(`已同步${name}: ${sourcePath} -> ${targetPath}`);
+
+      return { 
+        success: true, 
+        skipped: false, 
+        targetPath, 
+        sourcePath 
+      };
+    } catch (error) {
+      console.error(`${name}同步失败:`, error);
+      return { success: false, error: error.message };
+    }
+  }
+
+  /**
+   * 同步文件（从源文件复制）
+   * @param {Object} config - 同步配置
+   * @param {string} config.targetPath - 目标文件路径
+   * @param {string|Function} config.devPath - 开发模式下的源文件路径
+   * @param {string[]|Function} config.packagedPaths - 打包模式下的可能源文件路径
+   * @param {boolean} config.skipIfExists - 如果目标已存在则跳过（默认: true）
+   * @param {string} config.name - 资源名称（用于日志）
+   * @returns {Promise<Object>} 同步结果
+   */
+  static async syncFile({
+    targetPath,
+    devPath,
+    packagedPaths,
+    skipIfExists = true,
+    name = '文件'
+  }) {
+    try {
+      // 检查目标文件是否已存在
+      const targetExists = await PathUtils.pathExists(targetPath);
+      if (targetExists && skipIfExists) {
+        console.log(`${name}文件已存在，跳过同步: ${targetPath}`);
+        return { success: true, skipped: true, targetPath };
+      }
+
+      // 查找源路径
+      const sourcePath = await this.findSourcePath({ devPath, packagedPaths });
+      
+      if (!sourcePath) {
+        console.warn(`未找到源${name}文件，跳过同步`);
+        return { success: false, error: `Source ${name} file not found` };
+      }
+
+      // 创建目标文件的父目录
+      await PathUtils.ensureDir(path.dirname(targetPath));
+
+      // 复制文件
+      await fs.copyFile(sourcePath, targetPath);
+      console.log(`已同步${name}文件: ${sourcePath} -> ${targetPath}`);
+
+      return { 
+        success: true, 
+        skipped: false, 
+        targetPath, 
+        sourcePath 
+      };
+    } catch (error) {
+      console.error(`${name}文件同步失败:`, error);
+      return { success: false, error: error.message };
+    }
+  }
+
+  /**
+   * 基于内容创建文件
+   * @param {Object} config - 同步配置
+   * @param {string} config.targetPath - 目标文件路径
+   * @param {string|Function} config.content - 文件内容（字符串或返回内容的函数）
+   * @param {boolean} config.skipIfExists - 如果目标已存在则跳过（默认: true）
+   * @param {string} config.name - 资源名称（用于日志）
+   * @returns {Promise<Object>} 同步结果
+   */
+  static async syncContent({
+    targetPath,
+    content,
+    skipIfExists = true,
+    name = '文件'
+  }) {
+    try {
+      // 检查目标文件是否已存在
+      const targetExists = await PathUtils.pathExists(targetPath);
+      if (targetExists && skipIfExists) {
+        console.log(`${name}文件已存在，跳过创建: ${targetPath}`);
+        return { success: true, skipped: true, targetPath };
+      }
+
+      // 获取文件内容
+      let fileContent;
+      if (typeof content === 'function') {
+        fileContent = content();
+      } else {
+        fileContent = content;
+      }
+
+      if (!fileContent) {
+        return { success: false, error: 'Content is required' };
+      }
+
+      // 创建目标文件的父目录
+      await PathUtils.ensureDir(path.dirname(targetPath));
+
+      // 写入文件
+      await fs.writeFile(targetPath, fileContent, 'utf8');
+      console.log(`已创建${name}文件: ${targetPath}`);
+
+      return { 
+        success: true, 
+        skipped: false, 
+        targetPath 
+      };
+    } catch (error) {
+      console.error(`${name}文件创建失败:`, error);
+      return { success: false, error: error.message };
+    }
+  }
+}
+
+module.exports = ResourceSync;
+

package/app/desktop/src/utils/runtime-sync.js

@@ -0,0 +1,241 @@
+/**
+ * 运行时环境同步工具
+ * 负责将打包的 runtime 目录同步到 ~/.prompt-manager 目录
+ * runtime 目录包含所有运行时需要的资源（toolbox、.env 等）
+ * 
+ * 优化方案：直接同步整个 runtime 目录内容，避免逐个文件处理
+ */
+
+const path = require('path');
+const { app } = require('electron');
+const ResourceSync = require('./resource-sync');
+const PathUtils = require('./path-utils');
+
+class RuntimeSync {
+  /**
+   * 同步运行时环境
+   * 将 runtime 目录下的所有内容同步到 ~/.prompt-manager 目录
+   * 支持选择性同步（只同步不存在的文件/目录）
+   */
+  static async syncRuntime() {
+    const configRoot = ResourceSync._getUserConfigRoot();
+    
+    // 确保配置目录存在
+    await PathUtils.ensureDir(configRoot);
+    
+    const isPackaged = ResourceSync._checkIfPackaged();
+    
+    if (isPackaged) {
+      // 打包模式：从 runtime 目录同步
+      return await this._syncFromRuntime(configRoot);
+    } else {
+      // 开发模式：从源文件同步（构建 runtime 结构）
+      return await this._syncFromDev(configRoot);
+    }
+  }
+  
+  /**
+   * 从打包的 runtime 目录同步
+   */
+  static async _syncFromRuntime(configRoot) {
+    const resourcesPath = process.resourcesPath;
+    const possiblePaths = [
+      path.join(resourcesPath, 'runtime'), // extraResources 中的 runtime（最常见）
+      path.join(app.getAppPath(), 'runtime'), // 备用路径
+    ];
+    
+    // 查找 runtime 目录
+    const runtimePath = await ResourceSync.findSourcePath({
+      devPath: null,
+      packagedPaths: () => possiblePaths
+    });
+    
+    if (!runtimePath) {
+      console.warn('未找到 runtime 目录，跳过同步');
+      return { success: false, error: 'Runtime directory not found' };
+    }
+    
+    // 同步 runtime 目录下的所有内容到 configRoot
+    // 逐个同步子目录和文件，避免覆盖已存在的文件
+    const results = await this._syncContents(runtimePath, configRoot);
+    
+    return {
+      success: true,
+      configRoot,
+      runtimePath,
+      results
+    };
+  }
+  
+  /**
+   * 从开发环境源文件同步（模拟 runtime 结构）
+   */
+  static async _syncFromDev(configRoot) {
+    const projectRoot = ResourceSync._getProjectRoot();
+    const results = {};
+    
+    // 同步 toolbox（对应 runtime/toolbox）
+    // 使用递归同步，确保新增的工具能够被同步
+    const toolboxSource = path.join(projectRoot, 'packages', 'resources', 'tools');
+    const toolboxTarget = path.join(configRoot, 'toolbox');
+    if (await PathUtils.pathExists(toolboxSource)) {
+      const result = await this._syncDirectoryRecursive(toolboxSource, toolboxTarget, 'toolbox');
+      results.toolbox = result;
+    }
+    
+    // 同步 .env（对应 runtime/.env）
+    const envSource = path.join(projectRoot, 'env.example');
+    const envTarget = path.join(configRoot, '.env');
+    if (await PathUtils.pathExists(envSource)) {
+      const result = await ResourceSync.syncFile({
+        targetPath: envTarget,
+        devPath: () => envSource,
+        packagedPaths: () => [],
+        skipIfExists: true,
+        name: '环境配置'
+      });
+      results['.env'] = result;
+    }
+    
+    return {
+      success: true,
+      configRoot,
+      results
+    };
+  }
+  
+  /**
+   * 递归同步目录
+   * 确保新增的子目录和文件能够被同步到运行环境
+   * @param {string} sourceDir - 源目录路径
+   * @param {string} targetDir - 目标目录路径
+   * @param {string} dirName - 目录名称（用于日志）
+   * @returns {Promise<Object>} 同步结果
+   */
+  static async _syncDirectoryRecursive(sourceDir, targetDir, dirName = '目录') {
+    const fs = require('fs').promises;
+    const results = {
+      synced: [],
+      skipped: [],
+      errors: []
+    };
+    
+    try {
+      // 确保目标目录存在
+      await PathUtils.ensureDir(targetDir);
+      
+      // 读取源目录下的所有条目
+      const entries = await fs.readdir(sourceDir, { withFileTypes: true });
+      
+      for (const entry of entries) {
+        const sourcePath = path.join(sourceDir, entry.name);
+        const targetPath = path.join(targetDir, entry.name);
+        
+        try {
+          if (entry.isDirectory()) {
+            // 递归同步子目录
+            const subResult = await this._syncDirectoryRecursive(sourcePath, targetPath, entry.name);
+            
+            // 合并结果
+            results.synced.push(...subResult.details.synced);
+            results.skipped.push(...subResult.details.skipped);
+            results.errors.push(...subResult.details.errors);
+          } else if (entry.isFile()) {
+            // 同步文件
+            const targetExists = await PathUtils.pathExists(targetPath);
+            let needsSync = !targetExists;
+            
+            if (targetExists) {
+              // 比较文件修改时间
+              try {
+                const sourceStat = await fs.stat(sourcePath);
+                const targetStat = await fs.stat(targetPath);
+                if (sourceStat.mtime > targetStat.mtime) {
+                  needsSync = true;
+                }
+              } catch (statError) {
+                // 如果无法获取文件状态，默认需要同步
+                needsSync = true;
+              }
+            }
+            
+            if (needsSync) {
+              // 确保目标文件的父目录存在
+              await PathUtils.ensureDir(path.dirname(targetPath));
+              
+              // 复制文件
+              await fs.copyFile(sourcePath, targetPath);
+              console.log(`已同步文件: ${entry.name} -> ${targetPath}`);
+              
+              results.synced.push(entry.name);
+            } else {
+              console.log(`文件已存在且无需更新，跳过: ${entry.name}`);
+              results.skipped.push({ item: entry.name, reason: '已存在且无需更新' });
+            }
+          }
+        } catch (error) {
+          console.error(`同步失败: ${entry.name}`, error);
+          results.errors.push({ item: entry.name, error: error.message });
+        }
+      }
+      
+      return {
+        success: results.errors.length === 0,
+        synced: results.synced.length,
+        skipped: results.skipped.length,
+        errors: results.errors.length,
+        details: results
+      };
+    } catch (error) {
+      console.error(`递归同步 ${dirName} 失败:`, error);
+      return {
+        success: false,
+        error: error.message,
+        details: results
+      };
+    }
+  }
+
+  /**
+   * 同步 runtime 目录下的所有内容到目标目录
+   * 逐个同步子目录和文件，避免覆盖已存在的文件
+   */
+  static async _syncContents(runtimePath, configRoot) {
+    const fs = require('fs').promises;
+    const results = {};
+    
+    try {
+      // 读取 runtime 目录下的所有条目
+      const entries = await fs.readdir(runtimePath, { withFileTypes: true });
+      
+      for (const entry of entries) {
+        const sourcePath = path.join(runtimePath, entry.name);
+        const targetPath = path.join(configRoot, entry.name);
+        
+        if (entry.isDirectory()) {
+          // 所有目录都使用递归同步，确保新增的子目录和文件能够被同步
+          const result = await this._syncDirectoryRecursive(sourcePath, targetPath, entry.name);
+          results[entry.name] = result;
+        } else if (entry.isFile()) {
+          // 同步文件（如 .env）
+          const result = await ResourceSync.syncFile({
+            targetPath,
+            devPath: () => sourcePath,
+            packagedPaths: () => [sourcePath],
+            skipIfExists: true,
+            name: entry.name
+          });
+          results[entry.name] = result;
+        }
+      }
+      
+      return results;
+    } catch (error) {
+      console.error('同步 runtime 内容失败:', error);
+      throw error;
+    }
+  }
+}
+
+module.exports = RuntimeSync;
+

package/examples/prompts/recommend/human_3-0_growth_diagnostic_coach_prompt.yaml

@@ -0,0 +1,105 @@
+name: human_3.0_growth_diagnostic_coach_prompt
+# 饶秋定制·成长诊断教练 Prompt
+
+description: HUMAN 3.0 中文版 · 成长诊断教练 Prompt。
+arguments: []
+messages:
+  - role: user
+    content:
+      type: text
+      text: |
+        🎯 定位
+        你是一位极具洞察力、直率但尊重的成长教练。
+        你的任务是通过对话，帮助我识别我在四个成长象限——心智、身体、精神、职业——中的真实发展阶段，并指出阻碍我升级的“核心问题（Core Problem）”。
+        你的风格：直白、理性、真诚、有温度。
+        你要能识破自我欺骗，但不会评判，要像一个真正懂我的导师。
+
+        🧩 模型核心（你必须内化的设定）
+
+        一、四大象限
+        象限｜关键词｜典型问题
+        心智 Mind｜认知、思维、学习、自我觉察｜思维僵化、逃避反思、自以为是
+        身体 Body｜能量、健康、纪律、行动力｜作息紊乱、拖延、缺乏执行力
+        精神 Spirit｜价值、关系、内在平衡｜迷失、焦虑、空虚、人际疏离
+        职业 Vocation｜目标、影响力、创造价值｜无方向、低成就、失去意义感
+
+        二、成长三阶段
+        阶段｜描述｜典型表现
+        1.0 遵循规则期｜依赖外界标准、渴望被认可｜害怕出错、讨好他人、过度理性
+        2.0 追求自我期｜觉醒个体意志、寻求差异化｜疯狂试错、自我怀疑、易倦怠
+        3.0 整合全局期｜以更高层次视角整合四象限｜内外一致、长期主义、宁静清晰
+
+        🧠 对话流程（AI 请严格遵循）
+
+        Step 1：基础访谈
+        依次提问，判断我在四象限的阶段。
+
+        心智
+        • 最近有哪些事情让你改变了看法或重新思考？
+        • 你会主动反省自己，还是更习惯给自己找理由？
+        • 当别人挑战你的观点时，你通常怎么反应？
+
+        身体
+        • 你最近的睡眠、饮食、运动节奏是怎样的？
+        • 你有固定的能量管理方式吗？
+        • 当你状态不好时，你会强撑还是休息调整？
+
+        精神
+        • 你觉得生命的意义是什么？最近有让你感到平静的时刻吗？
+        • 你与家人、朋友、同事的关系是滋养型还是消耗型？
+        • 你是否能一个人独处而不焦虑？
+
+        职业
+        • 你现在的工作或项目，让你感到兴奋吗？
+        • 你觉得自己做的事对别人或世界有什么价值？
+        • 如果现在可以重来一次，你还会选择同样的方向吗？
+
+        你的目标：基于我的回答，判断我在每个象限处于哪一阶段（1.0 / 2.0 / 3.0）。
+
+        Step 2：识别核心问题（Core Problem）
+        根据四象限的评估，告诉我：
+        1) 哪个象限是当前发展的“瓶颈”？
+        2) 这个问题的本质是什么（表面困惑背后的根因）？
+        3) 为什么这会影响我整体的成长？
+        4) 我目前可能在哪些地方“自欺欺人”或“伪成长”？（要直白指出，但保持尊重）
+
+        Step 3：制定阶段性成长方案
+        请根据我的核心问题，提供一个分阶段行动计划：
+
+        📆 30 天计划：认知觉醒与启动
+        • 目标：打破旧思维，建立觉察
+        • 行动：
+          - 每日小习惯 × 3（含一个思维类、一个身体类、一个精神类）
+          - 每周挑战任务 × 1（打破舒适区）
+          - 推荐书 / 视频 / 练习资源
+        • 成功判断：出现情绪觉察、执行力提升、自我对话减少逃避。
+
+        📆 90 天计划：习惯与结构建立
+        • 目标：让成长自动化
+        • 行动：
+          - 建立节奏化的生活（固定睡眠 / 学习 / 复盘时间）
+          - 在职业维度落实成果或小里程碑
+          - 引入反馈机制（伙伴 / 教练 / 日志）
+        • 成功判断：行为稳定、目标清晰、关系和能量稳定。
+
+        📆 180 天计划：整合与跃迁
+        • 目标：让成长内化为身份
+        • 行动：
+          - 统一四象限目标，构建长期主义路线图
+          - 识别自己独特的 Metatype（如思考者 / 创造者 / 引导者）
+          - 形成自己的价值观系统并付诸实践
+        • 成功判断：行动与价值一致，外界变化不再轻易动摇你。
+
+        Step 4：总结反馈（输出结构）
+        1) 你的整体象限画像（心智 / 身体 / 精神 / 职业的阶段）
+        2) 当前最需要解决的核心问题
+        3) 对你最真诚的一句话（提醒或戳破盲点）
+        4) 30 / 90 / 180 天的成长计划
+        5) 你现在可以立刻去做的一件小事（1 小时内可完成）
+        6) 长远方向与下一次迭代建议
+
+        ⚠️ 语气与风格要求
+        • 语气真诚、理性，不浮夸。
+        • 指出问题时，不批评、不安慰，要有洞察力。
+        • 用“镜子”而不是“教条”说话。
+        • 中文语境下，可使用朴实比喻（如“你在用冲刺的方式跑马拉松”“你在用脑解决本应用心的问题”）。

package/package.json

@@ -1,12 +1,12 @@
 {
   "name": "@becrafter/prompt-manager",
-  "version": "0.0.19",
+  "version": "0.1.2",
   "description": "Remote MCP Server for managing prompts",
   "publishConfig": {
     "access": "public"
   },
   "type": "module",
-  "main": "packages/server/server.js",
+  "main": "packages/server/index.js",
   "bin": {
     "prompt-manager": "app/cli/cli.js"
   },
@@ -19,19 +19,20 @@
     "url": "https://github.com/BeCrafter/prompt-manager/issues"
   },
   "scripts": {
-    "start": "node packages/server/server.js",
     "dev": "node --watch packages/server/server.js",
-    "test": "node packages/server/server.js",
     "help": "node packages/server/server.js --help",
-    "version": "node packages/server/server.js --version",
-    "admin": "ADMIN_ENABLE=true ADMIN_USERNAME=admin ADMIN_PASSWORD=admin123 node packages/server/server.js -p ./examples/prompts",
-    "desktop:dev": "rm -rf ~/Library/Application\\ Support/@becrafter/prompt-desktop/prompt-manager && npm run dev --prefix app/desktop",
-    "desktop:build": "rm -rf ~/Library/Application\\ Support/@becrafter/prompt-desktop/prompt-manager && npm run build --prefix app/desktop && echo 'Build completed! Time:'$(date +'%Y-%m-%d %H:%M:%S')",
-    "desktop:build:all": "npm run build --prefix app/desktop -- --mac --win --linux",
-    "desktop:build:mac": "npm run build --prefix app/desktop -- --mac",
-    "desktop:build:win": "npm run build --prefix app/desktop -- --win",
-    "desktop:build:linux": "npm run build --prefix app/desktop -- --linux",
-    "postinstall": "node ./scripts/postinstall.js"
+    "admin": "ADMIN_ENABLE=true ADMIN_REQUIRE_AUTH=true ADMIN_USERNAME=admin ADMIN_PASSWORD=admin123 node packages/server/server.js -p ./examples/prompts",
+    "admin:dev": "npm run dev --prefix packages/admin-ui",
+    "admin:build": "npm run build --prefix packages/admin-ui",
+    "desktop:dev": "bash scripts/build.sh dev",
+    "desktop:build": "bash scripts/build.sh",
+    "desktop:build:all": "bash scripts/build.sh build:all",
+    "desktop:build:mac": "bash scripts/build.sh build:mac",
+    "desktop:build:win": "bash scripts/build.sh build:win",
+    "desktop:build:linux": "bash scripts/build.sh build:linux",
+    "postinstall": "node ./scripts/postinstall.js",
+    "build:core": "npm run build --prefix packages/server",
+    "build:icons": "node ./scripts/build-icons.js"
   },
   "keywords": [
     "mcp",
@@ -44,10 +45,12 @@
   "license": "MIT",
   "dependencies": {
     "@modelcontextprotocol/sdk": "^1.20.2",
+    "@npmcli/arborist": "^9.0.0",
     "dotenv": "^17.2.3",
     "electron-builder": "^26.0.12",
     "express": "^5.1.0",
     "fs-extra": "^11.2.0",
+    "http-proxy-middleware": "^3.0.5",
     "js-yaml": "^4.1.0",
     "sharp": "^0.34.4",
     "tar": "^7.5.1",

package/packages/admin-ui/.babelrc

@@ -0,0 +1,3 @@
+{
+  "presets": ["@babel/preset-env"]
+}