cocos2d-cli 1.0.3

package/bin/cocos-cli.js

@@ -0,0 +1,93 @@
+#!/usr/bin/env node
+/**
+ * Cocos Creator CLI
+ * Command-line tools for AI to read and manipulate Cocos Creator 2.4.x project scenes
+ */
+
+const path = require('path');
+
+// 命令映射
+const commands = {
+    tree: '../src/commands/tree',
+    get: '../src/commands/get',
+    set: '../src/commands/set',
+    add: '../src/commands/add',
+    'add-component': '../src/commands/add-component',
+    'remove': '../src/commands/remove',
+    delete: '../src/commands/delete',
+    build: '../src/commands/build'
+};
+
+// 帮助信息
+function showHelp() {
+    console.log(`
+Cocos Creator CLI - 场景操作工具集
+
+用法:
+  cocos2.4 <command> [options]
+
+命令:
+  tree <场景文件路径>                    查看节点树
+  get <场景文件路径> <节点>              获取节点信息
+  set <场景文件路径> <节点> [选项]       修改节点属性
+  add <场景文件路径> <父节点> <名称>     添加节点
+  add-component <场景文件路径> <节点> <类型>  给节点添加组件
+  remove <场景路径> <索引>               删除节点或组件
+  delete <场景文件路径> <节点>           删除节点
+  build <项目目录>                       构建组件映射
+
+选项:
+  --name=<名称>          修改节点名称
+  --active=true/false    修改激活状态
+  --x=<数值>             修改 X 坐标
+  --y=<数值>             修改 Y 坐标
+  --width=<数值>         修改宽度
+  --height=<数值>        修改高度
+  --anchorX=<0-1>        修改锚点 X
+  --anchorY=<0-1>        修改锚点 Y
+  --opacity=<0-255>      修改透明度
+  --color=<#RRGGBB>      修改颜色
+  --rotation=<角度>      修改旋转角度
+  --scaleX=<数值>        修改 X 缩放
+  --scaleY=<数值>        修改 Y 缩放
+  --type=sprite/label    添加节点时指定组件类型
+  --at=<位置>            添加节点时指定插入位置
+
+示例:
+  cocos2.4 tree assets/main.fire
+  cocos2.4 get assets/main.fire Canvas
+  cocos2.4 set assets/main.fire Canvas/Player --x=100 --y=200
+  cocos2.4 add assets/main.fire Canvas NewSprite --type=sprite --x=100
+  cocos2.4 add-component assets/main.fire Canvas/Player sprite
+  cocos2.4 delete assets/main.fire OldNode
+  cocos2.4 build ./my-project
+
+版本: 1.0.2
+`);
+}
+
+// 解析参数
+const args = process.argv.slice(2);
+
+if (args.length === 0 || args[0] === '--help' || args[0] === '-h') {
+    showHelp();
+    process.exit(0);
+}
+
+const commandName = args[0];
+const commandPath = commands[commandName];
+
+if (!commandPath) {
+    console.error(`未知命令: ${commandName}`);
+    console.error('运行 cocos-cli --help 查看可用命令');
+    process.exit(1);
+}
+
+// 加载并执行命令
+try {
+    const command = require(commandPath);
+    command.run(args.slice(1));
+} catch (err) {
+    console.error(`命令执行失败: ${err.message}`);
+    process.exit(1);
+}

package/data/script_map.json

