px2cc 2.0.5 → 2.1.0

package/README.md

@@ -6,7 +6,7 @@
 
 - 🚀 快速安装PromptX角色到Claude Code
 - 🎭 动态获取所有可用的系统角色和用户角色  
-- 🤖 支持安装为Claude Code Agents (通过 `/subagent` 调用)
+- 🤖 支持安装为Claude Code Subagents (通过自然语言提及调用)
 - ⚙️ 支持安装为Claude Code Commands (通过 `/command` 调用)
 - 🎨 友好的交互式界面
 - 📁 自动创建和管理 `.claude` 目录结构
@@ -33,9 +33,9 @@ npx px2cc
 
 ## 安装类型
 
-### Agent 模式
+### Subagent 模式
 - 安装到 `.claude/agents/` 目录
-- 通过 `/subagent <角色名>` 在Claude Code中调用
+- 通过自然语言提及调用: `Use the <角色名>-agent subagent to [任务]`
 
 ### Command 模式  
 - 安装到 `.claude/commands/` 目录
@@ -66,7 +66,7 @@ $ px2cc
 📊 发现 5 个系统角色，9 个用户角色
 
 ? 请选择要安装的PromptX角色: assistant (系统角色)
-? 安装 assistant 为: Agent - 通过 /subagent assistant 调用
+? 安装 assistant 为: Agent - 通过提及"assistant-agent subagent"调用
 ? 确认安装到Claude Code? Yes
 
 📖 加载 assistant 角色定义...
@@ -75,10 +75,11 @@ $ px2cc
 ✅ 角色安装完成！
 
 📄 生成的文件:
-   - .claude/agents/assistant.md
+   - .claude/agents/assistant-agent.md
 
 🎉 现在你可以在Claude Code中使用:
