cocos2d-cli 1.2.1 → 1.4.0

package/bin/{cocos-cli.js → cocos2d-cli.js}

@@ -14,7 +14,6 @@ const commands = {
     add: '../src/commands/add',
     'add-component': '../src/commands/add-component',
     'remove': '../src/commands/remove',
-    delete: '../src/commands/delete',
     build: '../src/commands/build',
     'create-prefab': '../src/commands/prefab-create',
     'create-scene': '../src/commands/create-scene'
@@ -34,11 +33,10 @@ Cocos Creator CLI - 场景/预制体操作工具集
   set <场景.fire | 预制体.prefab> <索引> [选项]  修改节点属性
   add <场景.fire | 预制体.prefab> <父索引> <名称>  添加节点
   add-component <文件> <节点索引> <类型>     给节点添加组件
-  remove <文件> <索引>                       删除节点或组件
-  delete <文件> <节点索引>                   删除节点
+  remove <文件> <索引> [--component|--node]  删除节点或组件（自动检测类型）
   build <项目目录>                           构建组件映射
-  create-prefab <输出.prefab>               从 stdin(JSON) 创建预制体
-  create-scene <输出.fire>                   从 stdin(JSON) 创建场景
+  create-prefab [JSON文件] <输出.prefab>     创建预制体（不传JSON则创建默认）
+  create-scene <JSON文件> <输出.fire>        从JSON文件创建场景
 
 选项:
   --name=<名称>          修改节点名称
@@ -79,8 +77,13 @@ JSON 格式 (create-prefab / create-scene):
 
   节点属性: name, width, height, x, y, color, opacity, anchorX, anchorY, rotation, scaleX, scaleY, active
 
+  组件写法:
+    简写: "sprite" 或 "label"
+    完整: { "type": "sprite", "sizeMode": 1 }
+    完整: { "type": "label", "string": "文本", "fontSize": 32, "color": "#fff" }
+
   组件类型:
-    sprite   - 精灵���默认白色方块，节点设置什么颜色就显示什么颜色
+    sprite   - 精灵（默认白色方块，节点设置什么颜色就显示什么颜色）
     label    - 文本，支持 string, fontSize, color(兼容)
     button   - 按钮，通常配合 sprite 使用才能看见
     widget   - 对齐，支持 top, bottom, left, right
@@ -92,7 +95,6 @@ JSON 格式 (create-prefab / create-scene):
   注意:
     - color 写在节点或 label 组件均可
     - button 需要配合 sprite 才能看见按钮外观
-    - 必须通过 JSON 文件输入: type panel.json | cocos2d-cli create-prefab xxx.prefab
 
 示例:
   cocos2d-cli tree assets/main.fire
@@ -100,11 +102,14 @@ JSON 格式 (create-prefab / create-scene):
   cocos2d-cli set assets/main.fire 8 --x=100 --y=200 --color=#ff0000
   cocos2d-cli add assets/main.fire 5 NewSprite --type=sprite --x=100
 
-  # 从 JSON 创建场景
-  type scene.json | cocos2d-cli create-scene assets/scene.fire
+  # 从 JSON 文件创建场景
+  cocos2d-cli create-scene scene.json assets/scene.fire
+
+  # 从 JSON 文件创建预制体
+  cocos2d-cli create-prefab panel.json assets/panel.prefab
 
-  # 从 JSON 创建预制体
-  type panel.json | cocos2d-cli create-prefab assets/panel.prefab
+  # 创建默认预制体（不传JSON）
+  cocos2d-cli create-prefab assets/NewNode.prefab
 `);
 }
 
@@ -132,4 +137,4 @@ try {
 } catch (err) {
     console.error(`命令执行失败: ${err.message}`);
     process.exit(1);
-}
+}

package/package.json

@@ -1,10 +1,10 @@
 {
   "name": "cocos2d-cli", 
-  "version": "1.2.1",
+  "version": "1.4.0",
   "description": "Command-line tools for AI to read and manipulate Cocos Creator 2.4.x project scenes",
-  "main": "bin/cocos-cli.js",
+  "main": "bin/cocos2d-cli.js",
   "bin": {
-    "cocos2d-cli": "./bin/cocos-cli.js"
+    "cocos2d-cli": "./bin/cocos2d-cli.js"
   },
   "files": [
     "bin",

package/src/commands/add-component.js

@@ -3,7 +3,8 @@
  */
 
 const { loadScene, saveScene, buildMaps, findNodeIndex, refreshEditor } = require('../lib/fire-utils');
-const { Components, generateId } = require('../lib/components');
+const { outputError, outputSuccess, generateId } = require('../lib/utils');
+const { createComponent } = require('../lib/components');
 const fs = require('fs');
 const path = require('path');
 
@@ -14,9 +15,7 @@ function loadScriptMap(projectPath) {
         if (fs.existsSync(mapPath)) {
             return JSON.parse(fs.readFileSync(mapPath, 'utf-8'));
         }
-    } catch (e) {
-        // 忽略错误
-    }
+    } catch (e) {}
     return {};
 }
 
@@ -37,9 +36,7 @@ function createScriptComponent(scriptUuid, nodeId, scriptMap) {
 
 function run(args) {
     if (args.length < 3) {
-        console.log(JSON.stringify({ 
-            error: '用法: cocos2.4 add-component <场景文件路径> <节点路径> <组件类型>' 
-        }));
+        outputError('用法: cocos2d-cli add-component <场景文件路径> <节点路径> <组件类型>');
         return;
     }
     
@@ -51,58 +48,41 @@ function run(args) {
         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}` }));
