openyida 0.1.2 → 1.0.0-beta.0

package/lib/babel-transform/index.js

@@ -0,0 +1,244 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+Object.defineProperty(exports, "JSXUtil", {
+  enumerable: true,
+  get: function get() {
+    return _jsxUtils.default;
+  }
+});
+exports.default = compile;
+exports.getCode = getCode;
+var _jsxUtils = _interopRequireDefault(require("./jsx-utils"));
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+function ownKeys(object, enumerableOnly) { var keys = Object.keys(object); if (Object.getOwnPropertySymbols) { var symbols = Object.getOwnPropertySymbols(object); enumerableOnly && (symbols = symbols.filter(function (sym) { return Object.getOwnPropertyDescriptor(object, sym).enumerable; })), keys.push.apply(keys, symbols); } return keys; }
+function _objectSpread(target) { for (var i = 1; i < arguments.length; i++) { var source = null != arguments[i] ? arguments[i] : {}; i % 2 ? ownKeys(Object(source), !0).forEach(function (key) { _defineProperty(target, key, source[key]); }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)) : ownKeys(Object(source)).forEach(function (key) { Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key)); }); } return target; }
+function _defineProperty(obj, key, value) { key = _toPropertyKey(key); if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; }
+function _toPropertyKey(arg) { var key = _toPrimitive(arg, "string"); return _typeof(key) === "symbol" ? key : String(key); }
+function _toPrimitive(input, hint) { if (_typeof(input) !== "object" || input === null) return input; var prim = input[Symbol.toPrimitive]; if (prim !== undefined) { var res = prim.call(input, hint || "default"); if (_typeof(res) !== "object") return res; throw new TypeError("@@toPrimitive must return a primitive value."); } return (hint === "string" ? String : Number)(input); }
+function _typeof(obj) { "@babel/helpers - typeof"; return _typeof = "function" == typeof Symbol && "symbol" == typeof Symbol.iterator ? function (obj) { return typeof obj; } : function (obj) { return obj && "function" == typeof Symbol && obj.constructor === Symbol && obj !== Symbol.prototype ? "symbol" : typeof obj; }, _typeof(obj); }
+// should not use import Babel from 'babel-standalone';
+var Babel = require('@babel/standalone');
+var RE_VERSION = '4.0.0';
+// 区分浏览器还是node环境
+if ((typeof window === "undefined" ? "undefined" : _typeof(window)) === 'object') {
+  var VisualEngine = window.VisualEngine;
+  RE_VERSION = window.pageConfig && window.pageConfig.RE_VERSION || VisualEngine && VisualEngine.Env && VisualEngine.Env.get('RE_VERSION') || window.RenderEngine && window.RenderEngine.version || '4.0.0';
+}
+function isString(string) {
+  return {}.toString.call(string) === '[object String]';
+}
+
+// 查找组件
+function findComps(ast) {
+  var id = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : 'normal';
+  var _ref = (typeof window === "undefined" ? "undefined" : _typeof(window)) === 'object' ? window : {},
+    MyBabel = _ref.MyBabel;
+  if (!ast || !MyBabel) {
+    return;
+  }
+  var comps = [];
+  MyBabel.traverse(ast, {
+    CallExpression: function CallExpression(path) {
+      if (!path.node.callee || path.node.callee.type !== 'MemberExpression' || !path.node.callee.property || !['createElement', 'getComponentView'].includes(path.node.callee.property.name)) {
+        return;
+      }
+      var node = Array.isArray(path.node.arguments) ? path.node.arguments[0] : {};
+      // 形如 Deep.Button，分析出Deep.Button
+      var componentName = '';
+      while (true) {
+        if (node && node.type === 'MemberExpression' && node.object) {
+          var _node, _node$property;
+          componentName = "".concat((_node = node) === null || _node === void 0 ? void 0 : (_node$property = _node.property) === null || _node$property === void 0 ? void 0 : _node$property.name).concat(componentName == '' ? '' : '.') + componentName;
+          node = node.object;
+        } else if (node && node.type === 'Identifier') {
+          componentName = "".concat(node.name).concat(componentName == '' ? '' : '.') + componentName;
+          break;
+        } else if (node && node.type === 'StringLiteral') {
+          componentName += "".concat(node.value) + componentName;
+          break;
+        } else {
+          break;
+        }
+      }
+      comps.push(componentName);
+    }
+  });
+  _jsxUtils.default.setComps(id, comps);
+}
+var EMPTY_FUNC_STRING = 'function emptyCall() {}';
+function getCode(obj) {
+  var opts = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {
+    compiled: false,
+    allowEmpty: false
+  };
+  if (typeof obj === 'string') {
+    return obj;
+  }
+  if (_typeof(obj) === 'object' && obj !== null) {
+    var result = opts.compiled ? 'value' in obj ? obj.value : obj.compiled : obj.source;
+    return opts.allowEmpty ? result : result || EMPTY_FUNC_STRING;
+  }
+  if (opts.allowEmpty) {
+    return obj;
+  }
+  return EMPTY_FUNC_STRING;
+}
+function compile() {
+  var source = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : '';
+  var options = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};
+  var transformFunction = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : false;
+  var env = arguments.length > 3 && arguments[3] !== undefined ? arguments[3] : {};
+  var compileOptions = arguments.length > 4 && arguments[4] !== undefined ? arguments[4] : {};
+  var compiled = '';
+  var error = {};
+  env = _objectSpread({
+    RE_VERSION: RE_VERSION
+  }, env);
+  var isOldRenderEngine = parseFloat(env.RE_VERSION, 10) < 4.2;
+  if (isString(source) && source !== '') {
+    if (isOldRenderEngine && !env.shouldCompile) {
+      return source;
+    }
+    var decoSource = source;
+    if (transformFunction) {
+      decoSource = "var __compiledFunc__ = ".concat(source, ";");
+    }
+    try {
+      var presets = parseInt(Babel.version, 10) > 6 ? ['react', ['env', {
+        "loose": true,
+        "spec": true,
+        targets: {
+          browsers: ['ie >= 11', 'chrome >= 62']
+        }
+      }]] : ['react', 'es2015-loose', 'stage-0'];
+      if (parseFloat(env.RE_VERSION, 10) < 7.0) {
+        var result = Babel.transform(decoSource, _objectSpread({
+          presets: presets,
+          ast: true
+        }, options));
+        compiled = result.code;
+        findComps(result.ast, env.id);
+        if (transformFunction) {
+          compiled = "function main(){\n    ".concat(compiled, "\n    return __compiledFunc__.apply(this, arguments);\n  }");
+        } else {
+          compiled = "".concat(compiled, "\n");
+        }
+      } else {
+        var addonBindings = [];
+        function addBindingToScope(scope, bind) {
+          if (!scope.addonBindings) {
+            scope.addonBindings = [];
+          }
+          scope.addonBindings.push(bind);
+        }
+        function hasAddonBinding(scope, bind) {
+          return scope.addonBindings && scope.addonBindings.indexOf(bind) > -1;
+        }
+        var plugins = [function (_ref2) {
+          var types = _ref2.types,
+            template = _ref2.template;
+          function getJSXTagName(ast) {
+            if (ast.type === 'JSXMemberExpression') {
+              return getJSXTagName(ast.object);
+            }
+            if (ast.type === 'JSXIdentifier') {
+              return ast.name;
+            }
+            return null;
+          }
+          function isCustomTag(name) {
+            return /^[A-Z]/.test(name);
+          }
+          function getTopStatement(path) {
+            // todo:
+            var st = path.getStatementParent();
+          }
+          var DC = template('const TAGNAME = this._getComponentView(TAGNAME_S)');
+          return {
+            visitor: {
+              JSXElement: function JSXElement(path) {
+                var node = path.node,
+                  scope = path.scope;
+                // todo: get top function declaration for nesting function statement
+                var tagName = getJSXTagName(node.openingElement.name);
+                if (!tagName || !isCustomTag(tagName) || scope.hasBinding(tagName)) {
+                  return;
+                }
+                if (transformFunction) {
+                  if (addonBindings.indexOf(tagName) > -1) {
+                    return;
+                  }
+                  addonBindings.push(tagName);
+                } else {
+                  if (hasAddonBinding(scope, tagName)) {
+                    return;
+                  }
+                  var st = path.getStatementParent();
+                  // simple arrow function, body is not statement
+                  if (st.parentPath.isProgram()) {
+                    // todo: not go here now
+                    /*
+                    path.replaceWith(ast);
+                    const body = path.scope.path.get('body');
+                    body.replaceWith(types.blockStatement([
+                      ...declares,
+                      types.returnStatement(body.node)
+                    ]));
+                    */
+                  } else {
+                    // st mybe return statement
+                    st.insertBefore(DC({
+                      TAGNAME: types.identifier(tagName),
+                      TAGNAME_S: types.stringLiteral(tagName)
+                    }));
+                  }
+                  addBindingToScope(scope, tagName);
+                }
+              }
+            }
+          };
+        }];
+        if (options.plugins) {
+          plugins = plugins.concat(options.plugins);
+        }
+        var _result = Babel.transform(decoSource, _objectSpread(_objectSpread({
+          presets: presets,
+          ast: true
+        }, options), {}, {
+          plugins: plugins
+        }));
+        compiled = _result.code;
+        findComps(_result.ast, env.id);
+        if (transformFunction) {
+          var addonCodes = addonBindings.map(function (name) {
+            return "const ".concat(name, " = this._getComponentView('").concat(name, "');");
+          }).join('\n');
+          compiled = "function main(){\n    ".concat(addonCodes, "\n    ").concat(compiled, "\n    return __compiledFunc__.apply(this, arguments);\n  }");
+        } else {
+          compiled = "".concat(compiled, "\n");
+        }
+      }
+    } catch (e) {
+      console.error(e);
+      error = e;
+    }
+  }
+  if (compileOptions !== null && compileOptions !== void 0 && compileOptions.preferJSExpression) {
+    return {
+      type: 'JSExpression',
+      source: source,
+      value: compiled,
+      extType: 'function',
+      error: error
+    };
+  }
+  return {
+    type: 'js',
+    source: source,
+    compiled: compiled,
+    error: error
+  };
+}