@@ -0,0 +1,25 @@
+{
+  "01e12Vix3xPZaV9rG8NNMhT": "CharacterAnimation",
+  "0c1120T6UNNk5mllwLCpN0/": "GameScene",
+  "0c5a3bepqdAUZOCSqDOe7tX": "StageManager",
+  "166a2V/C3pMsLYQh5Cfhh0M": "Tile",
+  "1777aIKiDVM2ayJgXQsFRbc": "InfoNode",
+  "2000bQ16aVPOowsYmWzQHBl": "TilemapCamera",
+  "25dfekurxJEpa4v3Hll7c7S": "PlayerController",
+  "2a19dBOCe1GUpzKNfMsQQR7": "Pathfinder",
+  "329ecFYmkpK+ZTeUQlUmyHq": "MapCharacter",
+  "36c13QGxrxExoOv5anzjyRj": "EventManager",
+  "394e4Gg6E1Dh6AedkHAFZH+": "index",
+  "3cc7eQO1TZPTYTHr3v/2h1L": "SceneScript",
+  "42cc8kWoTtFHqEMb8ClTUBk": "GameExpressionEvaluator",
+  "7541bC/enRKeocYItojXgyK": "Gamepiece",
+  "781adeySrdN27K4uANiWTCT": "MinimapRenderer",
+  "9701aXPPNhO2IJ1bgr/25pJ": "PlayerManager",
+  "a4e62KPZVNEbZO1mvkzyOQt": "FilmEffect",
+  "a4ff8dbnCJNsLLBFaNYXrQp": "Player",
+  "a89e2IVZx5Bn50oCifRT+GC": "Gameboard",
+  "c4069o+d29NprrTzmS9V1Mb": "ResourceManager",
+  "e0920R8VWpPOpxr0VnPlCqA": "GamepieceRegistry",
+  "e24c1oXqIpLvqqgMFn+zl3A": "Tilemap",
+  "f07feXxRJVMj7Vg6tTtIi+T": "index"
+}

package/package.json

@@ -0,0 +1,31 @@
+{
+  "name": "cocos2d-cli",
+  "version": "1.0.3",
+  "description": "Command-line tools for AI to read and manipulate Cocos Creator 2.4.x project scenes",
+  "main": "src/lib/index.js",
+  "bin": {
+    "cocos2.4": "./bin/cocos-cli.js"
+  },
+  "files": [
+    "bin",
+    "src",
+    "data"
+  ],
+  "scripts": {
+    "test": "bash test/run.sh",
+    "test:structure": "node test/verify_structure.js",
+    "test:cli": "bash test/run.sh"
+  },
+  "keywords": [
+    "cocos",
+    "cocos-creator",
+    "cli",
+    "scene",
+    "fire"
+  ],
+  "author": "",
+  "license": "MIT",
+  "engines": {
+    "node": ">=14.0.0"
+  }
+}

package/src/commands/add-component.js

