px2cc 1.1.1 → 2.0.1

package/cli.js

@@ -7,12 +7,20 @@
 
 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';
 
+// 注意：原有的parsePromptXRole函数已被PromptXActionProcessor替代
+// 新的处理器实现完整的PromptX Action流程，包括：
+// 1. RoleLoader - 加载角色定义  
+// 2. DependencyAnalyzer - 分析资源依赖
+// 3. CognitionLoader - 加载认知网络
+// 4. LayerAssembler - 三层内容组装
+
 // 发现MCP服务器
 async function discoverMCPServers() {
   const servers = {
@@ -21,10 +29,11 @@ async function discoverMCPServers() {
   };
 
   try {
-    // 使用claude mcp list获取所有MCP服务器
+    console.log(chalk.gray('   检查MCP服务器状态（可能需要一些时间）...'));
+    // 使用claude mcp list获取所有MCP服务器（增加超时时间）
     const mcpOutput = execSync('claude mcp list', { 
       encoding: 'utf8',
-      timeout: 10000 
+      timeout: 30000  // 增加到30秒
     });
     
     // 解析输出，提取服务器信息
@@ -48,8 +57,14 @@ async function discoverMCPServers() {
     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 servers;
@@ -57,62 +72,51 @@ async function discoverMCPServers() {
 
 // 显示MCP服务器选择界面
 async function selectMCPServers(roleName, availableServers) {
-  const choices = [
-    new inquirer.Separator(chalk.green('🔧 默认工具（已包含）')),
-    ...availableServers.defaultTools.map(tool => ({
-      name: `✓ ${tool}`,
-      value: tool,
-      checked: true,
-      disabled: '(必需)'
-    }))
-  ];
-
-  if (availableServers.mcpServers.length > 0) {
-    choices.push(
-      new inquirer.Separator(chalk.blue('🛠️  MCP服务器（选择后将获得该服务器的所有工具权限）'))
-    );
+  // 如果没有MCP服务器，直接返回undefined（继承所有工具）
+  if (availableServers.mcpServers.length === 0) {
+    console.log(chalk.gray('   没有发现MCP服务器，将继承所有可用工具'));
+    return undefined;
+  }
 
-    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: server.name.includes('promptx'), // PromptX服务器默认选中
-        disabled: !server.connected ? '(未连接)' : false
-      });
-    }
+  // 只显示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: 'selectedItems',
-    message: `为 ${roleName} 选择工具和服务器:`,
-    choices: choices,
-    validate: (input) => {
-      // 确保包含所有默认工具
-      const hasAllDefaults = availableServers.defaultTools.every(tool => input.includes(tool));
-      if (!hasAllDefaults) {
-        return '必须包含所有默认工具';
-      }
-      return true;
-    }
+    name: 'selectedServers',
+    message: `为 ${roleName} 选择额外的MCP服务器（可选）:`,
+    choices: choices
   }]);
 
-  // 分离默认工具和选中的服务器
-  const selectedTools = availableServers.defaultTools.slice(); // 始终包含默认工具
-  const selectedServers = [];
+  // 处理选中的MCP服务器
+  const selectedMCPServers = answer.selectedServers || [];
   
-  for (const item of answer.selectedItems) {
-    if (availableServers.defaultTools.includes(item)) {
-      continue; // 默认工具已经包含
-    } else {
-      selectedServers.push(item);
-      // 为选中的服务器添加通配符权限
-      selectedTools.push(`mcp__${item}__*`);
-    }
+  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;
 }
 
@@ -227,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}`;
@@ -255,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}`);
@@ -291,9 +300,21 @@ async function main() {
   try {
     showWelcome();
     
-    // 发现MCP服务器
-    console.log(chalk.cyan('🔍 正在发现MCP服务器...\n'));
-    const availableServers = await discoverMCPServers();
+    // 检查是否跳过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'));
@@ -342,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.1",
-  "description": "CLI tool to quickly install PromptX roles into Claude Code as agents or commands",
+  "version": "2.0.1",
+  "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,473 @@
+/**
+ * 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} 认知网络状态信息
+   */
+  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 {
+          hasNetwork: false,
+          networkPath: networkFilePath,
+          status: 'not_found'
+        };
+      }
+
+      // 读取网络数据基本信息（不生成静态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
+    };
+  }
+}
+
+/**
+ * 三层组装器 - 组装最终输出内容
+ */
+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 - 动态认知网络状态
+    parts.push('## 💭 Hippocampus网络');
+    
+    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 `recall` 工具查看当前激活的记忆网络');
+      parts.push('- 使用PromptX `remember` 工具将新经验编织到认知网络中');
+      parts.push('- 每次交互都会调整概念间的关联强度');
+      
+    } else {
+      parts.push('🌱 **初始状态**: 认知网络尚未建立');
+      parts.push('- 开始使用PromptX工具与该角色互动');  
+      parts.push('- 系统会自动建立和完善认知网络');
+      parts.push('- 随着经验积累，网络会变得越来越丰富');
+    }
+    
+    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;
+    }
+  }
+}