package/lib/babel-transform/jsx-utils.js

@@ -0,0 +1,89 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+function _typeof(obj) { "@babel/helpers - typeof"; return _typeof = "function" == typeof Symbol && "symbol" == typeof Symbol.iterator ? function (obj) { return typeof obj; } : function (obj) { return obj && "function" == typeof Symbol && obj.constructor === Symbol && obj !== Symbol.prototype ? "symbol" : typeof obj; }, _typeof(obj); }
+function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
+function _defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, _toPropertyKey(descriptor.key), descriptor); } }
+function _createClass(Constructor, protoProps, staticProps) { if (protoProps) _defineProperties(Constructor.prototype, protoProps); if (staticProps) _defineProperties(Constructor, staticProps); Object.defineProperty(Constructor, "prototype", { writable: false }); return Constructor; }
+function _defineProperty(obj, key, value) { key = _toPropertyKey(key); if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; }
+function _toPropertyKey(arg) { var key = _toPrimitive(arg, "string"); return _typeof(key) === "symbol" ? key : String(key); }
+function _toPrimitive(input, hint) { if (_typeof(input) !== "object" || input === null) return input; var prim = input[Symbol.toPrimitive]; if (prim !== undefined) { var res = prim.call(input, hint || "default"); if (_typeof(res) !== "object") return res; throw new TypeError("@@toPrimitive must return a primitive value."); } return (hint === "string" ? String : Number)(input); }
+var JSXUtil = /*#__PURE__*/function () {
+  function JSXUtil() {
+    _classCallCheck(this, JSXUtil);
+    _defineProperty(this, "tags", {});
+  }
+  _createClass(JSXUtil, [{
+    key: "setComps",
+    value: function setComps(id, tags) {
+      if (!Array.isArray(tags)) {
+        return;
+      }
+
+      // 去重
+      var s = new Set(tags);
+      tags = Array.from(s);
+      if (!id) {
+        id = 'normal';
+      }
+
+      // 初始化
+      if (!Array.isArray(this.tags[id])) {
+        this.tags[id] = [];
+      }
+
+      // 收集未传id的情况下的组件，保证组件只多不少
+      if (id === 'normal') {
+        // 去重
+        var arr = this.tags[id];
+        tags.forEach(function (i) {
+          return !arr.includes(i) && arr.push(i);
+        });
+      } else {
+        // 具体属性更改后重新覆盖
+        this.tags[id] = tags;
+      }
+    }
+
+    /**
+     * 返回自定义渲染的组件列表
+     */
+  }, {
+    key: "getComponentList",
+    value: function getComponentList() {
+      var _this = this;
+      var s = new Set();
+      Object.keys(this.tags).forEach(function (id) {
+        var comps = _this.tags[id] || [];
+        if (Array.isArray(comps)) {
+          comps.forEach(function (c) {
+            return s.add(c);
+          });
+        }
+      });
+      return Array.from(s);
+    }
+  }, {
+    key: "reset",
+    value: function reset() {
+      this.tags = {};
+    }
+  }]);
+  return JSXUtil;
+}();
+var __vu_jsx_util__;
+if ((typeof window === "undefined" ? "undefined" : _typeof(window)) === 'object') {
+  var _window;
+  window.__vu_jsx_util__ = ((_window = window) === null || _window === void 0 ? void 0 : _window.__vu_jsx_util__) || new JSXUtil();
+  __vu_jsx_util__ = window.__vu_jsx_util__;
+} else {
+  var _global;
+  global.__vu_jsx_util__ = ((_global = global) === null || _global === void 0 ? void 0 : _global.__vu_jsx_util__) || new JSXUtil();
+  __vu_jsx_util__ = global.__vu_jsx_util__;
+}
+var _default = __vu_jsx_util__;
+exports.default = _default;
+module.exports = exports.default;