@@ -0,0 +1,151 @@
+/**
+ * add-component 命令 - 给已存在的节点添加组件
+ */
+
+const { loadScene, saveScene, buildMaps, findNodeIndex, refreshEditor } = require('../lib/fire-utils');
+const { Components, generateId } = require('../lib/components');
+const fs = require('fs');
+const path = require('path');
+
+// 加载脚本映射
+function loadScriptMap(projectPath) {
+    const mapPath = path.join(projectPath, 'data', 'script_map.json');
+    try {
+        if (fs.existsSync(mapPath)) {
+            return JSON.parse(fs.readFileSync(mapPath, 'utf-8'));
+        }
+    } catch (e) {
+        // 忽略错误
+    }
+    return {};
+}
+
+// 创建自定义脚本组件
+function createScriptComponent(scriptUuid, nodeId, scriptMap) {
+    const scriptInfo = scriptMap[scriptUuid];
+    const typeName = scriptInfo ? scriptInfo.name : scriptUuid;
+    
+    return {
+        "__type__": typeName,
+        "_name": "",
+        "_objFlags": 0,
+        "node": { "__id__": nodeId },
+        "_enabled": true,
+        "_id": generateId()
+    };
+}
+
+function run(args) {
+    if (args.length < 3) {
+        console.log(JSON.stringify({ 
+            error: '用法: cocos2.4 add-component <场景文件路径> <节点路径> <组件类型>' 
+        }));
+        return;
+    }
+    
+    const scenePath = args[0];
+    const nodeRef = args[1];
+    const componentType = args[2];
+    
+    try {
+        const data = loadScene(scenePath);
+        const { indexMap } = buildMaps(data);
+        
+        // 查找节点
+        const nodeIndex = findNodeIndex(data, indexMap, nodeRef);
+        
+        if (nodeIndex === null || !data[nodeIndex]) {
+            console.log(JSON.stringify({ error: `找不到节点: ${nodeRef}` }));
+            return;
+        }
+        
+        const node = data[nodeIndex];
+        
+        // 检查是否已有该类型组件
+        const existingComp = node._components?.find(comp => {
+            const compData = data[comp.__id__];
+            if (!compData) return false;
+            const compType = compData.__type__;
+            return compType === componentType || compType === 'cc.' + componentType.charAt(0).toUpperCase() + componentType.slice(1);
+        });
+        
+        if (existingComp) {
+            console.log(JSON.stringify({ 
+                error: `节点 "${node._name}" 已有 ${componentType} 组件`,
+                nodeIndex,
+                nodeName: node._name
+            }));
+            return;
+        }
+        
+        // 加载脚本映射（从场景文件所在项目的 data 目录）
+        const projectPath = path.dirname(scenePath);
+        const scriptMap = loadScriptMap(projectPath);
+        
+        // 创建组件
+        let componentData;
+        const compIndex = data.length;
+        
+        // 检查是否是内置组件
+        const builtInTypes = ['sprite', 'label', 'button', 'layout', 'widget', 'camera', 'canvas', 'particleSystem'];
+        
+        if (builtInTypes.includes(componentType.toLowerCase())) {
+            // 内置组件
+            const typeKey = componentType.toLowerCase();
+            componentData = Components[typeKey]?.(nodeIndex);
+            
+            if (!componentData) {
+                console.log(JSON.stringify({ error: `不支持的组件类型: ${componentType}` }));
+                return;
+            }
+        } else {
+            // 自定义脚本组件 - 查找脚本UUID
+            let scriptUuid = null;
+            
+            // 在 scriptMap 中查找
+            for (const [uuid, info] of Object.entries(scriptMap)) {
+                if (info.name === componentType) {
+                    scriptUuid = uuid;
+                    break;
+                }
+            }
+            
+            // 如果没找到，尝试直接使用 componentType 作为类型名
+            if (!scriptUuid) {
+                // 检查是否是有效的 UUID 格式
+                const uuidRegex = /^[a-f0-9-]{36}$/i;
+                if (uuidRegex.test(componentType)) {
+                    scriptUuid = componentType;
+                }
+            }
+            
+            componentData = createScriptComponent(scriptUuid || componentType, nodeIndex, scriptMap);
+        }
+        
+        // 添加组件到数组
+        data.push(componentData);
+        
+        // 更新节点的 _components
+        if (!node._components) node._components = [];
+        node._components.push({ "__id__": compIndex });
+        
+        // 保存场景
+        saveScene(scenePath, data);
+        
+        // 触发编辑器刷新（传入场景路径以重新打开场景）
+        refreshEditor(scenePath);
+        
+        console.log(JSON.stringify({
+            success: true,
+            componentIndex: compIndex,
+            componentType: componentData.__type__,
+            nodeIndex,
+            nodeName: node._name,
+            message: `组件 "${componentData.__type__}" 已添加到节点 "${node._name}"`
+        }, null, 2));
+    } catch (err) {
+        console.log(JSON.stringify({ error: err.message }));
+    }
+}
+
+module.exports = { run };

package/src/commands/add.js

