px2cc 2.0.0 → 2.0.1

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "px2cc",
-  "version": "2.0.0",
+  "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",

package/src/PromptXActionProcessor.js

@@ -212,12 +212,12 @@ class CognitionLoader {
   }
 
   /**
-   * 加载认知网络
+   * 检查认知网络状态
    * @param {string} roleId - 角色ID
-   * @returns {Object} Mind对象和可视化
+   * @returns {Object} 认知网络状态信息
    */
   async loadCognitionNetwork(roleId) {
-    console.log(chalk.cyan(`🧠 加载认知网络: ${roleId}`));
+    console.log(chalk.cyan(`🧠 检查认知网络状态: ${roleId}`));
     
     try {
       const networkFilePath = path.join(this.basePath, roleId, 'network.json');
@@ -228,96 +228,64 @@ class CognitionLoader {
       } catch (error) {
         console.log(chalk.gray(`   未找到认知网络文件: ${roleId}`));
         return {
-          mind: null,
-          mindmap: null,
-          hasNetwork: false
+          hasNetwork: false,
+          networkPath: networkFilePath,
+          status: 'not_found'
         };
       }
 
-      // 读取网络数据
+      // 读取网络数据基本信息（不生成静态mindmap）
       const networkData = JSON.parse(await fs.readFile(networkFilePath, 'utf8'));
+      const stats = this.getNetworkStats(networkData);
       
-      // 生成mindmap
-      const mindmap = this.generateMindmap(networkData);
-      
-      // 构建Mind对象
-      const mind = this.buildMindObject(networkData);
-      
-      console.log(chalk.green(`✅ 认知网络加载成功: ${mind.nodeCount} 个节点, ${mind.connectionCount} 个连接`));
+      console.log(chalk.green(`✅ 认知网络检查完成: ${stats.nodeCount} 个节点, ${stats.connectionCount} 个连接`));
       
       return {
-        mind,
-        mindmap,
         hasNetwork: true,
-        networkData
+        networkPath: networkFilePath,
+        status: 'active',
+        stats,
+        lastModified: networkData.timestamp || 'unknown'
       };
       
     } catch (error) {
-      console.warn(chalk.yellow(`⚠️  认知网络加载失败: ${error.message}`));
+      console.warn(chalk.yellow(`⚠️  认知网络检查失败: ${error.message}`));
       return {
-        mind: null,
-        mindmap: null,
-        hasNetwork: false
+        hasNetwork: false,
+        networkPath: null,
+        status: 'error',
+        error: error.message
       };
     }
   }
 
   /**
-   * 生成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对象
+   * @returns {Object} 统计信息
    */
-  buildMindObject(networkData) {
+  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,
-      activatedCues: Object.keys(cues),
-      timestamp: networkData.timestamp,
-      version: networkData.version
+      mostActiveCue: mostActiveCue.word,
+      version: networkData.version,
+      hasConnections: connectionCount > 0
     };
   }
 }
@@ -341,19 +309,34 @@ class LayerAssembler {
     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('');
+    // CognitionLayer - 动态认知网络状态
+    parts.push('## 💭 Hippocampus网络');
+    
+    if (cognitionData.hasNetwork) {
+      parts.push(`**认知网络状态**: ${cognitionData.status === 'active' ? '🟢 激活' : '🔴 未激活'}`);
       
-      if (cognitionData.mind) {
-        parts.push(`**网络状态**: ${cognitionData.mind.nodeCount} 个概念节点，${cognitionData.mind.connectionCount} 个关联连接`);
-        parts.push('');
+      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) {