+            outputError(`找不到节点: ${nodeRef}`);
             return;
         }
         
         const node = data[nodeIndex];
         
         // 检查是否已有该类型组件
+        const ccType = 'cc.' + componentType.charAt(0).toUpperCase() + componentType.slice(1);
         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);
+            return compType === componentType || compType === ccType;
         });
         
         if (existingComp) {
-            console.log(JSON.stringify({ 
-                error: `节点 "${node._name}" 已有 ${componentType} 组件`,
-                nodeIndex,
-                nodeName: node._name
-            }));
+            outputError(`节点 "${node._name}" 已有 ${componentType} 组件`);
             return;
         }
         
-        // 加载脚本映射（从场景文件所在项目的 data 目录）
-        const projectPath = path.dirname(scenePath);
-        const scriptMap = loadScriptMap(projectPath);
-        
-        // 创建组件
-        let componentData;
         const compIndex = data.length;
+        let componentData;
         
-        // 检查是否是内置组件
-        const builtInTypes = ['sprite', 'label', 'button', 'layout', 'widget', 'camera', 'canvas', 'particleSystem'];
+        // 尝试使用内置组件
+        componentData = createComponent(componentType, nodeIndex);
         
-        if (builtInTypes.includes(componentType.toLowerCase())) {
-            // 内置组件
-            const typeKey = componentType.toLowerCase();
-            componentData = Components[typeKey]?.(nodeIndex);
+        if (!componentData) {
+            // 自定义脚本组件
+            const projectPath = path.dirname(scenePath);
+            const scriptMap = loadScriptMap(projectPath);
             
-            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;
@@ -110,42 +90,31 @@ function run(args) {
                 }
             }
             
-            // 如果没找到，尝试直接使用 componentType 作为类型名
-            if (!scriptUuid) {
-                // 检查是否是有效的 UUID 格式
-                const uuidRegex = /^[a-f0-9-]{36}$/i;
-                if (uuidRegex.test(componentType)) {
-                    scriptUuid = componentType;
-                }
+            const uuidRegex = /^[a-f0-9-]{36}$/i;
+            if (!scriptUuid && 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,
+        outputSuccess({
             componentIndex: compIndex,
             componentType: componentData.__type__,
             nodeIndex,
-            nodeName: node._name,
-            message: `组件 "${componentData.__type__}" 已添加到节点 "${node._name}"`
-        }, null, 2));
+            nodeName: node._name
+        });
     } catch (err) {
-        console.log(JSON.stringify({ error: err.message }));
+        outputError(err.message);
     }
 }
 
