px2cc 1.0.7

package/README.md

@@ -0,0 +1,93 @@
+# Px2CC
+
+**PromptX to Claude Code** - 一个简洁的CLI工具，快速将PromptX角色安装到Claude Code中。
+
+## 功能特性
+
+- 🚀 快速安装PromptX角色到Claude Code
+- 🎭 动态获取所有可用的系统角色和用户角色  
+- 🤖 支持安装为Claude Code Subagents (通过自然语言提及调用)
+- ⚙️ 支持安装为Claude Code Commands (通过 `/command` 调用)
+- 🎨 友好的交互式界面
+- 📁 自动创建和管理 `.claude` 目录结构
+
+## 安装
+
+### 方式一：全局安装
+```bash
+npm install -g px2cc
+px2cc
+```
+
+### 方式二：npx 直接运行（推荐）
+```bash
+npx px2cc
+```
+
+无需安装，一条命令直接运行！
+
+然后按照交互式提示：
+1. 选择要安装的PromptX角色
+2. 选择安装类型（Agent 或 Command）
+3. 确认安装
+
+## 安装类型
+
+### Subagent 模式
+- 安装到 `.claude/agents/` 目录
+- 通过自然语言提及调用: `Use the <角色名>-agent subagent to [任务]`
+
+### Command 模式  
+- 安装到 `.claude/commands/` 目录
+- 通过 `/<角色名>` 在Claude Code中调用
+
+## 角色类型
+
+- **系统角色** 📦 - PromptX内置的专业角色
+- **用户角色** 👤 - 用户自定义创建的角色
+
+## 系统要求
+
+- Node.js >= 16.0.0
+- Claude Code
+- PromptX账户（包含可用角色）
+
+## 示例
+
+```bash
+$ px2cc
+
+🚀 PromptX CLI - Claude Code 角色安装器
+   快速将PromptX角色集成到Claude Code中
+
+🔍 正在从PromptX系统加载角色...
+
+✅ 加载完成!
+📊 发现 5 个系统角色，9 个用户角色
+
+? 请选择要安装的PromptX角色: assistant (系统角色)
+? 安装 assistant 为: Agent - 通过提及"assistant-agent subagent"调用
+? 确认安装到Claude Code? Yes
+
+📖 加载 assistant 角色定义...
+🔧 生成 assistant agent文件...
+
+✅ 角色安装完成！
+
+📄 生成的文件:
+   - .claude/agents/assistant-agent.md
+
+🎉 现在你可以在Claude Code中使用:
+   Use the assistant-agent subagent to help with my task
+   Have the assistant-agent subagent review my code
+
+💡 提示: 重启Claude Code以确保新配置生效
+```
+
+## 许可证
+
+MIT
+
+## 作者
+
+PromptX Bridge Team

package/bin.js

@@ -0,0 +1,17 @@
+#!/usr/bin/env node
+
+/**
+ * Px2CC 启动器 - 通用版本
+ * 直接导入cli.js，跨平台兼容
+ */
+
+// 设置环境变量来抑制PromptX内部日志
+process.env.LOG_LEVEL = 'silent';
+
+// 修改process.argv让cli.js以为自己是主模块
+import { fileURLToPath } from 'url';
+const cliJsPath = fileURLToPath(new URL('cli.js', import.meta.url));
+process.argv[1] = cliJsPath;
+
+// 导入并执行cli.js
+import('./cli.js');

package/cli.js