@@ -0,0 +1,227 @@
+/**
+ * add 命令 - 添加节点
+ * 按照 Cocos Creator 的深度优先遍历顺序插入节点
+ */
+
+const { loadScene, saveScene, buildMaps, findNodeIndex, refreshEditor } = require('../lib/fire-utils');
+const { Components, createNodeData } = require('../lib/components');
+
+/**
+ * 获取节点及其所有子树的最后一个索引（用于确定插入位置）
+ * 按照深度优先遍历，返回该节点子树的结束位置
+ */
+function getSubtreeEndIndex(data, nodeIndex) {
+    const node = data[nodeIndex];
+    if (!node) return nodeIndex;
+    
+    let lastIndex = nodeIndex;
+    
+    // 递归处理所有子节点
+    if (node._children) {
+        for (const childRef of node._children) {
+            const childEnd = getSubtreeEndIndex(data, childRef.__id__);
+            lastIndex = Math.max(lastIndex, childEnd);
+        }
+    }
+    
+    // 处理组件（组件在子节点之后）
+    if (node._components) {
+        for (const compRef of node._components) {
+            lastIndex = Math.max(lastIndex, compRef.__id__);
+        }
+    }
+    
+    return lastIndex;
+}
+
+/**
+ * 重建所有 __id__ 引用（插入元素后索引变化）
+ * 返回新旧索引的映射表
+ */
+function rebuildReferencesForInsert(data, insertIndex) {
+    const indexMap = {};
+    
+    // 构建映射：旧索引 -> 新索引
+    for (let oldIndex = 0; oldIndex < data.length; oldIndex++) {
+        if (oldIndex < insertIndex) {
+            indexMap[oldIndex] = oldIndex;
+        } else {
+            indexMap[oldIndex] = oldIndex + 1;
+        }
+    }
+    
+    // 更新所有 __id__ 引用
+    function updateRef(obj) {
+        if (!obj || typeof obj !== 'object') return;
+        
+        if (obj.__id__ !== undefined) {
+            const oldId = obj.__id__;
+            if (indexMap[oldId] !== undefined) {
+                obj.__id__ = indexMap[oldId];
+            }
+        } else {
+            for (const key of Object.keys(obj)) {
+                updateRef(obj[key]);
+            }
+        }
+    }
+    
+    for (const item of data) {
+        updateRef(item);
+    }
+    
+    return indexMap;
+}
+
+function run(args) {
+    if (args.length < 3) {
+        console.log(JSON.stringify({ error: '用法: cocos2.4 add <场景文件路径> <父节点> <节点名称> [选项]' }));
+        return;
+    }
+    
+    const scenePath = args[0];
+    const parentRef = args[1];
+    const nodeName = args[2];
+    
+    // 解析选项
+    const options = {};
+    args.slice(3).forEach(arg => {
+        if (arg.startsWith('--')) {
+            const [key, value] = arg.substring(2).split('=');
+            if (key === 'type') options.type = value;
+            else if (key === 'x') options.x = parseFloat(value) || 0;
+            else if (key === 'y') options.y = parseFloat(value) || 0;
+            else if (key === 'width') options.width = parseFloat(value) || 0;
+            else if (key === 'height') options.height = parseFloat(value) || 0;
+            else if (key === 'at') options.at = parseInt(value);
+            else if (key === 'active') options.active = value !== 'false';
+        }
+    });
+    
+    try {
+        const data = loadScene(scenePath);
+        const { indexMap } = buildMaps(data);
+        
+        // 查找父节点
+        const parentIndex = findNodeIndex(data, indexMap, parentRef);
+        
+        if (parentIndex === null || !data[parentIndex]) {
+            console.log(JSON.stringify({ error: `找不到父节点: ${parentRef}` }));
+            return;
+        }
+        
+        const parentNode = data[parentIndex];
+        
+        // 确定插入位置
+        // 按照 _children 顺序，找到应该插入的位置
+        let insertIndex;
+        if (!parentNode._children || parentNode._children.length === 0) {
+            // 父节点没有子节点，新节点紧跟父节点之后
+            insertIndex = parentIndex + 1;
+        } else {
+            // 根据 --at 参数确定插入位置
+            const targetPosition = options.at >= 0 ? options.at : parentNode._children.length;
+            
+            if (targetPosition === 0) {
+                // 插入到第一个子节点位置，紧跟父节点之后
+                insertIndex = parentIndex + 1;
+            } else if (targetPosition >= parentNode._children.length) {
+                // 插入到最后，在所有现有子节点之后
+                const lastChildRef = parentNode._children[parentNode._children.length - 1];
+                insertIndex = getSubtreeEndIndex(data, lastChildRef.__id__) + 1;
+            } else {
+                // 插入到中间某个位置
+                const beforeChildRef = parentNode._children[targetPosition - 1];
+                insertIndex = getSubtreeEndIndex(data, beforeChildRef.__id__) + 1;
+            }
+        }
+        
+        // 创建新节点
+        const newNode = createNodeData(nodeName, parentIndex, options);
+        
+        // 在正确位置插入新节点
+        data.splice(insertIndex, 0, newNode);
+        
+        // 重建索引引用（因为插入了新元素，后续索引都+1）
+        const insertIndexMap = rebuildReferencesForInsert(data, insertIndex);
+        
+        // 新节点的实际索引
+        const newNodeIndex = insertIndex;
+        
+        // 更新新节点的 _parent 引用（使用映射后的父节点索引）
+        const newParentIndex = insertIndexMap[parentIndex] !== undefined ? insertIndexMap[parentIndex] : parentIndex;
+        newNode._parent = { "__id__": newParentIndex };
+        
+        // 添加组件（如果有）
+        let componentIndex = -1;
+        if (options.type) {
+            const compData = Components[options.type]?.(newNodeIndex);
+            if (compData) {
+                // 组件应该放在新节点子树之后（这里新节点没有子节点，所以紧跟节点后）
+                const compInsertIndex = newNodeIndex + 1;
+                data.splice(compInsertIndex, 0, compData);
+                
+                // 再次重建引用
+                rebuildReferencesForInsert(data, compInsertIndex);
+                
+                componentIndex = compInsertIndex;
+                newNode._components.push({ "__id__": componentIndex });
+            }
+        }
+        
+        // 更新父节点的 _children
+        if (!parentNode._children) parentNode._children = [];
+        
+        const insertPosition = options.at >= 0 ? options.at : parentNode._children.length;
+        parentNode._children.splice(insertPosition, 0, { "__id__": newNodeIndex });
+        
+        // 保存场景
+        saveScene(scenePath, data);
+        
+        // 触发编辑器刷新（传入场景路径以重新打开场景）
+        refreshEditor(scenePath);
+        
+        // 构建节点树（类似 tree 命令）
+        function buildTree(nodeIndex, prefix = '', isLast = true, isRoot = true) {
+            const node = data[nodeIndex];
+            if (!node) return '';
+            
+            const nodeName = isRoot ? 'Root' : (node._name || '(unnamed)');
+            const active = node._active !== false ? '●' : '○';
+            const connector = isRoot ? '' : (isLast ? '└── ' : '├── ');
+            
+            let result = prefix + (isRoot ? '' : active + ' ') + nodeName + ' #' + nodeIndex;
+            
+            // 添加组件信息
+            if (node._components && node._components.length > 0) {
+                const comps = node._components.map(c => {
+                    const comp = data[c.__id__];
+                    if (!comp) return `? #${c.__id__}`;
+                    return `${comp.__type__.replace('cc.', '')} #${c.__id__}`;
+                }).join(', ');
+                result += ` (${comps})`;
+            }
+            
+            result += '\n';
+            
+            // 处理子节点
+            if (node._children && node._children.length > 0) {
+                node._children.forEach((childRef, idx) => {
+                    const childIsLast = idx === node._children.length - 1;
+                    const childPrefix = prefix + (isRoot ? '' : (isLast ? '    ' : '│   '));
+                    result += buildTree(childRef.__id__, childPrefix, childIsLast, false);
+                });
+            }
+            
+            return result;
+        }
+        
+        const treeStr = buildTree(1);
+        
+        console.log(treeStr);
+    } catch (err) {
+        console.log(JSON.stringify({ error: err.message }));
+    }
+}
+
+module.exports = { run };