-   /subagent assistant
+   Use the assistant-agent subagent to help with my task
+   Have the assistant-agent subagent review my code
 
 💡 提示: 重启Claude Code以确保新配置生效
 ```

package/bin.js

@@ -6,7 +6,7 @@
  */
 
 // 设置环境变量来抑制PromptX内部日志
-process.env.PROMPTX_QUIET = 'true';
+process.env.LOG_LEVEL = 'silent';
 
 // 修改process.argv让cli.js以为自己是主模块
 import { fileURLToPath } from 'url';

package/cli.js

@@ -30,10 +30,11 @@ async function discoverMCPServers() {
 
   try {
     console.log(chalk.gray('   检查MCP服务器状态（可能需要一些时间）...'));
-    // 使用claude mcp list获取所有MCP服务器（增加超时时间）
+    // 使用claude mcp list获取所有MCP服务器（增加超时时间到60秒）
     const mcpOutput = execSync('claude mcp list', { 
       encoding: 'utf8',
-      timeout: 30000  // 增加到30秒
+      timeout: 60000,  // 增加到60秒
+      stdio: 'pipe'    // 确保错误输出被捕获
     });
     
     // 解析输出，提取服务器信息
@@ -58,13 +59,15 @@ async function discoverMCPServers() {
     
   } catch (error) {
     if (error.code === 'ETIMEDOUT') {
-      console.error(chalk.red('❌ MCP服务器检查超时'));
-      console.error(chalk.gray('   请检查网络连接或MCP服务器配置'));
+      console.error(chalk.yellow('⚠️  MCP服务器检查超时，将继续安装（只使用默认工具）'));
+      console.error(chalk.gray('   如需使用MCP工具，请检查网络连接或使用 --skip-mcp 参数'));
     } else {
-      console.error(chalk.red('❌ 无法获取MCP服务器列表'));
+      console.error(chalk.yellow('⚠️  无法获取MCP服务器列表，将继续安装（只使用默认工具）'));
       console.error(chalk.gray(`   原因: ${error.message}`));
     }
-    throw error;
+    // 不再抛出错误，而是继续执行，不使用MCP服务器
+    console.log(chalk.gray('   将继承所有可用工具（Claude Code默认行为）'));
+    return servers;
   }
 
   return servers;
@@ -177,7 +180,7 @@ async function showRoleMenu(systemRoles, userRoles, availableServers) {
       message: `安装 ${roleAnswer.selectedRole.role} 为:`,
       choices: [
         {
-          name: `🤖 Agent - 通过 /subagent ${roleAnswer.selectedRole.role} 调用`,
+          name: `🤖 Agent - 通过提及"${roleAnswer.selectedRole.role}-agent subagent"调用`,
           value: 'agents',
           short: 'Agent'
         },
@@ -240,7 +243,7 @@ async function installRole(selectedRole, installType, claudeDir, manager, select
     if (installType === 'agents') {
       console.log(chalk.cyan(`🔧 生成 ${roleName} subagent文件...`));
       const agentConfig = {
-        name: roleName,
+        name: `${roleName}-agent`,
         description: `基于PromptX ${roleName}角色的专业AI助手 - 完整action实现`,
         content: processedContent,
         targetDir: claudeDir
@@ -257,8 +260,8 @@ async function installRole(selectedRole, installType, claudeDir, manager, select
       if (!subagentResult.success) {
         throw new Error(`创建Subagent失败: ${subagentResult.error}`);
       }
-      results.agentFile = `${roleName}.md`;
-      results.usage = `/subagent ${roleName}`;
+      results.agentFile = `${roleName}-agent.md`;
+      results.usage = `Use the ${roleName}-agent subagent to [任务描述]`;
     }
 
     if (installType === 'commands') {
@@ -313,7 +316,15 @@ async function main() {
     } else {
       // 发现MCP服务器
       console.log(chalk.cyan('🔍 正在发现MCP服务器...\n'));
-      availableServers = await discoverMCPServers();
+      try {
+        availableServers = await discoverMCPServers();
+      } catch (error) {
+        console.error(chalk.yellow('⚠️  MCP服务器发现失败，使用默认配置'));
+        availableServers = {
+          defaultTools: ['Read', 'Write', 'Edit', 'Bash'],
+          mcpServers: []
+        };
+      }
     }
     
     // 加载角色

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "px2cc",
-  "version": "2.0.5",
+  "version": "2.1.0",
   "description": "CLI tool that implements complete PromptX Action flow in Claude Code - role activation, dependency loading, cognition networks & memory systems",
   "main": "cli.js",
   "type": "module",

package/src/PromptXActionProcessor.js

@@ -212,82 +212,42 @@ class CognitionLoader {
   }
 
   /**
-   * 检查认知网络状态
+   * 检查认知网络是否存在（不加载具体内容）
    * @param {string} roleId - 角色ID
-   * @returns {Object} 认知网络状态信息
+   * @returns {Object} 认知网络存在状态
    */
-  async loadCognitionNetwork(roleId) {
+  async checkNetworkExists(roleId) {
     console.log(chalk.cyan(`🧠 检查认知网络状态: ${roleId}`));
     
     try {
       const networkFilePath = path.join(this.basePath, roleId, 'network.json');
       
-      // 检查文件是否存在
+      // 仅检查文件是否存在
       try {
         await fs.access(networkFilePath);
+        console.log(chalk.green(`✅ 发现认知网络文件: ${roleId}`));
+        return {
+          hasNetwork: true,
+          networkPath: networkFilePath
+        };
       } catch (error) {
         console.log(chalk.gray(`   未找到认知网络文件: ${roleId}`));
         return {
           hasNetwork: false,
-          networkPath: networkFilePath,
-          status: 'not_found'
+          networkPath: networkFilePath
         };
       }
-
-      // 读取网络数据基本信息（不生成静态mindmap）
-      const networkData = JSON.parse(await fs.readFile(networkFilePath, 'utf8'));
-      const stats = this.getNetworkStats(networkData);
-      
-      console.log(chalk.green(`✅ 认知网络检查完成: ${stats.nodeCount} 个节点, ${stats.connectionCount} 个连接`));
-      
-      return {
-        hasNetwork: true,
-        networkPath: networkFilePath,
-        status: 'active',
-        stats,
-        lastModified: networkData.timestamp || 'unknown'
-      };
       
     } catch (error) {
       console.warn(chalk.yellow(`⚠️  认知网络检查失败: ${error.message}`));
       return {
         hasNetwork: false,
         networkPath: null,
-        status: 'error',
         error: error.message
       };
     }
   }
 
-  /**
-   * 获取网络统计信息
-   * @param {Object} networkData - 网络数据
-   * @returns {Object} 统计信息
-   */
-  getNetworkStats(networkData) {
-    const cues = networkData.cues || {};
-    const nodeCount = Object.keys(cues).length;
-    let connectionCount = 0;
-    
-    // 统计连接数
-    Object.values(cues).forEach(cue => {
-      connectionCount += (cue.connections || []).length;
-    });
-
-    // 找到最活跃的概念
-    const mostActiveCue = Object.entries(cues).reduce((max, [word, cue]) => {
-      const totalWeight = (cue.connections || []).reduce((sum, conn) => sum + (conn.weight || 0), 0);
-      return totalWeight > (max.totalWeight || 0) ? { word, totalWeight } : max;
-    }, { word: null, totalWeight: 0 });
-
-    return {
-      nodeCount,
-      connectionCount,
-      mostActiveCue: mostActiveCue.word,
-      version: networkData.version,
-      hasConnections: connectionCount > 0
-    };
-  }
 }
 
 /**
@@ -309,31 +269,26 @@ class LayerAssembler {
     parts.push(`# 🧠 [Consciousness Prime] ${roleInfo.id}${mode === 'subagent' ? '专业助手' : '角色已激活'}`);
     parts.push('');
 
