px2cc 1.1.0 → 2.0.0

package/cli.js

@@ -7,85 +7,117 @@
 
 import { resource } from '@promptx/core';
 import { ClaudeCodeBuilder } from 'claude-code-builder';
+import { PromptXActionProcessor } from './src/PromptXActionProcessor.js';
 import inquirer from 'inquirer';
 import chalk from 'chalk';
 import path from 'path';
 import fs from 'fs';
 import { execSync } from 'child_process';
 
-// 获取所有可用工具
-async function discoverAllTools() {
-  const tools = {
+// 注意：原有的parsePromptXRole函数已被PromptXActionProcessor替代
+// 新的处理器实现完整的PromptX Action流程，包括：
+// 1. RoleLoader - 加载角色定义  
+// 2. DependencyAnalyzer - 分析资源依赖
+// 3. CognitionLoader - 加载认知网络
+// 4. LayerAssembler - 三层内容组装
+
+// 发现MCP服务器
+async function discoverMCPServers() {
+  const servers = {
     defaultTools: ['Read', 'Write', 'Edit', 'Bash'],
-    mcpTools: []
+    mcpServers: []
   };
 
   try {
-    // 使用claude mcp命令获取所有可用工具
-    const mcpOutput = execSync('claude mcp list-tools', { 
+    console.log(chalk.gray('   检查MCP服务器状态（可能需要一些时间）...'));
+    // 使用claude mcp list获取所有MCP服务器（增加超时时间）
+    const mcpOutput = execSync('claude mcp list', { 
       encoding: 'utf8',
-      timeout: 10000 
+      timeout: 30000  // 增加到30秒
     });
     
-    // 解析输出，提取工具名称
+    // 解析输出，提取服务器信息
     const lines = mcpOutput.split('\n');
+    
     for (const line of lines) {
       const trimmedLine = line.trim();
-      // 匹配工具名称格式（通常以mcp__开头）
-      if (trimmedLine.startsWith('mcp__') || trimmedLine.includes('__')) {
-        tools.mcpTools.push(trimmedLine.split(/\s+/)[0]);
+      // 匹配服务器名称（格式：serverName: command - status）
+      const match = trimmedLine.match(/^([^:]+):\s+(.+)\s+-\s+(✓|✗)\s+(.*)$/);
+      if (match && !trimmedLine.includes('Checking MCP server health')) {
+        const [, name, command, status, statusText] = match;
+        servers.mcpServers.push({
+          name: name.trim(),
+          command: command.trim(), 
+          connected: status === '✓',
+          status: statusText.trim()
+        });
       }
     }
     
-    console.log(chalk.green(`✅ 发现 ${tools.mcpTools.length} 个MCP工具`));
+    console.log(chalk.green(`✅ 发现 ${servers.mcpServers.length} 个MCP服务器`));
     
   } catch (error) {
-    console.log(chalk.yellow('⚠️  无法获取MCP工具列表，使用默认配置'));
-    console.log(chalk.gray(`   原因: ${error.message}`));
+    if (error.code === 'ETIMEDOUT') {
+      console.error(chalk.red('❌ MCP服务器检查超时'));
+      console.error(chalk.gray('   请检查网络连接或MCP服务器配置'));
+    } else {
+      console.error(chalk.red('❌ 无法获取MCP服务器列表'));
+      console.error(chalk.gray(`   原因: ${error.message}`));
+    }
+    throw error;
   }
 
-  return tools;
+  return servers;
 }
 
-// 显示工具选择界面
-async function selectTools(roleName, availableTools) {
-  const choices = [
-    new inquirer.Separator(chalk.green('🔧 默认工具（必选）')),
-    ...availableTools.defaultTools.map(tool => ({
-      name: `✓ ${tool}`,
-      value: tool,
-      checked: true,
-      disabled: '(必需)'
-    }))
-  ];
+// 显示MCP服务器选择界面
+async function selectMCPServers(roleName, availableServers) {
+  // 如果没有MCP服务器，直接返回undefined（继承所有工具）
+  if (availableServers.mcpServers.length === 0) {
+    console.log(chalk.gray('   没有发现MCP服务器，将继承所有可用工具'));
+    return undefined;
+  }
 
-  if (availableTools.mcpTools.length > 0) {
-    choices.push(
-      new inquirer.Separator(chalk.blue('🛠️  MCP工具（可选）')),
-      ...availableTools.mcpTools.map(tool => ({
-        name: tool,
-        value: tool,
-        checked: tool.includes('promptx') // PromptX工具默认选中
-      }))
-    );
+  // 只显示MCP服务器选择
+  const choices = [];
+  
+  for (const server of availableServers.mcpServers) {
+    const statusIcon = server.connected ? '✓' : '✗';
+    const statusColor = server.connected ? chalk.green : chalk.red;
+    choices.push({
+      name: `${statusColor(statusIcon)} ${server.name} ${chalk.gray(`(${server.status})`)}`,
+      value: server.name,
+      checked: false, // 默认不选中任何MCP服务器
+      disabled: !server.connected ? '(未连接)' : false
+    });
   }
 
+  console.log(chalk.blue('\n🔧 默认工具（自动包含）:'), availableServers.defaultTools.join(', '));
+  
   const answer = await inquirer.prompt([{
     type: 'checkbox',
-    name: 'selectedTools',
-    message: `为 ${roleName} 选择可用工具:`,
-    choices: choices,
-    validate: (input) => {
-      // 确保包含所有默认工具
-      const hasAllDefaults = availableTools.defaultTools.every(tool => input.includes(tool));
-      if (!hasAllDefaults) {
-        return '必须包含所有默认工具';
-      }
-      return true;
-    }
+    name: 'selectedServers',
+    message: `为 ${roleName} 选择额外的MCP服务器（可选）:`,
+    choices: choices
   }]);
 
-  return answer.selectedTools;
+  // 处理选中的MCP服务器
+  const selectedMCPServers = answer.selectedServers || [];
+  
+  if (selectedMCPServers.length === 0) {
+    console.log(chalk.gray('   将继承所有可用工具（Claude Code默认行为）'));
+    return undefined; // Claude Code会继承所有工具
+  }
+  
+  // 如果选择了特定服务器，只包含默认工具+选中服务器的工具
+  const selectedTools = availableServers.defaultTools.slice();
+  for (const serverName of selectedMCPServers) {
+    // 添加该服务器的所有工具（使用通配符或具体工具名）
+    selectedTools.push(`mcp__${serverName}__*`);
+  }
+  
+  console.log(chalk.blue(`   已选择 ${selectedMCPServers.length} 个MCP服务器: ${selectedMCPServers.join(', ')}`));
+  return selectedTools;
 }
 
 // 获取PromptX角色
@@ -112,7 +144,7 @@ function showWelcome() {
 }
 
 // 显示角色选择菜单
-async function showRoleMenu(systemRoles, userRoles, availableTools) {
+async function showRoleMenu(systemRoles, userRoles, availableServers) {
   const choices = [
     ...systemRoles.map(role => ({
       name: `📦 ${role.id} ${chalk.gray('(系统角色)')}`,
@@ -166,8 +198,8 @@ async function showRoleMenu(systemRoles, userRoles, availableTools) {
 
   let selectedTools = [];
   if (typeAnswer.confirm) {
-    // 选择工具
-    selectedTools = await selectTools(roleAnswer.selectedRole.role, availableTools);
+    // 选择MCP服务器和工具
+    selectedTools = await selectMCPServers(roleAnswer.selectedRole.role, availableServers);
   }
 
   return {
@@ -199,27 +231,31 @@ async function installRole(selectedRole, installType, claudeDir, manager, select
   const results = {};
   
   try {
-    // 1. 从PromptX加载角色内容
-    console.log(chalk.cyan(`📖 加载 ${roleName} 角色定义...`));
-    const roleContent = await manager.loadResource(`@role://${roleName}`);
+    // 使用新的PromptXActionProcessor执行完整的action流程
+    const processor = new PromptXActionProcessor();
+    const mode = installType === 'agents' ? 'subagent' : 'command';
+    const processedContent = await processor.processRole(roleName, mode);
     
-    if (!roleContent || !roleContent.content) {
-      throw new Error(`无法加载角色 ${roleName} 的内容`);
-    }
-    
-    // 2. 根据安装目录创建相应文件
+    // 根据安装模式创建相应文件
     if (installType === 'agents') {
-      console.log(chalk.cyan(`🔧 生成 ${roleName} agent文件...`));
-      const subagentResult = await ClaudeCodeBuilder.createSubagent({
+      console.log(chalk.cyan(`🔧 生成 ${roleName} subagent文件...`));
+      const agentConfig = {
         name: roleName,
-        description: `基于PromptX ${roleName}角色的专业AI助手`,
-        content: roleContent.content,
-        tools: selectedTools,
+        description: `基于PromptX ${roleName}角色的专业AI助手 - 完整action实现`,
+        content: processedContent,
         targetDir: claudeDir
-      });
+      };
+      
+      // 设置工具配置 - 如果用户没有选择特定工具，则继承所有可用工具
+      if (selectedTools) {
+        agentConfig.tools = selectedTools;
+      }
+      // 如果没有选择特定工具，Claude Code会自动继承所有可用工具
+      
+      const subagentResult = await ClaudeCodeBuilder.createSubagent(agentConfig);
 
       if (!subagentResult.success) {
-        throw new Error(`创建Agent失败: ${subagentResult.error}`);
+        throw new Error(`创建Subagent失败: ${subagentResult.error}`);
       }
       results.agentFile = `${roleName}.md`;
       results.usage = `/subagent ${roleName}`;
@@ -227,20 +263,21 @@ async function installRole(selectedRole, installType, claudeDir, manager, select
 
     if (installType === 'commands') {
       console.log(chalk.cyan(`📋 生成 ${roleName} command文件...`));
-      const commandContent = `# ${roleName}
-基于PromptX ${roleName}角色的专业助手。
-
-${roleContent.content}
-
-现在开始处理用户需求。`;
-
-      const commandResult = await ClaudeCodeBuilder.createCommand({
+      
+      const commandConfig = {
         name: roleName,
-        description: `基于PromptX ${roleName}角色的专业助手`,
-        content: commandContent,
-        allowedTools: selectedTools,
+        description: `基于PromptX ${roleName}角色的专业助手 - 完整action实现`,
+        content: processedContent,
         targetDir: claudeDir
-      });
+      };
+      
+      // 设置工具配置 - 如果用户没有选择特定工具，则继承所有可用工具
+      if (selectedTools) {
+        commandConfig.allowedTools = selectedTools;
+      }
+      // 如果没有选择特定工具，Claude Code会自动继承所有可用工具
+
+      const commandResult = await ClaudeCodeBuilder.createCommand(commandConfig);
 
       if (!commandResult.success) {
         throw new Error(`创建Command失败: ${commandResult.error}`);
@@ -263,9 +300,21 @@ async function main() {
   try {
     showWelcome();
     
-    // 发现可用工具
-    console.log(chalk.cyan('🔍 正在发现可用工具...\n'));
-    const availableTools = await discoverAllTools();
+    // 检查是否跳过MCP发现（用于快速测试）
+    const skipMCP = process.argv.includes('--skip-mcp');
+    
+    let availableServers;
+    if (skipMCP) {
+      console.log(chalk.yellow('⚠️  跳过MCP发现（测试模式）'));
+      availableServers = {
+        defaultTools: ['Read', 'Write', 'Edit', 'Bash'],
+        mcpServers: []
+      };
+    } else {
+      // 发现MCP服务器
+      console.log(chalk.cyan('🔍 正在发现MCP服务器...\n'));
+      availableServers = await discoverMCPServers();
+    }
     
     // 加载角色
     console.log(chalk.cyan('🔍 正在从PromptX系统加载角色...\n'));
@@ -275,7 +324,7 @@ async function main() {
     console.log(`📊 发现 ${chalk.bold(systemRoles.length)} 个系统角色，${chalk.bold(userRoles.length)} 个用户角色\n`);
     
     // 显示角色选择
-    const { selectedRole, installType, confirm, selectedTools } = await showRoleMenu(systemRoles, userRoles, availableTools);
+    const { selectedRole, installType, confirm, selectedTools } = await showRoleMenu(systemRoles, userRoles, availableServers);
     
     if (!confirm) {
       console.log(chalk.yellow('\n👋 安装已取消'));
@@ -314,6 +363,9 @@ async function main() {
 }
 
 // 运行主程序
-if (import.meta.url === `file://${process.argv[1]}`) {
-  main();
+if (import.meta.url === new URL(process.argv[1], 'file:').href) {
+  main().catch(error => {
+    console.error(chalk.red('❌ 程序异常:'), error.message);
+    process.exit(1);
+  });
 }

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "px2cc",
-  "version": "1.1.0",
-  "description": "CLI tool to quickly install PromptX roles into Claude Code as agents or commands",
+  "version": "2.0.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",
   "bin": {
@@ -22,6 +22,7 @@
   "files": [
     "cli.js",
     "bin.js",
+    "src/",
     "README.md",
     "package.json"
   ],

package/src/PromptXActionProcessor.js

@@ -0,0 +1,490 @@
+/**
+ * PromptXActionProcessor - 实现完整的PromptX Action流程
+ * 
+ * 替代简单的parsePromptXRole函数，实现：
+ * 1. 角色加载器 (RoleLoader)
+ * 2. 依赖分析器 (DependencyAnalyzer)  
+ * 3. 认知网络加载器 (CognitionLoader)
+ * 4. 三层组装器 (LayerAssembler)
+ */
+
+import { resource } from '@promptx/core';
+import fs from 'fs/promises';
+import path from 'path';
+import os from 'os';
+import chalk from 'chalk';
+
+/**
+ * 角色加载器 - 替代PromptX的ResourceManager
+ */
+class RoleLoader {
+  constructor(resourceManager) {
+    this.resourceManager = resourceManager;
+  }
+
+  /**
+   * 加载角色定义
+   * @param {string} roleId - 角色ID
+   * @returns {Object} 角色信息
+   */
+  async loadRole(roleId) {
+    console.log(chalk.cyan(`📖 加载角色定义: ${roleId}`));
+    
+    try {
+      // 确保ResourceManager已初始化
+      if (!this.resourceManager.initialized) {
+        await this.resourceManager.initializeWithNewArchitecture();
+      }
+      
+      // 加载角色资源
+      const result = await this.resourceManager.loadResource(`@role://${roleId}`);
+      
+      if (!result || !result.success || !result.content) {
+        throw new Error(`无法加载角色 ${roleId} 的内容`);
+      }
+      
+      // 解析DPML内容
+      const parsedContent = this.parseDPMLContent(result.content);
+      
+      return {
+        id: roleId,
+        raw: result.content,
+        sections: parsedContent,
+        metadata: result.metadata || {}
+      };
+      
+    } catch (error) {
+      console.error(chalk.red(`❌ 角色加载失败: ${error.message}`));
+      throw error;
+    }
+  }
+
+  /**
+   * 解析DPML角色文档
+   * @param {string} content - 原始内容
+   * @returns {Object} 解析后的sections
+   */
+  parseDPMLContent(content) {
+    const sections = {};
+    
+    // 解析 <role> 标签
+    const roleMatch = content.match(/<role>([\s\S]*?)<\/role>/);
+    if (roleMatch) {
+      const roleContent = roleMatch[1];
+      
+      // 提取各个部分
+      sections.personality = this.extractSection(roleContent, 'personality');
+      sections.principle = this.extractSection(roleContent, 'principle');
+      sections.knowledge = this.extractSection(roleContent, 'knowledge');
+    }
+    
+    return sections;
+  }
+
+  /**
+   * 提取XML标签内容
+   * @param {string} content - 内容
+   * @param {string} tagName - 标签名
+   * @returns {string|null} 提取的内容
+   */
+  extractSection(content, tagName) {
+    const regex = new RegExp(`<${tagName}>([\\s\\S]*?)<\\/${tagName}>`, 'i');
+    const match = content.match(regex);
+    return match ? match[1].trim() : null;
+  }
+}
+
+/**
+ * 依赖分析器 - 分析和加载资源依赖
+ */
+class DependencyAnalyzer {
+  constructor(resourceManager) {
+    this.resourceManager = resourceManager;
+  }
+
+  /**
+   * 分析角色依赖
+   * @param {Object} roleInfo - 角色信息
+   * @returns {Object} 依赖资源
+   */
+  async analyzeDependencies(roleInfo) {
+    console.log(chalk.cyan(`🔍 分析资源依赖...`));
+    
+    const dependencies = {
+      thoughts: [],
+      executions: [],
+      knowledges: []
+    };
+
+    if (!roleInfo.sections) {
+      return dependencies;
+    }
+
+    // 收集所有资源引用
+    const allRefs = this.extractResourceReferences(roleInfo.sections);
+    
+    console.log(chalk.gray(`   发现 ${allRefs.length} 个资源引用`));
+
+    // 并发加载所有依赖
+    const loadPromises = allRefs.map(ref => this.loadDependency(ref));
+    const results = await Promise.allSettled(loadPromises);
+
+    // 分类处理结果
+    results.forEach((result, index) => {
+      if (result.status === 'fulfilled' && result.value) {
+        const ref = allRefs[index];
+        const content = result.value;
+        
+        switch (ref.protocol) {
+          case 'thought':
+            dependencies.thoughts.push({ id: ref.resource, content });
+            break;
+          case 'execution':
+            dependencies.executions.push({ id: ref.resource, content });
+            break;
+          case 'knowledge':
+            dependencies.knowledges.push({ id: ref.resource, content });
+            break;
+        }
+      }
+    });
+
+    console.log(chalk.green(`✅ 依赖分析完成: thoughts=${dependencies.thoughts.length}, executions=${dependencies.executions.length}, knowledges=${dependencies.knowledges.length}`));
+    
+    return dependencies;
+  }
+
+  /**
+   * 提取资源引用
+   * @param {Object} sections - 角色sections
+   * @returns {Array} 引用列表
+   */
+  extractResourceReferences(sections) {
+    const refs = [];
+    
+    const extractFromText = (text) => {
+      if (!text) return [];
+      // 匹配 @protocol://resource 格式
+      const matches = text.matchAll(/@([^:]+):\/\/([^\\s\\>\\<]+)/g);
+      return Array.from(matches).map(match => ({
+        protocol: match[1],
+        resource: match[2]
+      }));
+    };
+
+    // 从所有sections中提取引用
+    Object.values(sections).forEach(section => {
+      refs.push(...extractFromText(section));
+    });
+
+    return refs;
+  }
+
+  /**
+   * 加载单个依赖
+   * @param {Object} ref - 引用对象
+   * @returns {Promise<string>} 内容
+   */
+  async loadDependency(ref) {
+    try {
+      const resourceUrl = `@${ref.protocol}://${ref.resource}`;
+      const result = await this.resourceManager.loadResource(resourceUrl);
+      
+      if (result && result.success && result.content) {
+        return result.content;
+      }
+      
+      console.warn(chalk.yellow(`⚠️  无法加载依赖: ${resourceUrl}`));
+      return null;
+    } catch (error) {
+      console.warn(chalk.yellow(`⚠️  依赖加载失败: @${ref.protocol}://${ref.resource} - ${error.message}`));
+      return null;
+    }
+  }
+}
+
+/**
+ * 认知网络加载器 - 加载PromptX认知数据
+ */
+class CognitionLoader {
+  constructor() {
+    this.basePath = path.join(os.homedir(), '.promptx', 'cognition');
+  }
+
+  /**
+   * 加载认知网络
+   * @param {string} roleId - 角色ID
+   * @returns {Object} Mind对象和可视化
+   */
+  async loadCognitionNetwork(roleId) {
+    console.log(chalk.cyan(`🧠 加载认知网络: ${roleId}`));
+    
+    try {
+      const networkFilePath = path.join(this.basePath, roleId, 'network.json');
+      
+      // 检查文件是否存在
+      try {
+        await fs.access(networkFilePath);
+      } catch (error) {
+        console.log(chalk.gray(`   未找到认知网络文件: ${roleId}`));
+        return {
+          mind: null,
+          mindmap: null,
+          hasNetwork: false
+        };
+      }
+
+      // 读取网络数据
+      const networkData = JSON.parse(await fs.readFile(networkFilePath, 'utf8'));
+      
+      // 生成mindmap
+      const mindmap = this.generateMindmap(networkData);
+      
+      // 构建Mind对象
+      const mind = this.buildMindObject(networkData);
+      
+      console.log(chalk.green(`✅ 认知网络加载成功: ${mind.nodeCount} 个节点, ${mind.connectionCount} 个连接`));
+      
+      return {
+        mind,
+        mindmap,
+        hasNetwork: true,
+        networkData
+      };
+      
+    } catch (error) {
+      console.warn(chalk.yellow(`⚠️  认知网络加载失败: ${error.message}`));
+      return {
+        mind: null,
+        mindmap: null,
+        hasNetwork: false
+      };
+    }
+  }
+
+  /**
+   * 生成Mermaid mindmap
+   * @param {Object} networkData - 网络数据
+   * @returns {string} mindmap代码
+   */
+  generateMindmap(networkData) {
+    if (!networkData.cues || Object.keys(networkData.cues).length === 0) {
+      return 'mindmap\n  root((暂无认知数据))';
+    }
+
+    // 找到权重最高的概念作为根节点
+    const cues = Object.entries(networkData.cues);
+    const rootCue = 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;
+    }, {});
+
+    let mindmap = 'mindmap\n';
+    mindmap += `  root((${rootCue.word || '认知中心'}))\n`;
+
+    // 添加相关概念（取权重前10的连接）
+    if (rootCue.word && networkData.cues[rootCue.word]?.connections) {
+      const connections = networkData.cues[rootCue.word].connections
+        .sort((a, b) => (b.weight || 0) - (a.weight || 0))
+        .slice(0, 10);
+
+      connections.forEach(conn => {
+        if (conn.target) {
+          mindmap += `    ${conn.target}\n`;
+        }
+      });
+    }
+
+    return mindmap;
+  }
+
+  /**
+   * 构建Mind对象
+   * @param {Object} networkData - 网络数据
+   * @returns {Object} Mind对象
+   */
+  buildMindObject(networkData) {
+    const cues = networkData.cues || {};
+    const nodeCount = Object.keys(cues).length;
+    let connectionCount = 0;
+
+    Object.values(cues).forEach(cue => {
+      connectionCount += (cue.connections || []).length;
+    });
+
+    return {
+      nodeCount,
+      connectionCount,
+      activatedCues: Object.keys(cues),
+      timestamp: networkData.timestamp,
+      version: networkData.version
+    };
+  }
+}
+
+/**
+ * 三层组装器 - 组装最终输出内容
+ */
+class LayerAssembler {
+  /**
+   * 组装完整内容
+   * @param {Object} roleInfo - 角色信息
+   * @param {Object} dependencies - 依赖资源
+   * @param {Object} cognitionData - 认知数据
+   * @param {string} mode - 模式 (command|subagent)
+   * @returns {string} 组装后的内容
+   */
+  assembleContent(roleInfo, dependencies, cognitionData, mode = 'command') {
+    const parts = [];
+
+    // 标题部分
+    parts.push(`# 🧠 [Consciousness Prime] ${roleInfo.id}${mode === 'subagent' ? '专业助手' : '角色已激活'}`);
+    parts.push('');
+
+    // CognitionLayer - 认知网络可视化
+    if (cognitionData.hasNetwork && cognitionData.mindmap) {
+      parts.push('## 💭 Hippocampus网络');
+      parts.push('```mermaid');
+      parts.push(cognitionData.mindmap);
+      parts.push('```');
+      parts.push('');
+      
+      if (cognitionData.mind) {
+        parts.push(`**网络状态**: ${cognitionData.mind.nodeCount} 个概念节点，${cognitionData.mind.connectionCount} 个关联连接`);
+        parts.push('');
+      }
+    }
+
+    // RoleLayer - 角色定义
+    if (roleInfo.sections.personality) {
+      parts.push('## 🎭 角色人格');
+      parts.push(this.cleanContent(roleInfo.sections.personality));
+      parts.push('');
+    }
+
+    if (roleInfo.sections.principle) {
+      parts.push('## 🔧 工作原则');
+      parts.push(this.cleanContent(roleInfo.sections.principle));
+      parts.push('');
+    }
+
+    if (roleInfo.sections.knowledge) {
+      parts.push('## 📚 专业知识');
+      parts.push(this.cleanContent(roleInfo.sections.knowledge));
+      parts.push('');
+    }
+
+    // 依赖资源
+    if (dependencies.thoughts.length > 0) {
+      parts.push('## 💡 思维模式');
+      dependencies.thoughts.forEach(thought => {
+        parts.push(`### ${thought.id}`);
+        parts.push(this.cleanContent(thought.content));
+        parts.push('');
+      });
+    }
+
+    if (dependencies.executions.length > 0) {
+      parts.push('## ⚡ 执行技能');
+      dependencies.executions.forEach(execution => {
+        parts.push(`### ${execution.id}`);
+        parts.push(this.cleanContent(execution.content));
+        parts.push('');
+      });
+    }
+
+    // StateLayer - 状态信息
+    parts.push('---');
+    parts.push('');
+    
+    if (mode === 'command') {
+      parts.push(`🎉 ${roleInfo.id}角色激活完成！我现在以该角色身份为你服务。`);
+    } else {
+      parts.push('## 🤖 助手说明');
+      parts.push(`我是基于PromptX ${roleInfo.id}角色的专业AI助手。我会：`);
+      parts.push(`- 始终保持${roleInfo.id}的专业身份和思维模式`);
+      parts.push('- 利用完整的PromptX工具生态提供专业服务');
+      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('');
+    
+    if (mode === 'command') {
+      parts.push('现在开始处理用户需求。');
+    }
+
+    return parts.join('\n');
+  }
+
+  /**
+   * 清理内容格式
+   * @param {string} content - 原始内容
+   * @returns {string} 清理后的内容
+   */
+  cleanContent(content) {
+    if (!content) return '';
+    
+    return content
+      // 移除PromptX资源引用标签（但保留引用内容的展开结果）
+      .replace(/<reference[^>]*>/g, '')
+      .replace(/<\/reference>/g, '')
+      // 清理多余空行
+      .replace(/\n\s*\n\s*\n/g, '\n\n')
+      // 移除开头结尾空白
+      .trim();
+  }
+}
+
+/**
+ * PromptX Action处理器主类
+ */
+export class PromptXActionProcessor {
+  constructor() {
+    this.resourceManager = resource.getGlobalResourceManager();
+    this.roleLoader = new RoleLoader(this.resourceManager);
+    this.dependencyAnalyzer = new DependencyAnalyzer(this.resourceManager);
+    this.cognitionLoader = new CognitionLoader();
+    this.layerAssembler = new LayerAssembler();
+  }
+
+  /**
+   * 执行完整的PromptX Action流程
+   * @param {string} roleId - 角色ID
+   * @param {string} mode - 模式 (command|subagent)
+   * @returns {string} 处理后的内容
+   */
+  async processRole(roleId, mode = 'command') {
+    try {
+      console.log(chalk.blue(`\n🎭 开始执行 ${roleId} 的 PromptX Action 流程 (${mode} 模式)`));
+      
+      // 1. 加载角色定义
+      const roleInfo = await this.roleLoader.loadRole(roleId);
+      
+      // 2. 分析依赖资源
+      const dependencies = await this.dependencyAnalyzer.analyzeDependencies(roleInfo);
+      
+      // 3. 加载认知网络
+      const cognitionData = await this.cognitionLoader.loadCognitionNetwork(roleId);
+      
+      // 4. 三层组装
+      const content = this.layerAssembler.assembleContent(roleInfo, dependencies, cognitionData, mode);
+      
+      console.log(chalk.green(`✅ PromptX Action 流程完成！`));
+      
+      return content;
+      
+    } catch (error) {
+      console.error(chalk.red(`❌ PromptX Action 流程失败: ${error.message}`));
+      throw error;
+    }
+  }
+}