package/src/commands/build.js

@@ -0,0 +1,78 @@
+/**
+ * build 命令 - 构建组件映射
+ */
+
+const fs = require('fs');
+const path = require('path');
+
+function run(args) {
+    if (args.length < 1) {
+        console.log(JSON.stringify({ error: '用法: cocos-cli build <项目目录>' }));
+        return;
+    }
+    
+    const projectDir = args[0];
+    const importsDir = path.join(projectDir, 'library', 'imports');
+    const outputFile = path.join(__dirname, '../../data/script_map.json');
+    
+    if (!fs.existsSync(importsDir)) {
+        console.log(JSON.stringify({ error: `imports 目录不存在: ${importsDir}` }));
+        return;
+    }
+    
+    const scriptMap = {};
+    let processedCount = 0;
+    
+    function scanDirectory(dir) {
+        const items = fs.readdirSync(dir);
+        
+        for (const item of items) {
+            const fullPath = path.join(dir, item);
+            const stat = fs.statSync(fullPath);
+            
+            if (stat.isDirectory()) {
+                scanDirectory(fullPath);
+            } else if (item.endsWith('.js')) {
+                try {
+                    const content = fs.readFileSync(fullPath, 'utf8');
+                    
+                    // 查找 cc._RF.push 调用
+                    const match = content.match(/cc\._RF\.push\(module,\s*['"]([^'"]+)['"],\s*['"]([^'"]+)['"]\)/);
+                    
+                    if (match) {
+                        const hash = match[1];
+                        const className = match[2];
+                        
+                        // 只存储脚本相关的哈希（不以 'cc.' 开头的）
+                        if (!className.startsWith('cc.')) {
+                            scriptMap[hash] = className;
+                            processedCount++;
+                        }
+                    }
+                } catch (err) {
+                    // 忽略读取错误
+                }
+            }
+        }
+    }
+    
+    scanDirectory(importsDir);
+    
+    // 确保输出目录存在
+    const outputDir = path.dirname(outputFile);
+    if (!fs.existsSync(outputDir)) {
+        fs.mkdirSync(outputDir, { recursive: true });
+    }
+    
+    // 写入输出文件
+    fs.writeFileSync(outputFile, JSON.stringify(scriptMap, null, 2), 'utf8');
+    
+    console.log(JSON.stringify({
+        success: true,
+        count: Object.keys(scriptMap).length,
+        outputFile,
+        message: `构建完成，共 ${Object.keys(scriptMap).length} 个脚本映射`
+    }, null, 2));
+}
+
+module.exports = { run };