-    // CognitionLayer - 动态认知网络状态
-    parts.push('## 💭 Hippocampus网络');
+    // CognitionLayer - PromptX认知增强
+    parts.push('## 💭 PromptX认知增强');
     
     if (cognitionData.hasNetwork) {
-      parts.push(`**认知网络状态**: ${cognitionData.status === 'active' ? '🟢 激活' : '🔴 未激活'}`);
-      
-      if (cognitionData.stats) {
-        parts.push(`**基础统计**: ${cognitionData.stats.nodeCount} 个概念节点，${cognitionData.stats.connectionCount} 个关联连接`);
-        
-        if (cognitionData.stats.mostActiveCue) {
-          parts.push(`**核心概念**: ${cognitionData.stats.mostActiveCue}`);
-        }
-      }
-      
+      parts.push('🧠 **状态**: 该角色已建立经验网络');
+      parts.push('');
+      parts.push('🔧 **激活方式** (需要PromptX MCP服务器):');
+      parts.push(`- \`recall ${roleInfo.id}\` - 激活该角色的完整经验网络`);
+      parts.push(`- \`recall ${roleInfo.id} "具体问题"\` - 检索相关历史经验`);
+      parts.push(`- \`remember ${roleInfo.id} "新知识"\` - 将新经验加入角色记忆`);
       parts.push('');
-      parts.push('🔄 **动态认知网络**: 网络状态随着你的学习和记忆而实时进化');
-      parts.push('- 使用PromptX `recall` 工具查看当前激活的记忆网络');
-      parts.push('- 使用PromptX `remember` 工具将新经验编织到认知网络中');
-      parts.push('- 每次交互都会调整概念间的关联强度');
+      parts.push('💡 **说明**: 认知网络包含该角色的历史使用经验，通过recall工具动态激活');
       
     } else {
-      parts.push('🌱 **初始状态**: 认知网络尚未建立');
-      parts.push('- 开始使用PromptX工具与该角色互动');  
-      parts.push('- 系统会自动建立和完善认知网络');
-      parts.push('- 随着经验积累，网络会变得越来越丰富');
+      parts.push('🌱 **状态**: 该角色尚未建立经验网络');
+      parts.push('');
+      parts.push('🚀 **开始使用**:');
+      parts.push('- 安装并配置PromptX MCP服务器');
+      parts.push(`- 使用 \`recall ${roleInfo.id}\` 开始建立认知网络`);
+      parts.push('- 随着使用逐步积累该角色的专业经验');
     }
     
     parts.push('');
@@ -392,13 +347,15 @@ class LayerAssembler {
       parts.push('请告诉我你需要什么帮助？');
     }
 
+    parts.push('');
+    parts.push('---');
     parts.push('');
     parts.push('💡 **可用的PromptX工具生态**：');
-    parts.push('- 使用PromptX的 `recall` 工具激活相关记忆和经验');
-    parts.push('- 使用PromptX的 `remember` 工具保存新的学习成果');
-    parts.push('- 使用PromptX的 `learn` 工具学习新的资源和知识');
-    parts.push('- 使用PromptX的 `toolx` 工具执行专业工具');
-    parts.push('- 具体工具名称取决于你的MCP配置');
+    parts.push(`- \`recall ${roleInfo.id}\` - 激活该角色的历史经验网络`);
+    parts.push(`- \`remember ${roleInfo.id} "新体验"\` - 将新体验编织到角色记忆`);
+    parts.push('- `learn` - 学习新的资源和知识');
+    parts.push('- `toolx` - 执行专业工具');
+    parts.push('- 具体工具可用性取决于PromptX MCP服务器配置');
     parts.push('');
     
     if (mode === 'command') {
@@ -457,8 +414,8 @@ export class PromptXActionProcessor {
       // 2. 分析依赖资源
       const dependencies = await this.dependencyAnalyzer.analyzeDependencies(roleInfo);
       
-      // 3. 加载认知网络
-      const cognitionData = await this.cognitionLoader.loadCognitionNetwork(roleId);
+      // 3. 检查认知网络存在性
+      const cognitionData = await this.cognitionLoader.checkNetworkExists(roleId);
       
       // 4. 三层组装
       const content = this.layerAssembler.assembleContent(roleInfo, dependencies, cognitionData, mode);