package/lib/check-update.js

@@ -0,0 +1,72 @@
+/**
+ * check-update.js - openyida 版本更新检查
+ *
+ * 向 npm registry 查询最新版本，有新版本时打印提示。
+ * 全程异步，不阻塞主命令流程。
+ */
+
+"use strict";
+
+const https = require("https");
+
+const REGISTRY_URL = "https://registry.npmjs.org/openyida/latest";
+
+/**
+ * 从 npm registry 获取最新版本号。
+ * @returns {Promise<string|null>}
+ */
+function fetchLatestVersion() {
+  return new Promise((resolve) => {
+    const req = https.get(REGISTRY_URL, { timeout: 5000 }, (res) => {
+      let data = "";
+      res.on("data", (chunk) => { data += chunk; });
+      res.on("end", () => {
+        try {
+          const parsed = JSON.parse(data);
+          resolve(parsed.version || null);
+        } catch {
+          resolve(null);
+        }
+      });
+    });
+    req.on("error", () => resolve(null));
+    req.on("timeout", () => { req.destroy(); resolve(null); });
+  });
+}
+
+/**
+ * 比较版本号，返回 latestVersion 是否比 currentVersion 更新。
+ * 仅支持 semver 格式（major.minor.patch）。
+ */
+function isNewer(currentVersion, latestVersion) {
+  const parseParts = (v) => (v || "").split(".").map((n) => parseInt(n, 10) || 0);
+  const [cMajor, cMinor, cPatch] = parseParts(currentVersion);
+  const [lMajor, lMinor, lPatch] = parseParts(latestVersion);
+
+  if (lMajor !== cMajor) return lMajor > cMajor;
+  if (lMinor !== cMinor) return lMinor > cMinor;
+  return lPatch > cPatch;
+}
+
+/**
+ * 检查是否有新版本，有则打印提示。
+ * @param {string} currentVersion - 当前版本号（来自 package.json）
+ */
+async function checkUpdate(currentVersion) {
+  try {
+    const latestVersion = await fetchLatestVersion();
+
+    if (latestVersion && isNewer(currentVersion, latestVersion)) {
+      process.nextTick(() => {
+        console.error(
+          `\n💡 发现新版本 ${latestVersion}（当前 ${currentVersion}）` +
+          `\n   运行以下命令更新：\n   npm install -g openyida@latest\n`
+        );
+      });
+    }
+  } catch {
+    // 版本检查失败静默忽略，不影响主流程
+  }
+}
+
+module.exports = { checkUpdate, isNewer, fetchLatestVersion };