package/src/commands/delete.js

@@ -0,0 +1,73 @@
+/**
+ * delete 命令 - 删除节点
+ */
+
+const { loadScene, saveScene, buildMaps, collectNodeAndChildren, rebuildReferences, findNodeIndex, refreshEditor } = require('../lib/fire-utils');
+
+function run(args) {
+    if (args.length < 2) {
+        console.log(JSON.stringify({ error: '用法: cocos2.4 delete <场景文件路径> <节点索引|名称>' }));
+        return;
+    }
+    
+    const scenePath = args[0];
+    const nodeRef = args[1];
+    
+    try {
+        const data = loadScene(scenePath);
+        const { indexMap } = buildMaps(data);
+        
+        // 查找节点
+        const nodeIndex = findNodeIndex(data, indexMap, nodeRef);
+        
+        if (nodeIndex === null || !data[nodeIndex]) {
+            console.log(JSON.stringify({ error: `找不到节点: ${nodeRef}` }));
+            return;
+        }
+        
+        if (nodeIndex <= 1) {
+            console.log(JSON.stringify({ error: '不能删除根节点' }));
+            return;
+        }
+        
+        const node = data[nodeIndex];
+        const nodeName = node._name;
+        
+        // 收集所有需要删除的索引（节点 + 子节点 + 组件）
+        const indicesToDelete = collectNodeAndChildren(data, nodeIndex);
+        
+        // 从父节点的 _children 中移除引用
+        if (node._parent) {
+            const parentIndex = node._parent.__id__;
+            const parent = data[parentIndex];
+            if (parent && parent._children) {
+                parent._children = parent._children.filter(c => c.__id__ !== nodeIndex);
+            }
+        }
+        
+        // 重建引用（更新所有 __id__）
+        rebuildReferences(data, indicesToDelete);
+        
+        // 真正删除元素（从大到小排序，避免索引错乱）
+        const sortedIndices = Array.from(indicesToDelete).sort((a, b) => b - a);
+        for (const idx of sortedIndices) {
+            data.splice(idx, 1);
+        }
+        
+        // 保存场景
+        saveScene(scenePath, data);
+        
+        // 触发编辑器刷新（传入场景路径以重新打开场景）
+        refreshEditor(scenePath);
+        
+        console.log(JSON.stringify({
+            success: true,
+            message: `节点 "${nodeName}" 已删除`,
+            deletedCount: indicesToDelete.size
+        }, null, 2));
+    } catch (err) {
+        console.log(JSON.stringify({ error: err.message }));
+    }
+}
+
+module.exports = { run };