@@ -0,0 +1,382 @@
+#!/usr/bin/env node
+
+/**
+ * PromptX CLI - 使用 @promptx/core 动态获取角色信息  
+ * 注意：此文件应通过 promptx-cli wrapper 脚本运行以过滤内部日志
+ */
+
+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 = {
+    defaultTools: ['Read', 'Write', 'Edit', 'Bash'],
+    mcpServers: []
+  };
+
+  try {
+    console.log(chalk.gray('   检查MCP服务器状态（可能需要一些时间）...'));
+    // 使用claude mcp list获取所有MCP服务器（增加超时时间到60秒）
+    const mcpOutput = execSync('claude mcp list', { 
+      encoding: 'utf8',
+      timeout: 60000,  // 增加到60秒
+      stdio: 'pipe'    // 确保错误输出被捕获
+    });
+    
+    // 解析输出，提取服务器信息
+    const lines = mcpOutput.split('\n');
+    
+    for (const line of lines) {
+      const trimmedLine = line.trim();
+      // 匹配服务器名称（格式：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(`✅ 发现 ${servers.mcpServers.length} 个MCP服务器`));
+    
+  } catch (error) {
+    if (error.code === 'ETIMEDOUT') {
+      console.error(chalk.yellow('⚠️  MCP服务器检查超时，将继续安装（只使用默认工具）'));
+      console.error(chalk.gray('   如需使用MCP工具，请检查网络连接或使用 --skip-mcp 参数'));
+    } else {
+      console.error(chalk.yellow('⚠️  无法获取MCP服务器列表，将继续安装（只使用默认工具）'));
+      console.error(chalk.gray(`   原因: ${error.message}`));
+    }
+    // 不再抛出错误，而是继续执行，不使用MCP服务器
+    console.log(chalk.gray('   将继承所有可用工具（Claude Code默认行为）'));
+    return servers;
+  }
+
+  return servers;
+}
+
+// 显示MCP服务器选择界面
+async function selectMCPServers(roleName, availableServers) {
+  // 如果没有MCP服务器，直接返回undefined（继承所有工具）
+  if (availableServers.mcpServers.length === 0) {
+    console.log(chalk.gray('   没有发现MCP服务器，将继承所有可用工具'));
+    return undefined;
+  }
+
+  // 只显示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: 'selectedServers',
+    message: `为 ${roleName} 选择额外的MCP服务器（可选）:`,
+    choices: choices
+  }]);
+
+  // 处理选中的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角色
+async function getAllRoles() {
+  try {
+    const manager = resource.getGlobalResourceManager();
+    await manager.initializeWithNewArchitecture();
+    
+    const roleResources = manager.registryData.getResourcesByProtocol('role');
+    const systemRoles = roleResources.filter(r => r.source === 'package');
+    const userRoles = roleResources.filter(r => r.source === 'user');
+
+    return { systemRoles, userRoles, manager };
+  } catch (error) {
+    throw new Error(`获取PromptX角色失败: ${error.message}`);
+  }
+}
+
+// 显示欢迎界面
+function showWelcome() {
+  console.clear();
+  console.log(chalk.blue.bold('🚀 PromptX CLI - Claude Code 角色安装器'));
+  console.log(chalk.gray('   快速将PromptX角色集成到Claude Code中\n'));
+}
+
+// 显示角色选择菜单
+async function showRoleMenu(systemRoles, userRoles, availableServers) {
+  const choices = [
+    ...systemRoles.map(role => ({
+      name: `📦 ${role.id} ${chalk.gray('(系统角色)')}`,
+      value: { role: role.id, source: 'package' },
+      short: role.id
+    })),
+    new inquirer.Separator(chalk.gray('─── 用户角色 ───')),
+    ...userRoles.map(role => ({
+      name: `👤 ${role.id} ${chalk.gray('(用户角色)')}`,
+      value: { role: role.id, source: 'user' },
+      short: role.id
+    }))
+  ];
+
+  const roleAnswer = await inquirer.prompt([
+    {
+      type: 'list',
+      name: 'selectedRole',
+      message: '请选择要安装的PromptX角色:',
+      choices: choices,
+      pageSize: 15
+    }
+  ]);
+
+  // 选择安装类型
+  const typeAnswer = await inquirer.prompt([
+    {
+      type: 'list',
+      name: 'installType',
+      message: `安装 ${roleAnswer.selectedRole.role} 为:`,
+      choices: [
+        {
+          name: `🤖 Agent - 通过提及"${roleAnswer.selectedRole.role}-agent subagent"调用`,
+          value: 'agents',
+          short: 'Agent'
+        },
+        {
+          name: `⚙️  Command - 通过 /${roleAnswer.selectedRole.role} 调用`,
+          value: 'commands', 
+          short: 'Command'
+        }
+      ]
+    },
+    {
+      type: 'confirm',
+      name: 'confirm',
+      message: '确认安装到Claude Code?',
+      default: true
+    }
+  ]);
+
+  let selectedTools = [];
+  if (typeAnswer.confirm) {
+    // 选择MCP服务器和工具
+    selectedTools = await selectMCPServers(roleAnswer.selectedRole.role, availableServers);
+  }
+
+  return {
+    selectedRole: roleAnswer.selectedRole,
+    installType: typeAnswer.installType,
+    confirm: typeAnswer.confirm,
+    selectedTools: selectedTools
+  };
+}
+
+// 检查当前目录
+function checkDirectory() {
+  const currentDir = process.cwd();
+  const claudeDir = path.join(currentDir, '.claude');
+  
+  if (!fs.existsSync(claudeDir)) {
+    console.log(chalk.yellow('📁 创建 .claude 目录...'));
+    fs.mkdirSync(claudeDir, { recursive: true });
+    fs.mkdirSync(path.join(claudeDir, 'agents'), { recursive: true });
+    fs.mkdirSync(path.join(claudeDir, 'commands'), { recursive: true });
+  }
+  
+  return claudeDir;
+}
+
+// 安装角色
+async function installRole(selectedRole, installType, claudeDir, manager, selectedTools) {
+  const roleName = selectedRole.role;
+  const results = {};
+  
+  try {
+    // 使用新的PromptXActionProcessor执行完整的action流程
+    const processor = new PromptXActionProcessor();
+    const mode = installType === 'agents' ? 'subagent' : 'command';
+    const processedContent = await processor.processRole(roleName, mode);
+    
+    // 根据安装模式创建相应文件
+    if (installType === 'agents') {
+      console.log(chalk.cyan(`🔧 生成 ${roleName} subagent文件...`));
+      const agentConfig = {
+        name: `${roleName}-agent`,
+        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(`创建Subagent失败: ${subagentResult.error}`);
+      }
+      results.agentFile = `${roleName}-agent.md`;
+      results.usage = `Use the ${roleName}-agent subagent to [任务描述]`;
+    }
+
+    if (installType === 'commands') {
+      console.log(chalk.cyan(`📋 生成 ${roleName} command文件...`));
+      
+      const commandConfig = {
+        name: roleName,
+        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}`);
+      }
+      results.commandFile = `${roleName}.md`;
+      results.usage = `/${roleName}`;
+    }
+
+    results.roleName = roleName;
+    results.installType = installType;
+    return results;
+    
+  } catch (error) {
+    throw new Error(`安装角色失败: ${error.message}`);
+  }
+}
+
+// 主程序入口
+async function main() {
+  try {
+    showWelcome();
+    
+    // 检查是否跳过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'));
+      try {
+        availableServers = await discoverMCPServers();
+      } catch (error) {
+        console.error(chalk.yellow('⚠️  MCP服务器发现失败，使用默认配置'));
+        availableServers = {
+          defaultTools: ['Read', 'Write', 'Edit', 'Bash'],
+          mcpServers: []
+        };
+      }
+    }
+    
+    // 加载角色
+    console.log(chalk.cyan('🔍 正在从PromptX系统加载角色...\n'));
+    const { systemRoles, userRoles, manager } = await getAllRoles();
+    
+    console.log(chalk.green('✅ 加载完成!'));
+    console.log(`📊 发现 ${chalk.bold(systemRoles.length)} 个系统角色，${chalk.bold(userRoles.length)} 个用户角色\n`);
+    
+    // 显示角色选择
+    const { selectedRole, installType, confirm, selectedTools } = await showRoleMenu(systemRoles, userRoles, availableServers);
+    
+    if (!confirm) {
+      console.log(chalk.yellow('\n👋 安装已取消'));
+      return;
+    }
+
+    // 检查目录
+    const claudeDir = checkDirectory();
+    
+    console.log(chalk.blue(`\n🎭 开始安装角色: ${selectedRole.role} (${installType})`));
+    
+    // 安装角色
+    const result = await installRole(selectedRole, installType, claudeDir, manager, selectedTools);
+    
+    console.log(chalk.green.bold('\n✅ 角色安装完成！'));
+    console.log(`\n📄 生成的文件:`);
+    
+    if (result.agentFile) {
+      console.log(`   - ${chalk.gray('.claude/agents/')}${chalk.white(result.agentFile)}`);
+    }
+    if (result.commandFile) {
+      console.log(`   - ${chalk.gray('.claude/commands/')}${chalk.white(result.commandFile)}`);
+    }
+    
+    console.log(chalk.magenta(`\n🎉 现在你可以在Claude Code中使用:`));
+    if (result.usage) {
+      console.log(chalk.yellow(`   ${result.usage}`));
+    }
+    
+    console.log(chalk.gray(`\n💡 提示: 重启Claude Code以确保新配置生效`));
+    
+  } catch (error) {
+    console.error(chalk.red('❌ 安装失败:'), error.message);
+    process.exit(1);
+  }
+}
+
+// 运行主程序
+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

@@ -0,0 +1,51 @@
+{
+  "name": "px2cc",
+  "version": "1.0.7",
+  "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": {
+    "px2cc": "./bin.js"
+  },
+  "scripts": {
+    "start": "./promptx-cli",
+    "test": "node test.js"
+  },
+  "dependencies": {
+    "@promptx/core": "^1.13.0",
+    "@promptx/logger": "^1.13.0",
+    "@promptx/resource": "^1.13.0",
+    "claude-code-builder": "^1.0.0",
+    "inquirer": "^9.2.0",
+    "chalk": "^5.3.0"
+  },
+  "files": [
+    "cli.js",
+    "bin.js",
+    "src/",
+    "README.md",
+    "package.json"
+  ],
+  "keywords": [
+    "promptx",
+    "claude-code",
+    "cli",
+    "ai",
+    "roles",
+    "agents",
+    "commands"
+  ],
+  "author": "PromptX Bridge Team",
+  "license": "MIT",
+  "engines": {
+    "node": ">=16.0.0"
+  },
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/promptx/px2cc"
+  },
+  "homepage": "https://github.com/promptx/px2cc#readme",
+  "bugs": {
+    "url": "https://github.com/promptx/px2cc/issues"
+  }
+}

package/src/PromptXActionProcessor.js

@@ -0,0 +1,432 @@
+/**
+ * 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 或 @protocol://resource 格式
+      const matches = text.matchAll(/@!?([^:]+):\/\/([^\s\>\<\n]+)/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 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
+        };
+      }
+      
+    } catch (error) {
+      console.warn(chalk.yellow(`⚠️  认知网络检查失败: ${error.message}`));
+      return {
+        hasNetwork: false,
+        networkPath: null,
+        error: error.message
+      };
+    }
+  }
+
+}
+
+/**
+ * 三层组装器 - 组装最终输出内容
+ */
+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 - PromptX认知增强
+    parts.push('## 💭 PromptX认知增强');
+    
+    if (cognitionData.hasNetwork) {
+      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('💡 **说明**: 认知网络包含该角色的历史使用经验，通过recall工具动态激活');
+      
+    } else {
+      parts.push('🌱 **状态**: 该角色尚未建立经验网络');
+      parts.push('');
+      parts.push('🚀 **开始使用**:');
+      parts.push('- 安装并配置PromptX MCP服务器');
+      parts.push(`- 使用 \`recall ${roleInfo.id}\` 开始建立认知网络`);
+      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('---');
+    parts.push('');
+    parts.push('💡 **可用的PromptX工具生态**：');
+    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') {
+      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, '')
+      // 移除@!protocol://resource引用行（因为依赖内容会单独展示）
+      .replace(/\s*@!?[^:]+:\/\/[^\s\>\<\n]+\s*/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.checkNetworkExists(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;
+    }
+  }
+}