-module.exports = { run };
+module.exports = { run };

package/src/commands/add.js

@@ -1,25 +1,14 @@
 /**
  * add 命令 - 添加节点（支持场景和预制体）
- * 
- * 预制体正确结构（深度优先遍历）：
- *   节点 → 子节点(递归) → 组件 → PrefabInfo
- * 
- * 示例：
- * [1] Node (根) _prefab -> [最后]
- * [2] Node (子1) _prefab -> [6]
- * [3] Node (孙) _prefab -> [5]
- * [4] Component (孙的组件)
- * [5] PrefabInfo (孙的)
- * [6] Component (子1的组件)
- * [7] PrefabInfo (子1的)
- * [8] PrefabInfo (根的，在最后)
  */
 
-const { loadScene, saveScene, buildMaps, refreshEditor, isPrefab, generateFileId } = require('../lib/fire-utils');
-const { Components, createNodeData } = require('../lib/components');
+const { loadScene, saveScene, buildMaps, refreshEditor, isPrefab, generateFileId, getPrefabRootIndex } = require('../lib/fire-utils');
+const { parseOptions, outputError, outputSuccess } = require('../lib/utils');
+const { createNodeData } = require('../lib/node-utils');
+const { createComponent } = require('../lib/components');
 
 /**
- * 获取根节点 PrefabInfo 的索引（预制体最后一个元素）
+ * 获取根节点 PrefabInfo 的索引
  */
 function getRootPrefabInfoIndex(data) {
     for (let i = data.length - 1; i >= 0; i--) {
@@ -32,7 +21,7 @@ function getRootPrefabInfoIndex(data) {
 }
 
 /**
- * 获取节点子树的结束索引（子节点 → 组件 → PrefabInfo）
+ * 获取节点子树的结束索引
  */
 function getSubtreeEndIndex(data, nodeIndex) {
     const node = data[nodeIndex];
@@ -40,7 +29,6 @@ function getSubtreeEndIndex(data, nodeIndex) {
     
     let lastIndex = nodeIndex;
     
-    // 递归处理所有子节点
     if (node._children) {
         for (const childRef of node._children) {
             const childEnd = getSubtreeEndIndex(data, childRef.__id__);
@@ -48,14 +36,12 @@ function getSubtreeEndIndex(data, nodeIndex) {
         }
     }
     
-    // 处理组件
     if (node._components) {
         for (const compRef of node._components) {
             lastIndex = Math.max(lastIndex, compRef.__id__);
         }
     }
     
-    // PrefabInfo 在最后（根节点的除外，它在整个数组最后）
     if (node._prefab && nodeIndex !== 1) {
         lastIndex = Math.max(lastIndex, node._prefab.__id__);
     }
@@ -66,7 +52,7 @@ function getSubtreeEndIndex(data, nodeIndex) {
 /**
  * 重建所有 __id__ 引用
  */
-function rebuildReferences(data, insertIndex, count) {
+function rebuildReferencesForInsert(data, insertIndex, count) {
     const indexMap = {};
     
     for (let oldIndex = 0; oldIndex < data.length; oldIndex++) {
@@ -101,7 +87,7 @@ function rebuildReferences(data, insertIndex, count) {
 
 function run(args) {
     if (args.length < 3) {
-        console.log(JSON.stringify({ error: '用法: cocos2.4 add <场景.fire | 预制体.prefab> <父节点索引> <节点名称> [选项]' }));
+        outputError('用法: cocos2d-cli add <场景.fire | 预制体.prefab> <父节点索引> <节点名称> [选项]');
         return;
     }
     
@@ -109,62 +95,50 @@ function run(args) {
     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';
-            else if (key === 'color') options.color = value;
-            else if (key === 'fontSize') options.fontSize = parseInt(value) || 40;
-            else if (key === 'string') options.string = value || '';
-        }
-    });
+    const options = parseOptions(args, 3);
+    
+    // 转换数值类型
+    if (options.x) options.x = parseFloat(options.x) || 0;
+    if (options.y) options.y = parseFloat(options.y) || 0;
+    if (options.width) options.width = parseFloat(options.width) || 0;
+    if (options.height) options.height = parseFloat(options.height) || 0;
+    if (options.at !== undefined) options.at = parseInt(options.at);
+    if (options.active !== undefined) options.active = options.active !== 'false';
+    if (options.fontSize) options.fontSize = parseInt(options.fontSize) || 40;
     
     try {
         const data = loadScene(filePath);
         const { prefab } = buildMaps(data);
         
         if (!/^\d+$/.test(parentRef)) {
-            console.log(JSON.stringify({ error: '父节点必须使用数字索引，请先用 tree 命令查看节点索引' }));
+            outputError('父节点必须使用数字索引，请先用 tree 命令查看节点索引');
             return;
         }
         
         const parentIndex = parseInt(parentRef);
         
         if (parentIndex < 0 || parentIndex >= data.length || !data[parentIndex]) {
-            console.log(JSON.stringify({ error: `无效的节点索引: ${parentRef}` }));
+            outputError(`无效的节点索引: ${parentRef}`);
             return;
         }
         
         const parentNode = data[parentIndex];
         const isRootChild = prefab && parentIndex === 1;
         
-        // 确定插入位置：紧跟父节点之后（在父节点的子节点/组件/PrefabInfo之前）
+        // 确定插入位置
         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 = parentNode._children[0].__id__;
             } else if (targetPosition >= parentNode._children.length) {
-                // 插入到最后一个子节点之后
                 const lastChildRef = parentNode._children[parentNode._children.length - 1];
                 insertIndex = getSubtreeEndIndex(data, lastChildRef.__id__) + 1;
             } else {
-                // 插入到中间
                 insertIndex = parentNode._children[targetPosition].__id__;
             }
         }
@@ -173,39 +147,16 @@ function run(args) {
         
         if (prefab) {
             // 预制体模式
-            // 找到根节点的 PrefabInfo
             const rootPrefabInfoOldIdx = getRootPrefabInfoIndex(data);
             const rootPrefabInfo = data[rootPrefabInfoOldIdx];
             
             // 创建节点
-            const nodeData = {
-                "__type__": "cc.Node",
-                "_name": nodeName,
-                "_objFlags": 0,
-                "_parent": { "__id__": parentIndex },
-                "_children": [],
-                "_active": options.active !== false,
-                "_components": [],
-                "_prefab": null,
-                "_opacity": 255,
-                "_color": parseColor(options.color) || { "__type__": "cc.Color", "r": 255, "g": 255, "b": 255, "a": 255 },
-                "_contentSize": { "__type__": "cc.Size", "width": options.width || 0, "height": options.height || 0 },
-                "_anchorPoint": { "__type__": "cc.Vec2", "x": 0.5, "y": 0.5 },
-                "_trs": { "__type__": "TypedArray", "ctor": "Float64Array", "array": [options.x || 0, options.y || 0, 0, 0, 0, 0, 1, 1, 1, 1] },
-                "_eulerAngles": { "__type__": "cc.Vec3", "x": 0, "y": 0, "z": 0 },
-                "_skewX": 0,
-                "_skewY": 0,
-                "_is3DNode": false,
-                "_groupIndex": 0,
-                "groupIndex": 0,
-                "_id": ""
-            };
+            const nodeData = createNodeData(nodeName, parentIndex, options);
             
-            // 创建组件（如果有）
+            // 创建组件
             let compData = null;
             if (options.type) {
-                compData = Components[options.type]?.(insertIndex);
-                // 修改组件属性
+                compData = createComponent(options.type, insertIndex);
                 if (compData) {
                     if (options.type === 'label') {
                         if (options.fontSize) {
@@ -229,31 +180,25 @@ function run(args) {
                 "sync": false
             };
             
-            // 构建要插入的元素：节点 → 组件 → PrefabInfo
             const itemsToInsert = [nodeData];
             if (compData) itemsToInsert.push(compData);
             itemsToInsert.push(prefabInfo);
             
-            // 如果是根节点的子节点，先移除根 PrefabInfo
             if (isRootChild) {
-                // 如果插入位置在根 PrefabInfo 之后，需要调整
                 if (insertIndex > rootPrefabInfoOldIdx) {
                     insertIndex--;
                 }
                 data.splice(rootPrefabInfoOldIdx, 1);
             }
             
-            // 插入元素
             for (let i = 0; i < itemsToInsert.length; i++) {
                 data.splice(insertIndex + i, 0, itemsToInsert[i]);
             }
             
-            // 重建引用
-            rebuildReferences(data, insertIndex, itemsToInsert.length);
+            rebuildReferencesForInsert(data, insertIndex, itemsToInsert.length);
             
             newNodeIndex = insertIndex;
             
-            // 设置引用
             if (compData) {
                 compData.node = { "__id__": newNodeIndex };
                 nodeData._components.push({ "__id__": newNodeIndex + 1 });
@@ -262,27 +207,20 @@ function run(args) {
                 nodeData._prefab = { "__id__": newNodeIndex + 1 };
             }
             
-            // 如果是根节点的子节点，把根 PrefabInfo 添加到最后
             if (isRootChild) {
                 data.push(rootPrefabInfo);
                 data[1]._prefab = { "__id__": data.length - 1 };
             }
             
         } else {
-            // 场景模式：节点 + 组件
+            // 场景模式
             const newNode = createNodeData(nodeName, parentIndex, options);
             
-            if (options.color) {
-                const color = parseColor(options.color);
-                if (color) newNode._color = color;
-            }
-            
             const itemsToInsert = [newNode];
             
             let compData = null;
             if (options.type) {
-                compData = Components[options.type]?.(insertIndex);
-                // 修改组件属性
+                compData = createComponent(options.type, insertIndex);
                 if (compData) {
                     if (options.type === 'label') {
                         if (options.fontSize) {
@@ -302,7 +240,7 @@ function run(args) {
                 data.splice(insertIndex + i, 0, itemsToInsert[i]);
             }
             
-            rebuildReferences(data, insertIndex, itemsToInsert.length);
+            rebuildReferencesForInsert(data, insertIndex, itemsToInsert.length);
             
             newNodeIndex = insertIndex;
             
@@ -317,40 +255,19 @@ function run(args) {
         const insertPosition = options.at >= 0 ? options.at : parentNode._children.length;
         parentNode._children.splice(insertPosition, 0, { "__id__": newNodeIndex });
         
-        // 保存文件
         saveScene(filePath, data);
-        
-        // 触发编辑器刷新
         refreshEditor(filePath);
         
-        console.log(JSON.stringify({ 
-            success: true, 
+        outputSuccess({ 
             nodeIndex: newNodeIndex,
             name: nodeName,
             parent: parentRef,
             type: prefab ? 'prefab' : 'scene'
-        }));
+        });
         
     } catch (err) {
-        console.log(JSON.stringify({ error: err.message }));
-    }
-}
-
-function parseColor(colorStr) {
-    if (!colorStr) return null;
-    let color = colorStr;
-    if (typeof color === 'string') {
-        if (color.startsWith('#')) color = color.slice(1);
-        if (color.length === 6) {
-            const r = parseInt(color.slice(0, 2), 16);
-            const g = parseInt(color.slice(2, 4), 16);
-            const b = parseInt(color.slice(4, 6), 16);
-            if (!isNaN(r) && !isNaN(g) && !isNaN(b)) {
-                return { "__type__": "cc.Color", r, g, b, a: 255 };
-            }
-        }
+        outputError(err.message);
     }
-    return null;
 }
 
 module.exports = { run };

package/src/commands/build.js

@@ -7,7 +7,7 @@ const path = require('path');
 
 function run(args) {
     if (args.length < 1) {
-        console.log(JSON.stringify({ error: '用法: cocos-cli build <项目目录>' }));
+        console.log(JSON.stringify({ error: '用法: cocos2d-cli build <项目目录>' }));
         return;
     }