teamix-evo 0.16.0 → 0.18.0

package/dist/index.js

@@ -582,7 +582,7 @@ var init_registry = __esm({
 });
 
 // src/index.ts
-import { Command as Command41 } from "commander";
+import { Command as Command42 } from "commander";
 import { createRequire as createRequire9 } from "module";
 
 // src/commands/tokens/index.ts
@@ -807,9 +807,9 @@ async function installSkills(options) {
 async function renderSkillFiles(skill, options) {
   const { data, packageRoot } = options;
   const sourceAbs = path7.resolve(packageRoot, skill.source);
-  const stat5 = await fs6.stat(sourceAbs);
+  const stat6 = await fs6.stat(sourceAbs);
   const rendered = /* @__PURE__ */ new Map();
-  if (stat5.isFile()) {
+  if (stat6.isFile()) {
     const content = await renderSkillContent(sourceAbs, skill, data);
     rendered.set("SKILL.md", content);
     return rendered;
@@ -1072,13 +1072,13 @@ async function pruneEmptyIdeSkillDirs(args) {
     }
     for (const name of entries) {
       const dir = path7.join(skillsRoot, name);
-      let stat5;
+      let stat6;
       try {
-        stat5 = await fs6.stat(dir);
+        stat6 = await fs6.stat(dir);
       } catch {
         continue;
       }
-      if (!stat5.isDirectory()) continue;
+      if (!stat6.isDirectory()) continue;
       let children;
       try {
         children = await fs6.readdir(dir);
@@ -2395,11 +2395,11 @@ var uninstallCommand = new Command5("uninstall").description(
       `Will remove ${removable.length} file(s); keep ${kept} managed file(s).`
     );
     if (!opts.yes) {
-      const confirm7 = await prompts.confirm({
+      const confirm8 = await prompts.confirm({
         message: "\u786E\u8BA4\u5378\u8F7D tokens \u53D8\u4F53\uFF1F",
         initialValue: false
       });
-      if (prompts.isCancel(confirm7) || !confirm7) {
+      if (prompts.isCancel(confirm8) || !confirm8) {
         logger.info("Cancelled.");
         return;
       }
@@ -4583,11 +4583,11 @@ async function runFullUninstall(args) {
     `Will remove ${resources.length} skill file(s) installed by ${SKILLS_PACKAGE3}.`
   );
   if (!opts.yes) {
-    const confirm7 = await prompts4.confirm({
+    const confirm8 = await prompts4.confirm({
       message: "\u786E\u8BA4\u5378\u8F7D\uFF1F\u6B64\u64CD\u4F5C\u4F1A\u5220\u9664\u4E0A\u8FF0\u6587\u4EF6\u3002",
       initialValue: false
     });
-    if (prompts4.isCancel(confirm7) || !confirm7) {
+    if (prompts4.isCancel(confirm8) || !confirm8) {
       logger.info("Cancelled.");
       return;
     }
@@ -4640,11 +4640,11 @@ async function runPartialUninstall(args) {
     `Will remove ${matched.length} skill(s): ${matched.join(", ")} (${toRemove.length} file(s)).`
   );
   if (!opts.yes) {
-    const confirm7 = await prompts4.confirm({
+    const confirm8 = await prompts4.confirm({
       message: "\u786E\u8BA4\u5378\u8F7D\uFF1F\u6B64\u64CD\u4F5C\u4F1A\u5220\u9664\u4E0A\u8FF0\u6587\u4EF6\u3002",
       initialValue: false
     });
-    if (prompts4.isCancel(confirm7) || !confirm7) {
+    if (prompts4.isCancel(confirm8) || !confirm8) {
       logger.info("Cancelled.");
       return;
     }
@@ -5016,8 +5016,8 @@ async function runSkillsDoctor(options) {
 }
 async function dirExists(p2) {
   try {
-    const stat5 = await fs17.stat(p2);
-    return stat5.isDirectory();
+    const stat6 = await fs17.stat(p2);
+    return stat6.isDirectory();
   } catch {
     return false;
   }
@@ -6125,8 +6125,8 @@ function extractIds(pkg) {
 }
 async function directoryExists(p2) {
   try {
-    const stat5 = await fs22.stat(p2);
-    return stat5.isDirectory();
+    const stat6 = await fs22.stat(p2);
+    return stat6.isDirectory();
   } catch {
     return false;
   }
@@ -8548,13 +8548,44 @@ async function detectProjectState(cwd) {
       significantEntries: []
     };
   }
+  let legacyLib = "unknown";
+  let buildTool = "unknown";
+  let allDeps = {};
+  if (hasPackageJson2) {
+    const pkgRaw = await readFileOrNull(path36.join(absCwd, "package.json"));
+    if (pkgRaw) {
+      try {
+        const pkg = JSON.parse(pkgRaw);
+        allDeps = { ...pkg.dependencies, ...pkg.devDependencies };
+      } catch {
+      }
+    }
+  }
+  if ("@alifd/next" in allDeps || "@ali/teamix-material" in allDeps) {
+    legacyLib = "fusion";
+  } else if ("antd" in allDeps) {
+    legacyLib = "antd";
+  } else if ("element-ui" in allDeps || "element-plus" in allDeps) {
+    legacyLib = "element";
+  }
+  if (await fileExists(path36.join(absCwd, "build.json"))) {
+    buildTool = "ice";
+  } else if (await fileExists(path36.join(absCwd, "vite.config.ts")) || await fileExists(path36.join(absCwd, "vite.config.js")) || await fileExists(path36.join(absCwd, "vite.config.mts"))) {
+    buildTool = "vite";
+  } else if (await fileExists(path36.join(absCwd, "webpack.config.js")) || await fileExists(path36.join(absCwd, "webpack.config.ts"))) {
+    buildTool = "webpack";
+  } else if ("umi" in allDeps || "@umijs/max" in allDeps) {
+    buildTool = "umi";
+  }
   return {
     state: "other",
     cwd: absCwd,
     hasTeamixDir: false,
     hasPackageJson: hasPackageJson2,
     hasComponentsJson,
-    significantEntries: significant.slice(0, 20).sort()
+    significantEntries: significant.slice(0, 20).sort(),
+    legacyLib,
+    buildTool
   };
 }
 
@@ -8563,7 +8594,8 @@ init_logger();
 var COMMAND_LABELS = {
   init: "\u521D\u59CB\u5316 Teamix Evo \u5957\u4EF6",
   migrate: "shadcn \u9879\u76EE\u8FC1\u79FB\u4E3A Teamix Evo \u5957\u4EF6",
-  update: "Teamix Evo \u5957\u4EF6\u66F4\u65B0"
+  update: "Teamix Evo \u5957\u4EF6\u66F4\u65B0",
+  graft: "\u53E0\u52A0 Teamix Evo \u80FD\u529B"
 };
 var STATE_LABELS = {
   empty: "\u7A7A\u76EE\u5F55",
@@ -8574,13 +8606,14 @@ var STATE_LABELS = {
 var VALID_STATES = {
   init: "empty",
   migrate: "shadcn",
-  update: "teamix-evo"
+  update: "teamix-evo",
+  graft: "other"
 };
 var STATE_TO_COMMAND = {
   empty: "init",
   shadcn: "migrate",
   "teamix-evo": "update",
-  other: null
+  other: "graft"
 };
 function assertCommandPrecondition(command, state) {
   const expected = VALID_STATES[command];
@@ -8594,13 +8627,6 @@ function assertCommandPrecondition(command, state) {
   if (suggestion) {
     const suggestionLabel = COMMAND_LABELS[suggestion];
     logger.info(`\u5EFA\u8BAE\u4F7F\u7528\uFF1Ateamix-evo ${suggestion}\uFF08${suggestionLabel}\uFF09`);
-  } else {
-    logger.info(
-      "\u5F53\u524D\u9879\u76EE\u7C7B\u578B\u6682\u4E0D\u652F\u6301\u76F4\u63A5\u63A5\u5165\u3002"
-    );
-    logger.info(
-      "\u5EFA\u8BAE\uFF1A\u5148\u7528 teamix-evo init \u521D\u59CB\u5316 Teamix Evo \u5957\u4EF6\uFF08\u7A7A\u76EE\u5F55\uFF09\uFF0C\u7136\u540E\u5BF9\u65E7\u9879\u76EE\u8FDB\u884C\u91CD\u6784\u3002"
-    );
   }
   process.exitCode = 1;
 }
@@ -9482,7 +9508,7 @@ async function detectLintVersions(projectRoot) {
   const pkgJson = pkgJsonRaw ? JSON.parse(pkgJsonRaw) : null;
   const devDeps = pkgJson?.devDependencies ?? {};
   const deps = pkgJson?.dependencies ?? {};
-  const resolve12 = async (pkg) => {
+  const resolve13 = async (pkg) => {
     const declared = devDeps[pkg] ?? deps[pkg] ?? null;
     if (!declared) return null;
     const installedPkgJson = await readFileOrNull(
@@ -9492,8 +9518,8 @@ async function detectLintVersions(projectRoot) {
     return { declared, installed };
   };
   const [eslintConfig, stylelintConfig] = await Promise.all([
-    resolve12(LINT_PACKAGES[0]),
-    resolve12(LINT_PACKAGES[1])
+    resolve13(LINT_PACKAGES[0]),
+    resolve13(LINT_PACKAGES[1])
   ]);
   return { eslintConfig, stylelintConfig };
 }
@@ -9659,11 +9685,16 @@ var migrateCommand = new Command38("migrate").description(
   }
 });
 
-// src/commands/restore/index.ts
+// src/commands/graft/index.ts
 import { Command as Command39 } from "commander";
-import * as path44 from "path";
+import * as path45 from "path";
+import * as fs32 from "fs/promises";
 import * as prompts7 from "@clack/prompts";
 
+// src/core/graft-init.ts
+import { hasManagedRegion as hasManagedRegion5, replaceManagedRegion as replaceManagedRegion4 } from "@teamix-evo/registry";
+init_state();
+
 // src/core/snapshot.ts
 init_logger();
 import * as fs31 from "fs/promises";
@@ -9672,6 +9703,7 @@ var TEAMIX_DIR6 = ".teamix-evo";
 var SNAPSHOTS_DIR = ".snapshots";
 var META_FILE = "_meta.json";
 var DEFAULT_KEEP = 5;
+var SNAPSHOT_REASONS = ["init", "update", "switch", "restore", "graft", "manual"];
 function isoToFsSafe3(iso) {
   return iso.replace(/[:.]/g, "-");
 }
@@ -9684,8 +9716,8 @@ function fsSafeToIso(safe) {
 async function createSnapshot(projectRoot, opts = {}) {
   const teamixDir = path43.join(projectRoot, TEAMIX_DIR6);
   try {
-    const stat5 = await fs31.stat(teamixDir);
-    if (!stat5.isDirectory()) return null;
+    const stat6 = await fs31.stat(teamixDir);
+    if (!stat6.isDirectory()) return null;
   } catch (err) {
     if (err.code === "ENOENT") return null;
     throw err;
@@ -9737,7 +9769,7 @@ async function listSnapshots(projectRoot) {
       const raw = await fs31.readFile(path43.join(dir, META_FILE), "utf-8");
       const parsed = JSON.parse(raw);
       if (typeof parsed.ts === "string") isoTs = parsed.ts;
-      if (typeof parsed.reason === "string" && ["init", "update", "switch", "restore", "manual"].includes(
+      if (typeof parsed.reason === "string" && SNAPSHOT_REASONS.includes(
         parsed.reason
       )) {
         reason = parsed.reason;
@@ -9769,8 +9801,8 @@ async function restoreSnapshot(projectRoot, ts) {
   const snapshotRoot = path43.join(projectRoot, TEAMIX_DIR6, SNAPSHOTS_DIR);
   const target = path43.join(snapshotRoot, ts);
   try {
-    const stat5 = await fs31.stat(target);
-    if (!stat5.isDirectory()) {
+    const stat6 = await fs31.stat(target);
+    if (!stat6.isDirectory()) {
       throw new Error(`Snapshot path is not a directory: ${target}`);
     }
   } catch (err) {
@@ -9801,14 +9833,547 @@ async function restoreSnapshot(projectRoot, ts) {
   logger.debug(`Restored .teamix-evo/ from snapshot ${ts}`);
 }
 
+// src/core/graft-init.ts
+init_error();
+init_logger();
+init_fs();
+import * as fsNode2 from "fs/promises";
+import * as path44 from "path";
+var CRITICAL_STEPS2 = /* @__PURE__ */ new Set([
+  "ensure-teamix-dir",
+  "tokens",
+  "ui-init",
+  "skills"
+]);
+var AGENTS_MD_GRAFT_MANAGED_ID = "teamix-evo-graft";
+var GITIGNORE_MARKER_START2 = "# >>> teamix-evo:managed >>>";
+var GITIGNORE_MARKER_END2 = "# <<< teamix-evo:managed <<<";
+var GITIGNORE_RULES2 = [
+  "# Runtime artifacts (regenerable / archives)",
+  ".teamix-evo/.snapshots/",
+  ".teamix-evo/.backups/",
+  ".teamix-evo/.upgrade-staging/",
+  ".teamix-evo/.upgrade-hints/"
+];
+var LEGACY_LIB_META = {
+  fusion: {
+    displayName: "Fusion Design",
+    imports: ["teamix/ui", "@alifd/next", "@ali/teamix-material"]
+  },
+  antd: {
+    displayName: "Ant Design",
+    imports: ["antd", "@ant-design/*"]
+  },
+  element: {
+    displayName: "Element UI",
+    imports: ["element-ui", "element-plus"]
+  }
+};
+async function runGraftInit(options) {
+  const {
+    projectRoot,
+    variant,
+    legacyLib,
+    onStep
+  } = options;
+  const ide = options.ide ?? "qoder";
+  const ides = options.ides ?? ["qoder", "claude"];
+  const scope = options.scope ?? "project";
+  const steps = [];
+  let aborted = false;
+  function record(step) {
+    steps.push(step);
+    onStep?.(step);
+  }
+  function recordFailure(name, err) {
+    const message = getErrorMessage(err);
+    record({ name, status: "fail", detail: message });
+    if (CRITICAL_STEPS2.has(name)) aborted = true;
+  }
+  try {
+    await ensureTeamixDir(projectRoot);
+    record({ name: "ensure-teamix-dir", status: "ok" });
+  } catch (err) {
+    recordFailure("ensure-teamix-dir", err);
+  }
+  if (!aborted) {
+    try {
+      const snap = await createSnapshot(projectRoot, { reason: "graft" });
+      record({
+        name: "snapshot",
+        status: "ok",
+        detail: snap ? `snapshot ${snap.ts}` : "empty .teamix-evo/ \u2014 nothing to snapshot"
+      });
+    } catch (err) {
+      recordFailure("snapshot", err);
+    }
+  } else {
+    record({ name: "snapshot", status: "skip", detail: "aborted: earlier critical step failed" });
+  }
+  if (!aborted) {
+    try {
+      const result = await runTokensInit({ projectRoot, variant, ide });
+      const detail = result.status === "installed" ? `${result.packageName}@${result.version} (${result.count} files)` : result.status;
+      record({ name: "tokens", status: "ok", detail });
+    } catch (err) {
+      recordFailure("tokens", err);
+    }
+  } else {
+    record({ name: "tokens", status: "skip", detail: "aborted: earlier critical step failed" });
+  }
+  if (!aborted) {
+    try {
+      const initResult = await runUiInit({ projectRoot, ide });
+      record({
+        name: "ui-init",
+        status: "ok",
+        detail: initResult.status === "installed" ? "config.json packages.ui written" : initResult.status
+      });
+    } catch (err) {
+      recordFailure("ui-init", err);
+    }
+  } else {
+    record({ name: "ui-init", status: "skip", detail: "aborted: earlier critical step failed" });
+  }
+  const collectedNpmDeps = {};
+  if (!aborted) {
+    try {
+      const { manifest } = await loadUiData("@teamix-evo/ui");
+      const allIds = manifest.entries.map((e) => e.id);
+      const addResult = await runUiAdd({
+        projectRoot,
+        ids: allIds,
+        overwrite: true
+      });
+      record({
+        name: "ui-add",
+        status: "ok",
+        detail: `${addResult.orderedIds.length} entries (${addResult.written} written, ${addResult.skipped} skipped)`
+      });
+      Object.assign(collectedNpmDeps, addResult.npmDependencies);
+    } catch (err) {
+      recordFailure("ui-add", err);
+    }
+  } else {
+    record({ name: "ui-add", status: "skip", detail: "aborted: earlier critical step failed" });
+  }
+  if (!aborted) {
+    try {
+      const listing = await listBizUiEntries(variant);
+      if (listing.entries.length === 0) {
+        record({
+          name: "biz-ui-add",
+          status: "skip",
+          detail: `no biz-ui entries for variant "${variant}"`
+        });
+      } else {
+        const allIds = listing.entries.map((e) => e.id);
+        const result = await runBizUiAdd({
+          projectRoot,
+          variant,
+          ids: allIds,
+          overwrite: true
+        });
+        record({
+          name: "biz-ui-add",
+          status: "ok",
+          detail: `${result.orderedIds.length} entries (${result.written} written, ${result.skipped} skipped)`
+        });
+        if (result.npmDependencies) {
+          Object.assign(collectedNpmDeps, result.npmDependencies);
+        }
+      }
+    } catch (err) {
+      recordFailure("biz-ui-add", err);
+    }
+  } else {
+    record({ name: "biz-ui-add", status: "skip", detail: "aborted: earlier critical step failed" });
+  }
+  if (!aborted && Object.keys(collectedNpmDeps).length > 0) {
+    try {
+      await installProjectDeps({
+        projectRoot,
+        npmDependencies: collectedNpmDeps,
+        skipInstall: options.skipInstall ?? false
+      });
+    } catch (err) {
+      logger.warn(
+        `\u5B89\u88C5 ui/biz-ui \u4F20\u9012\u4F9D\u8D56\u5931\u8D25\uFF1A${getErrorMessage(err)}\uFF08\u53EF\u624B\u52A8\u8FD0\u884C \`npm install\` \u91CD\u8BD5\uFF09`
+      );
+    }
+  }
+  if (!aborted) {
+    try {
+      const result = await runSkillsInit({ projectRoot, ides, scope, ide });
+      if (result.status === "already-initialized") {
+        record({ name: "skills", status: "ok", detail: "already-initialized" });
+      } else {
+        record({
+          name: "skills",
+          status: "ok",
+          detail: `${result.skillCount} skills, ${result.fileCount} files`
+        });
+      }
+    } catch (err) {
+      recordFailure("skills", err);
+    }
+  } else {
+    record({ name: "skills", status: "skip", detail: "aborted: earlier critical step failed" });
+  }
+  if (!aborted) {
+    try {
+      const result = await runGenerateAgentsMd({
+        projectRoot,
+        variant,
+        skillIds: [
+          `teamix-evo-design-${variant}`,
+          `teamix-evo-code-${variant}`
+        ],
+        globalSkillIds: ["teamix-evo-manage"],
+        mode: "merge-managed"
+      });
+      record({
+        name: "agents-md",
+        status: "ok",
+        detail: `${result.skillCount} skill index (${result.merge})`
+      });
+    } catch (err) {
+      recordFailure("agents-md", err);
+    }
+  } else {
+    record({ name: "agents-md", status: "skip", detail: "aborted" });
+  }
+  if (!aborted) {
+    try {
+      const agentsMdPath = path44.join(projectRoot, "AGENTS.md");
+      const existing = await readFileOrNull(agentsMdPath) ?? "";
+      const meta = LEGACY_LIB_META[legacyLib] ?? {
+        displayName: legacyLib,
+        imports: [legacyLib]
+      };
+      const importsStr = meta.imports.map((i) => `\`${i}\``).join("\u3001");
+      const graftBody = renderGraftManagedBody(meta.displayName, importsStr);
+      let output;
+      if (hasManagedRegion5(existing, AGENTS_MD_GRAFT_MANAGED_ID)) {
+        output = replaceManagedRegion4(
+          existing,
+          AGENTS_MD_GRAFT_MANAGED_ID,
+          graftBody
+        );
+      } else {
+        const wrapped = wrapGraftManagedBlock(graftBody);
+        output = existing.trimEnd() + "\n\n" + wrapped + "\n";
+      }
+      await fsNode2.writeFile(agentsMdPath, output, "utf-8");
+      record({ name: "agents-md-graft", status: "ok", detail: `dual-stack rules for ${legacyLib}` });
+    } catch (err) {
+      recordFailure("agents-md-graft", err);
+    }
+  } else {
+    record({ name: "agents-md-graft", status: "skip", detail: "aborted" });
+  }
+  if (!aborted) {
+    try {
+      const uiResult = await landUiMeta(projectRoot);
+      const bizResult = await landBizUiMeta(projectRoot, variant);
+      record({
+        name: "meta-landing",
+        status: "ok",
+        detail: `ui: ${uiResult.metaFilesWritten}/${uiResult.metaFilesTotal}, biz-ui: ${bizResult.metaFilesWritten}/${bizResult.metaFilesTotal}`
+      });
+    } catch (err) {
+      recordFailure("meta-landing", err);
+    }
+  } else {
+    record({ name: "meta-landing", status: "skip", detail: "aborted" });
+  }
+  if (!aborted) {
+    try {
+      const config = await readProjectConfig(projectRoot);
+      if (config) {
+        config.mode = "graft";
+        config.legacyLib = legacyLib;
+        await writeProjectConfig(projectRoot, config);
+        record({ name: "config-mode", status: "ok", detail: `mode=graft, legacyLib=${legacyLib}` });
+      } else {
+        record({ name: "config-mode", status: "skip", detail: "no config.json found to patch" });
+      }
+    } catch (err) {
+      recordFailure("config-mode", err);
+    }
+  } else {
+    record({ name: "config-mode", status: "skip", detail: "aborted" });
+  }
+  if (!aborted) {
+    try {
+      const giPath = path44.join(projectRoot, ".gitignore");
+      let giContent = "";
+      try {
+        giContent = await fsNode2.readFile(giPath, "utf-8");
+      } catch {
+      }
+      if (giContent.includes(GITIGNORE_MARKER_START2)) {
+        record({ name: "gitignore", status: "skip", detail: "teamix-evo markers already present" });
+      } else {
+        const block = [
+          "",
+          GITIGNORE_MARKER_START2,
+          ...GITIGNORE_RULES2,
+          GITIGNORE_MARKER_END2,
+          ""
+        ].join("\n");
+        const separator = giContent.length > 0 && !giContent.endsWith("\n") ? "\n" : "";
+        await fsNode2.writeFile(giPath, giContent + separator + block, "utf-8");
+        record({
+          name: "gitignore",
+          status: "ok",
+          detail: `${GITIGNORE_RULES2.filter((r) => r && !r.startsWith("#")).length} rules appended`
+        });
+      }
+    } catch (err) {
+      recordFailure("gitignore", err);
+    }
+  } else {
+    record({ name: "gitignore", status: "skip", detail: "aborted" });
+  }
+  const status = steps.some((s) => s.status === "fail") ? "partial" : "success";
+  return { status, steps };
+}
+function renderGraftManagedBody(legacyLibName, legacyImports) {
+  return `## \u53CC\u6808\u7814\u53D1\u89C4\u5219
+
+\u672C\u9879\u76EE\u540C\u65F6\u5B58\u5728 ${legacyLibName}\uFF08\u65E7\u6808\uFF09\u548C teamix-evo\uFF08\u65B0\u6808\uFF09\u4E24\u5957\u6280\u672F\u6808\u3002
+
+### \u5224\u65AD\u89C4\u5219\u2014\u2014\u901A\u8FC7 import \u8BED\u53E5\u8BC6\u522B
+- \u6587\u4EF6\u4E2D import \u4E86 ${legacyImports} \u2192 **\u65E7\u6808**\uFF0C\u6309 ${legacyLibName} \u89C4\u8303\u7814\u53D1\uFF0C**\u8DF3\u8FC7** teamix-evo \u7684 design / code skill
+- \u6587\u4EF6\u4E2D import \u4E86 \`@/components/ui\`\u3001\u4F7F\u7528 Tailwind class \u2192 **\u65B0\u6808**\uFF0C\u6B63\u5E38\u89E6\u53D1 teamix-evo design / code skill
+- \u65B0\u5EFA\u9875\u9762 \u2192 \u9ED8\u8BA4\u4F7F\u7528\u65B0\u6808\uFF08teamix-evo\uFF09
+
+### \u7981\u6B62\u4E8B\u9879
+- \u7981\u6B62\u5728\u65E7\u6808\u6587\u4EF6\u4E2D\u5F15\u5165 \`@/components/ui\` \u6216 Tailwind class
+- \u7981\u6B62\u5728\u65B0\u6808\u6587\u4EF6\u4E2D\u5F15\u5165 ${legacyImports}
+- \u7981\u6B62\u5728\u540C\u4E00\u6587\u4EF6\u4E2D\u6DF7\u7528\u4E24\u5957\u7EC4\u4EF6\u5E93`;
+}
+function wrapGraftManagedBlock(body) {
+  return `<!-- teamix-evo:managed:start id="${AGENTS_MD_GRAFT_MANAGED_ID}" -->
+${body}
+<!-- teamix-evo:managed:end id="${AGENTS_MD_GRAFT_MANAGED_ID}" -->`;
+}
+
+// src/commands/graft/index.ts
+init_logger();
+init_error();
+init_fs();
+var APP_ENTRY_CANDIDATES = [
+  "src/app.tsx",
+  "src/app.ts",
+  "src/app.jsx",
+  "src/app.js",
+  "src/index.tsx",
+  "src/index.ts",
+  "src/index.jsx",
+  "src/index.js"
+];
+var POSTCSS_CONFIG_CANDIDATES = [
+  "postcss.config.js",
+  "postcss.config.cjs",
+  "postcss.config.mjs",
+  "postcss.config.ts",
+  ".postcssrc",
+  ".postcssrc.json",
+  ".postcssrc.yml",
+  ".postcssrc.yaml",
+  ".postcssrc.js"
+];
+var CONFLICT_PATHS = [
+  { path: ".teamix-evo", type: "directory" },
+  { path: "src/components/ui", type: "directory" },
+  { path: "src/components/business", type: "directory" },
+  { path: "tokens", type: "directory" }
+];
+async function findFirst(cwd, candidates) {
+  for (const c of candidates) {
+    if (await fileExists(path45.join(cwd, c))) return c;
+  }
+  return null;
+}
+async function getLegacyLibVersion(cwd, legacyLib) {
+  const pkgRaw = await readFileOrNull(path45.join(cwd, "package.json"));
+  if (!pkgRaw) return "unknown";
+  try {
+    const pkg = JSON.parse(pkgRaw);
+    const allDeps = { ...pkg.dependencies, ...pkg.devDependencies };
+    const libKeyMap = {
+      fusion: ["@alifd/next", "@ali/teamix-material"],
+      antd: ["antd"],
+      element: ["element-ui", "element-plus"]
+    };
+    const keys = libKeyMap[legacyLib] ?? [];
+    for (const key of keys) {
+      if (allDeps[key]) return allDeps[key];
+    }
+  } catch {
+  }
+  return "unknown";
+}
+async function detectConflicts(cwd) {
+  const conflicts = [];
+  for (const entry of CONFLICT_PATHS) {
+    const full = path45.join(cwd, entry.path);
+    try {
+      const stat6 = await fs32.stat(full);
+      if (entry.type === "directory" && stat6.isDirectory() || entry.type === "file" && stat6.isFile()) {
+        conflicts.push(entry);
+      }
+    } catch {
+    }
+  }
+  return conflicts;
+}
+async function analyzeProject(cwd) {
+  const state = await detectProjectState(cwd);
+  if (state.state !== "other") {
+    assertCommandPrecondition("graft", state.state);
+    throw new Error("unreachable");
+  }
+  const legacyLib = state.legacyLib ?? "unknown";
+  const buildTool = state.buildTool ?? "unknown";
+  const legacyVersion = await getLegacyLibVersion(cwd, legacyLib);
+  const BUILD_TOOL_CONFIG_CANDIDATES = {
+    ice: ["build.json"],
+    vite: ["vite.config.ts", "vite.config.js", "vite.config.mts", "vite.config.mjs"],
+    webpack: ["webpack.config.js", "webpack.config.ts", "webpack.config.cjs"]
+  };
+  const buildToolConfig = await findFirst(
+    cwd,
+    BUILD_TOOL_CONFIG_CANDIDATES[buildTool] ?? []
+  );
+  const postcssPath = await findFirst(cwd, POSTCSS_CONFIG_CANDIDATES);
+  const appEntry = await findFirst(cwd, APP_ENTRY_CANDIDATES);
+  const conflicts = await detectConflicts(cwd);
+  return {
+    report: {
+      projectRoot: cwd,
+      legacyLib: { name: legacyLib, version: legacyVersion },
+      buildTool: { type: buildTool, configFile: buildToolConfig },
+      postcssConfig: { exists: postcssPath !== null, path: postcssPath },
+      appEntry,
+      conflicts
+    },
+    legacyLib
+  };
+}
+function printReport(report) {
+  logger.info("Teamix Evo Graft \u2014 \u53CC\u6808\u5171\u5B58\u524D\u7F6E\u68C0\u67E5");
+  logger.info("");
+  logger.info(`  \u9879\u76EE\u76EE\u5F55\uFF1A${report.projectRoot}`);
+  logger.info(
+    `  \u65E7\u7EC4\u4EF6\u5E93\uFF1A${report.legacyLib.name} (${report.legacyLib.version})`
+  );
+  logger.info(`  \u6784\u5EFA\u5DE5\u5177\uFF1A${report.buildTool.type}`);
+  logger.info(
+    `  PostCSS \u914D\u7F6E\uFF1A${report.postcssConfig.path ?? "\u672A\u68C0\u6D4B\u5230"}`
+  );
+  logger.info(`  App \u5165\u53E3\uFF1A${report.appEntry ?? "\u672A\u68C0\u6D4B\u5230"}`);
+  if (report.conflicts.length > 0) {
+    logger.info("");
+    logger.warn("  \u5DF2\u5B58\u5728\u7684\u8DEF\u5F84\uFF08\u53EF\u80FD\u51B2\u7A81\uFF09\uFF1A");
+    for (const c of report.conflicts) {
+      logger.warn(`    ${c.path} (${c.type})`);
+    }
+  }
+}
+var graftCommand = new Command39("graft").description(
+  "\u53E0\u52A0 Teamix Evo AICoding \u80FD\u529B\u5230\u73B0\u6709\u9879\u76EE\uFF08\u53CC\u6808\u5171\u5B58\uFF0CADR 0047\uFF09"
+).option("--variant <name>", "\u6307\u5B9A tokens variant\uFF08\u5982 opentrek\uFF09").option("--cwd <dir>", "\u6307\u5B9A\u5DE5\u7A0B\u6839\u76EE\u5F55\uFF08\u9ED8\u8BA4\uFF1A\u5F53\u524D\u76EE\u5F55\uFF09").option("--json", "\u8F93\u51FA JSON \u683C\u5F0F\u7684\u5206\u6790\u62A5\u544A\uFF08\u4F9B AI skill \u6D88\u8D39\uFF09").option("--apply", "\u6267\u884C graft pipeline\uFF08\u9ED8\u8BA4\u4EC5\u524D\u7F6E\u68C0\u67E5\uFF09").option("-y, --yes", "\u8DF3\u8FC7 --apply \u4E8C\u6B21\u786E\u8BA4").action(async (opts) => {
+  const cwd = path45.resolve(opts.cwd ?? process.cwd());
+  const apply = opts.apply ?? false;
+  try {
+    const { report, legacyLib } = await analyzeProject(cwd);
+    if (opts.json) {
+      console.log(JSON.stringify(report, null, 2));
+    } else {
+      printReport(report);
+    }
+    if (!apply) {
+      if (!opts.json) {
+        logger.info("");
+        logger.info(
+          "\u524D\u7F6E\u68C0\u67E5\u5B8C\u6210\u3002\u52A0 --apply --variant <v> \u6267\u884C graft pipeline\u3002"
+        );
+      }
+      return;
+    }
+    if (!opts.variant) {
+      logger.error("--apply \u9700\u8981\u6307\u5B9A --variant\uFF08\u5982 --variant opentrek\uFF09");
+      process.exitCode = 1;
+      return;
+    }
+    if (legacyLib === "unknown") {
+      logger.error(
+        "\u672A\u8BC6\u522B\u65E7\u7EC4\u4EF6\u5E93\u3002\u8BF7\u786E\u8BA4 package.json \u4E2D\u5305\u542B @alifd/next / antd / element-ui \u7B49\u4F9D\u8D56\u3002"
+      );
+      process.exitCode = 1;
+      return;
+    }
+    const isInteractive = Boolean(process.stdin.isTTY);
+    if (!opts.yes && isInteractive) {
+      logger.info("");
+      logger.info(
+        `graft --apply \u5C06\u5B89\u88C5 teamix-evo \u5168\u6808\uFF08tokens + UI + biz-ui + skills + AGENTS.md\uFF09\uFF0Cvariant = "${opts.variant}"\u3002`
+      );
+      const confirmed = await prompts7.confirm({
+        message: "\u7EE7\u7EED\u6267\u884C\uFF1F"
+      });
+      if (prompts7.isCancel(confirmed) || !confirmed) {
+        logger.info("\u5DF2\u53D6\u6D88\u3002");
+        return;
+      }
+    }
+    logger.info("");
+    logger.info("\u6267\u884C graft pipeline\u2026");
+    logger.info("");
+    const result = await runGraftInit({
+      projectRoot: cwd,
+      variant: opts.variant,
+      legacyLib,
+      onStep: (step) => {
+        const icon = STEP_ICON[step.status];
+        const detail = step.detail ? ` \u2014 ${step.detail}` : "";
+        logger.info(`  ${icon} ${step.name}${detail}`);
+      }
+    });
+    logger.info("");
+    if (result.status === "success") {
+      logger.success(
+        `graft \u5B8C\u6210\uFF08${result.steps.filter((s) => s.status === "ok").length}/${result.steps.length} \u6B65\u6210\u529F\uFF09`
+      );
+    } else {
+      logger.warn("graft \u90E8\u5206\u5B8C\u6210\uFF08\u542B\u5931\u8D25\u6B65\u9AA4\uFF09\uFF0C\u8BE6\u89C1\u4E0A\u65B9\u660E\u7EC6\u3002");
+      const failed = result.steps.filter((s) => s.status === "fail");
+      for (const s of failed) {
+        logger.error(`  \u2716 ${s.name}: ${s.detail ?? "unknown error"}`);
+      }
+      process.exitCode = 1;
+    }
+  } catch (err) {
+    logger.error(`graft \u5931\u8D25\uFF1A${getErrorMessage(err)}`);
+    logger.debug(err.stack ?? "");
+    process.exitCode = 1;
+  }
+});
+
 // src/commands/restore/index.ts
+import { Command as Command40 } from "commander";
+import * as path46 from "path";
+import * as prompts8 from "@clack/prompts";
 init_logger();
 init_error();
 function createRestoreCommand() {
-  return new Command39("restore").description(
+  return new Command40("restore").description(
     "\u56DE\u6EDA .teamix-evo/ \u5230\u6307\u5B9A snapshot\uFF08init/update \u5931\u8D25\u65F6\u4F7F\u7528 \u2014 ADR 0019 \xA72\uFF09"
   ).argument("[ts]", "\u76EE\u6807 snapshot \u65F6\u95F4\u6233\uFF08\u5982 2026-06-11T20-59-03-000Z\uFF09").option("--list", "\u5217\u51FA\u53EF\u7528 snapshot\uFF08\u4E0D\u505A\u5B9E\u9645\u56DE\u6EDA\uFF09").option("--cwd <dir>", "\u6307\u5B9A\u5DE5\u7A0B\u6839\u76EE\u5F55\uFF08\u9ED8\u8BA4\uFF1A\u5F53\u524D\u76EE\u5F55\uFF09").option("-y, --yes", "\u8DF3\u8FC7\u4E8C\u6B21\u786E\u8BA4\uFF08destructive\uFF0C\u8BF7\u786E\u8BA4\u65E0\u8BEF\uFF09").action(async (ts, opts) => {
-    const cwd = path44.resolve(opts.cwd ?? process.cwd());
+    const cwd = path46.resolve(opts.cwd ?? process.cwd());
     try {
       const snapshots = await listSnapshots(cwd);
       if (opts.list) {
@@ -9856,10 +10421,10 @@ function createRestoreCommand() {
         logger.info(
           '\u56DE\u6EDA\u524D\u4F1A\u81EA\u52A8\u518D\u505A\u4E00\u6B21 reason="restore" \u7684\u5B89\u5168 snapshot\uFF0C\u53EF\u4E8C\u6B21\u56DE\u6EDA\u3002'
         );
-        const confirmed = await prompts7.confirm({
+        const confirmed = await prompts8.confirm({
           message: "\u7EE7\u7EED\u56DE\u6EDA\uFF1F"
         });
-        if (prompts7.isCancel(confirmed) || !confirmed) {
+        if (prompts8.isCancel(confirmed) || !confirmed) {
           logger.info("\u5DF2\u53D6\u6D88\u3002");
           return;
         }
@@ -9904,14 +10469,14 @@ function printSnapshotTable(snapshots) {
 }
 
 // src/commands/switch/index.ts
-import { Command as Command40 } from "commander";
-import * as path46 from "path";
-import * as prompts8 from "@clack/prompts";
+import { Command as Command41 } from "commander";
+import * as path48 from "path";
+import * as prompts9 from "@clack/prompts";
 
 // src/core/variant-switch.ts
 init_fs();
-import * as path45 from "path";
-import * as fs32 from "fs/promises";
+import * as path47 from "path";
+import * as fs33 from "fs/promises";
 import {
   loadTokensPackageManifest as loadTokensPackageManifest3,
   getVariantEntry as getVariantEntry3
@@ -9948,8 +10513,8 @@ async function runVariantSwitch(options) {
   const upstreamByBasename = /* @__PURE__ */ new Map();
   for (const fileRel of variantEntry.files) {
     upstreamByBasename.set(
-      path45.basename(fileRel),
-      path45.join(packageRoot, fileRel)
+      path47.basename(fileRel),
+      path47.join(packageRoot, fileRel)
     );
   }
   const prior = await readInstalledManifest(projectRoot) ?? {
@@ -9963,7 +10528,7 @@ async function runVariantSwitch(options) {
   const priorVersion = installedIdx >= 0 ? prior.installed[installedIdx].version : "0.0.0";
   const changes = [];
   for (const resource of priorResources) {
-    const consumerBasename = path45.basename(resource.target);
+    const consumerBasename = path47.basename(resource.target);
     const upstreamBasename = lookupUpstreamBasename2(consumerBasename);
     const upstreamAbs = upstreamBasename ? upstreamByBasename.get(upstreamBasename) : void 0;
     if (resource.strategy === "frozen") {
@@ -9984,7 +10549,7 @@ async function runVariantSwitch(options) {
       });
       continue;
     }
-    const upstreamContent = await fs32.readFile(upstreamAbs, "utf-8");
+    const upstreamContent = await fs33.readFile(upstreamAbs, "utf-8");
     if (resource.strategy === "regenerable") {
       const newHash = computeHash(upstreamContent);
       if (newHash === resource.hash) {
@@ -10037,12 +10602,12 @@ async function runVariantSwitch(options) {
   }
   const refreshedResources = [];
   for (const resource of priorResources) {
-    const consumerAbs = path45.isAbsolute(resource.target) ? resource.target : path45.join(projectRoot, resource.target);
-    const consumerBasename = path45.basename(resource.target);
+    const consumerAbs = path47.isAbsolute(resource.target) ? resource.target : path47.join(projectRoot, resource.target);
+    const consumerBasename = path47.basename(resource.target);
     const upstreamBasename = lookupUpstreamBasename2(consumerBasename);
     const upstreamAbs = upstreamBasename ? upstreamByBasename.get(upstreamBasename) : void 0;
     if (resource.strategy === "regenerable" && upstreamAbs) {
-      const upstreamContent = await fs32.readFile(upstreamAbs, "utf-8");
+      const upstreamContent = await fs33.readFile(upstreamAbs, "utf-8");
       await writeFileSafe(consumerAbs, upstreamContent);
       logger.debug(`[variant-switch] rewrite regenerable: ${resource.target}`);
       refreshedResources.push({
@@ -10052,8 +10617,8 @@ async function runVariantSwitch(options) {
       continue;
     }
     if (resource.strategy === "managed" && upstreamAbs && await fileExists(consumerAbs)) {
-      const upstreamContent = await fs32.readFile(upstreamAbs, "utf-8");
-      const consumerContent = await fs32.readFile(consumerAbs, "utf-8");
+      const upstreamContent = await fs33.readFile(upstreamAbs, "utf-8");
+      const consumerContent = await fs33.readFile(consumerAbs, "utf-8");
       const merged = mergeManagedRegions(upstreamContent, consumerContent);
       if (merged !== consumerContent) {
         await writeFileSafe(consumerAbs, merged);
@@ -10084,7 +10649,7 @@ async function runVariantSwitch(options) {
     installedAt: now
   };
   await writeFileSafe(
-    path45.join(projectRoot, ".teamix-evo", "tokens-lock.json"),
+    path47.join(projectRoot, ".teamix-evo", "tokens-lock.json"),
     JSON.stringify(lock, null, 2) + "\n"
   );
   logger.debug(
@@ -10201,10 +10766,10 @@ var KIND_LABEL = {
   unchanged: "unchanged"
 };
 function createSwitchCommand() {
-  return new Command40("switch").description(
+  return new Command41("switch").description(
     "variant \u5207\u6362\uFF1A\u5148\u5C55\u793A file-level diff\uFF0C--apply \u624D\u771F\u5199\uFF08ADR 0019 \xA7D3\uFF09"
   ).argument("<new-variant>", "\u76EE\u6807 variant id\uFF08\u5982 opentrek / uni-manager\uFF09").option("--cwd <dir>", "\u6307\u5B9A\u5DE5\u7A0B\u6839\u76EE\u5F55\uFF08\u9ED8\u8BA4\uFF1A\u5F53\u524D\u76EE\u5F55\uFF09").option("--apply", "\u771F\u6B63\u6267\u884C\u5207\u6362\uFF08\u9ED8\u8BA4 dry-run\uFF0C\u4EC5\u5C55\u793A\u8BA1\u5212\uFF09").option("-y, --yes", "\u8DF3\u8FC7 --apply \u4E8C\u6B21\u786E\u8BA4\uFF08destructive\uFF0C\u8BF7\u786E\u8BA4\u65E0\u8BEF\uFF09").action(async (newVariant, opts) => {
-    const cwd = path46.resolve(opts.cwd ?? process.cwd());
+    const cwd = path48.resolve(opts.cwd ?? process.cwd());
     const apply = opts.apply ?? false;
     try {
       const plan = await runVariantSwitch({
@@ -10250,10 +10815,10 @@ function createSwitchCommand() {
         logger.info(
           '\u6267\u884C\u524D\u4F1A\u81EA\u52A8\u6355\u83B7 reason="switch" snapshot\uFF0C\u53EF\u901A\u8FC7 `teamix-evo restore <ts>` \u56DE\u6EDA\u3002'
         );
-        const confirmed = await prompts8.confirm({
+        const confirmed = await prompts9.confirm({
           message: `\u7EE7\u7EED\u5207\u6362\u81F3 "${newVariant}"\uFF1F`
         });
-        if (prompts8.isCancel(confirmed) || !confirmed) {
+        if (prompts9.isCancel(confirmed) || !confirmed) {
           logger.info("\u5DF2\u53D6\u6D88\u3002");
           return;
         }
@@ -10320,7 +10885,7 @@ function printChangePlan(from, to, toVersion, changes) {
 // src/index.ts
 var require9 = createRequire9(import.meta.url);
 var { version } = require9("../package.json");
-var program = new Command41();
+var program = new Command42();
 program.name("teamix-evo").description("Where ideas evolve. \u2014 AI Coding \u5957\u4EF6").version(version);
 program.addCommand(tokensCommand);
 program.addCommand(skillsCommand);
@@ -10331,6 +10896,7 @@ program.addCommand(lintCommand);
 program.addCommand(initCommand5);
 program.addCommand(updateCommand5);
 program.addCommand(migrateCommand);
+program.addCommand(graftCommand);
 program.addCommand(restoreCommand);
 program.addCommand(switchCommand);
 function enableHelpAfterError(cmd) {