package/lib/copy.js

@@ -0,0 +1,258 @@
+/**
+ * copy.js - 复制 project 工作目录模板 / 创建 yida-skills 软链接到当前 AI 工具环境
+ *
+ * 用法：
+ *   openyida copy                → 复制 project/ 目录模板（默认，合并模式）
+ *   openyida copy --force        → 复制 project/ 目录模板（强制覆盖，先清空目标目录）
+ *   openyida copy -skills        → 创建 yida-skills/ 软链接（如果存在实际目录则先删除）
+ *   openyida copy -project       → 复制 project/ 目录模板（与默认行为相同，显式指定）
+ *   openyida copy -project --force → 复制 project/ 目录模板（强制覆盖）
+ *
+ * 目标策略：
+ *   - 悟空（Wukong）：复制/链接到 ~/.real/workspace/（专属 workspace，路径固定）
+ *   - 其他 AI 工具：复制/链接到当前工程目录（process.cwd()）下
+ *
+ * 源路径：npm 全局安装包根目录（通过 require.resolve 定位）
+ *
+ * project/ 合并模式（默认）：已存在的文件强制覆盖，目标目录中多余的文件保留不动
+ * project/ 强制模式（--force）：先清空目标目录，再完整复制
+ * yida-skills/：始终创建软链接，如目标存在实际目录则先删除
+ */
+
+"use strict";
+
+const fs = require("fs");
+const path = require("path");
+const os = require("os");
+const { detectEnvironment } = require("./env");
+
+/**
+ * 查找 npm 全局安装包根目录。
+ * 优先通过 require.resolve 定位（适用于正式全局安装），
+ * 失败时 fallback 到 __dirname 向上查找（适用于 npm link 本地开发）。
+ * @returns {string|null} 包根目录的绝对路径，找不到则返回 null
+ */
+function findPackageRoot() {
+  try {
+    const packageJsonPath = require.resolve("openyida/package.json");
+    return path.dirname(packageJsonPath);
+  } catch {
+    // fallback：从当前文件向上查找包含 package.json 的目录
+    let dir = path.resolve(__dirname);
+    while (dir !== path.dirname(dir)) {
+      if (fs.existsSync(path.join(dir, "package.json"))) {
+        return dir;
+      }
+      dir = path.dirname(dir);
+    }
+    return null;
+  }
+}
+
+/**
+ * 合并复制目录：源文件强制覆盖，目标目录多余文件保留。
+ * @returns {number} 复制的文件数量
+ */
+function mergeCopyDir(sourceDir, destDir) {
+  if (!fs.existsSync(sourceDir)) return 0;
+
+  fs.mkdirSync(destDir, { recursive: true });
+
+  const entries = fs.readdirSync(sourceDir, { withFileTypes: true });
+  let copiedCount = 0;
+
+  for (const entry of entries) {
+    const sourcePath = path.join(sourceDir, entry.name);
+    const destPath = path.join(destDir, entry.name);
+
+    if (entry.isDirectory()) {
+      copiedCount += mergeCopyDir(sourcePath, destPath);
+    } else {
+      fs.copyFileSync(sourcePath, destPath);
+      console.log(`    复制: ${destPath}`);
+      copiedCount++;
+    }
+  }
+
+  return copiedCount;
+}
+
+/**
+ * 强制复制目录：先清空目标目录，再完整复制。
+ * @returns {number} 复制的文件数量
+ */
+function forceCopyDir(sourceDir, destDir) {
+  if (!fs.existsSync(sourceDir)) return 0;
+
+  if (fs.existsSync(destDir)) {
+    fs.rmSync(destDir, { recursive: true, force: true });
+    console.log(`    🗑️  已清空: ${destDir}`);
+  }
+
+  return mergeCopyDir(sourceDir, destDir);
+}
+
+/**
+ * 创建软链接：如果目标存在实际目录则先删除，再创建软链接。
+ * @returns {boolean} 是否成功创建
+ */
+function createSymlink(sourceDir, destLink) {
+  if (!fs.existsSync(sourceDir)) return false;
+
+  // 如果目标已存在，判断是目录还是软链接
+  if (fs.existsSync(destLink)) {
+    const stats = fs.lstatSync(destLink);
+    if (stats.isSymbolicLink()) {
+      // 已是软链接，删除后重新创建（确保指向正确）
+      fs.unlinkSync(destLink);
+      console.log(`    🗑️  已移除旧软链接: ${destLink}`);
+    } else if (stats.isDirectory()) {
+      // 是实际目录，删除后创建软链接
+      fs.rmSync(destLink, { recursive: true, force: true });
+      console.log(`    🗑️  已删除实际目录: ${destLink}`);
+    } else {
+      // 其他类型（文件等），直接删除
+      fs.unlinkSync(destLink);
+      console.log(`    🗑️  已移除: ${destLink}`);
+    }
+  }
+
+  // 创建软链接（使用相对路径或绝对路径，这里用绝对路径确保稳定）
+  fs.symlinkSync(sourceDir, destLink, "junction");
+  console.log(`    🔗 软链接: ${destLink} -> ${sourceDir}`);
+  return true;
+}
+
+/**
+ * 检测 AI 工具环境，返回目标根目录。
+ * @returns {string} 目标根目录路径
+ */
+function resolveDestBase() {
+  const { activeToolName, activeProjectRoot, results } = detectEnvironment();
+  const activeResult = results.find((r) => r.displayName === activeToolName);
+  const isWukong = activeResult && activeResult.dirName === ".real";
+
+  if (isWukong) {
+    return activeProjectRoot
+      ? path.dirname(activeProjectRoot)
+      : path.join(os.homedir(), ".real", "workspace");
+  }
+
+  if (activeToolName) {
+    return process.cwd();
+  }
+
+  // 未检测到活跃工具
+  console.error("\n❌ 未检测到活跃的 AI 工具环境");
+  console.error("   支持的工具：悟空、OpenCode、Claude Code、Aone Copilot、Cursor、Qoder、iFlow");
+  console.error("\n   当前检测结果：");
+  results.forEach((r) => {
+    console.error(`     ${r.isActive ? "✅" : "⬜"} ${r.displayName}`);
+  });
+  console.error("\n   如需强制复制到当前目录，请运行：");
+  console.error("   openyida copy --force");
+  process.exit(1);
+}
+
+/**
+ * 执行单项复制任务，打印结果。
+ */
+function copyItem(label, sourceDir, destDir, isForce) {
+  console.log(`\n📂 复制 ${label}...`);
+  const count = isForce
+    ? forceCopyDir(sourceDir, destDir)
+    : mergeCopyDir(sourceDir, destDir);
+  return count;
+}
+
+/**
+ * 执行 copy 命令主逻辑。
+ */
+function run() {
+  const SEP = "=".repeat(55);
+  console.log(SEP);
+  console.log("  openyida copy - 初始化宜搭工作目录");
+  console.log(SEP);
+
+  const args = process.argv.slice(3);
+  const isForce = args.includes("--force");
+  const wantsSkills = args.includes("-skills");
+  const wantsProject = args.includes("-project");
+
+  // 1. 查找 npm 包根目录
+  const packageRoot = findPackageRoot();
+  if (!packageRoot) {
+    console.error("\n❌ 未找到 openyida 安装包目录");
+    console.error("   请确认 openyida 已正确全局安装：");
+    console.error("   npm install -g openyida");
+    process.exit(1);
+  }
+
+  const packageProjectDir = path.join(packageRoot, "project");
+  const packageYidaSkillsDir = path.join(packageRoot, "yida-skills");
+
+  console.log(`\n📦 包根目录: ${packageRoot}`);
+
+  // 2. 确定目标根目录（检测 AI 工具环境）
+  const destBase = resolveDestBase();
+  console.log(`🤖 目标根目录: ${destBase}`);
+  if (isForce) {
+    console.log("⚠️  --force 模式：目标目录将被清空后重新复制");
+  }
+
+  // 3. 确定要复制/链接的内容
+  //    - 指定了 -skills：只创建 yida-skills/ 软链接
+  //    - 指定了 -project：只复制 project/
+  //    - 两者都没指定（默认）：只复制 project/
+  //    - 两者都指定：同时处理两项
+  const shouldCopyProject = wantsProject || (!wantsSkills);
+  const shouldLinkSkills = wantsSkills;
+
+  const results = [];
+
+  if (shouldCopyProject) {
+    const count = copyItem(
+      "project/ 工作目录模板",
+      packageProjectDir,
+      path.join(destBase, "project"),
+      isForce
+    );
+    results.push({ label: "project/", dest: path.join(destBase, "project"), count, type: "copy" });
+  }
+
+  if (shouldLinkSkills) {
+    console.log(`\n📂 创建 yida-skills/ 软链接...`);
+    const success = createSymlink(
+      packageYidaSkillsDir,
+      path.join(destBase, "yida-skills")
+    );
+    results.push({
+      label: "yida-skills/",
+      dest: path.join(destBase, "yida-skills"),
+      count: success ? 1 : 0,
+      type: "symlink"
+    });
+  }
+
+  // 4. 打印汇总
+  const copyCount = results.filter(r => r.type === "copy").reduce((sum, r) => sum + r.count, 0);
+  const linkCount = results.filter(r => r.type === "symlink").length;
+  console.log(`\n${SEP}`);
+  console.log(`✅ 完成！`);
+  if (copyCount > 0) {
+    console.log(`   复制文件: ${copyCount} 个`);
+  }
+  if (linkCount > 0) {
+    console.log(`   创建软链接: ${linkCount} 个`);
+  }
+  results.forEach((r) => {
+    if (r.type === "symlink") {
+      console.log(`   ${r.label.padEnd(14)} → ${r.dest} (软链接)`);
+    } else {
+      console.log(`   ${r.label.padEnd(14)} → ${r.dest} (${r.count} 个文件)`);
+    }
+  });
+  console.log(SEP);
+}
+
+module.exports = { run };