teamix-evo 0.16.0 → 0.17.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);
@@ -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,19 +9685,162 @@ 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 path43 from "path";
+import * as fs31 from "fs/promises";
+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(path43.join(cwd, c))) return c;
+  }
+  return null;
+}
+async function getLegacyLibVersion(cwd, legacyLib) {
+  const pkgRaw = await readFileOrNull(path43.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 = path43.join(cwd, entry.path);
+    try {
+      const stat6 = await fs31.stat(full);
+      if (entry.type === "directory" && stat6.isDirectory() || entry.type === "file" && stat6.isFile()) {
+        conflicts.push(entry);
+      }
+    } catch {
+    }
+  }
+  return conflicts;
+}
+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").action(async (opts) => {
+  const cwd = path43.resolve(opts.cwd ?? process.cwd());
+  try {
+    const state = await detectProjectState(cwd);
+    if (state.state !== "other") {
+      assertCommandPrecondition("graft", state.state);
+      return;
+    }
+    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);
+    const report = {
+      projectRoot: cwd,
+      legacyLib: { name: legacyLib, version: legacyVersion },
+      buildTool: { type: buildTool, configFile: buildToolConfig },
+      postcssConfig: { exists: postcssPath !== null, path: postcssPath },
+      appEntry,
+      conflicts
+    };
+    if (opts.json) {
+      console.log(JSON.stringify(report, null, 2));
+    } else {
+      logger.info("Teamix Evo Graft \u2014 \u53CC\u6808\u5171\u5B58\u524D\u7F6E\u68C0\u67E5");
+      logger.info("");
+      logger.info(`  \u9879\u76EE\u76EE\u5F55\uFF1A${cwd}`);
+      logger.info(
+        `  \u65E7\u7EC4\u4EF6\u5E93\uFF1A${legacyLib} (${legacyVersion})`
+      );
+      logger.info(`  \u6784\u5EFA\u5DE5\u5177\uFF1A${buildTool}`);
+      logger.info(
+        `  PostCSS \u914D\u7F6E\uFF1A${postcssPath ?? "\u672A\u68C0\u6D4B\u5230"}`
+      );
+      logger.info(`  App \u5165\u53E3\uFF1A${appEntry ?? "\u672A\u68C0\u6D4B\u5230"}`);
+      if (conflicts.length > 0) {
+        logger.info("");
+        logger.warn("  \u5DF2\u5B58\u5728\u7684\u8DEF\u5F84\uFF08\u53EF\u80FD\u51B2\u7A81\uFF09\uFF1A");
+        for (const c of conflicts) {
+          logger.warn(`    ${c.path} (${c.type})`);
+        }
+      }
+      logger.info("");
+      logger.info(
+        "\u524D\u7F6E\u68C0\u67E5\u901A\u8FC7\u3002\u8BF7\u5728 AI IDE \u4E2D\u89E6\u53D1 teamix-evo-manage skill \u4EE5\u5F15\u5BFC graft \u6D41\u7A0B\u3002"
+      );
+      logger.info(
+        "CLI \u4EC5\u505A\u524D\u7F6E\u68C0\u67E5\uFF0C\u5B9E\u9645 graft \u7531 AI skill \u9A71\u52A8\u3002"
+      );
+    }
+  } catch (err) {
+    logger.error(`graft \u524D\u7F6E\u68C0\u67E5\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 path45 from "path";
 import * as prompts7 from "@clack/prompts";
 
 // src/core/snapshot.ts
 init_logger();
-import * as fs31 from "fs/promises";
-import * as path43 from "path";
+import * as fs32 from "fs/promises";
+import * as path44 from "path";
 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, "-");
 }
@@ -9682,47 +9851,47 @@ function fsSafeToIso(safe) {
   );
 }
 async function createSnapshot(projectRoot, opts = {}) {
-  const teamixDir = path43.join(projectRoot, TEAMIX_DIR6);
+  const teamixDir = path44.join(projectRoot, TEAMIX_DIR6);
   try {
-    const stat5 = await fs31.stat(teamixDir);
-    if (!stat5.isDirectory()) return null;
+    const stat6 = await fs32.stat(teamixDir);
+    if (!stat6.isDirectory()) return null;
   } catch (err) {
     if (err.code === "ENOENT") return null;
     throw err;
   }
   const isoTs = (/* @__PURE__ */ new Date()).toISOString();
   const ts = isoToFsSafe3(isoTs);
-  const snapshotRoot = path43.join(teamixDir, SNAPSHOTS_DIR);
-  const target = path43.join(snapshotRoot, ts);
-  await fs31.mkdir(target, { recursive: true });
-  const entries = await fs31.readdir(teamixDir, { withFileTypes: true });
+  const snapshotRoot = path44.join(teamixDir, SNAPSHOTS_DIR);
+  const target = path44.join(snapshotRoot, ts);
+  await fs32.mkdir(target, { recursive: true });
+  const entries = await fs32.readdir(teamixDir, { withFileTypes: true });
   for (const entry of entries) {
     if (entry.name === SNAPSHOTS_DIR) continue;
-    const src = path43.join(teamixDir, entry.name);
-    const dst = path43.join(target, entry.name);
-    await fs31.cp(src, dst, { recursive: true });
+    const src = path44.join(teamixDir, entry.name);
+    const dst = path44.join(target, entry.name);
+    await fs32.cp(src, dst, { recursive: true });
   }
   const meta = {
     ts: isoTs,
     reason: opts.reason ?? "manual"
   };
-  await fs31.writeFile(
-    path43.join(target, META_FILE),
+  await fs32.writeFile(
+    path44.join(target, META_FILE),
     JSON.stringify(meta, null, 2) + "\n",
     "utf-8"
   );
   logger.debug(
-    `Snapshot created \u2192 ${path43.relative(projectRoot, target)} (${meta.reason})`
+    `Snapshot created \u2192 ${path44.relative(projectRoot, target)} (${meta.reason})`
   );
   const keep = opts.keep ?? DEFAULT_KEEP;
   await pruneSnapshots(projectRoot, keep, { protectedTs: opts.protectedTs });
   return { ts, path: target };
 }
 async function listSnapshots(projectRoot) {
-  const snapshotRoot = path43.join(projectRoot, TEAMIX_DIR6, SNAPSHOTS_DIR);
+  const snapshotRoot = path44.join(projectRoot, TEAMIX_DIR6, SNAPSHOTS_DIR);
   let entries;
   try {
-    entries = await fs31.readdir(snapshotRoot, { withFileTypes: true });
+    entries = await fs32.readdir(snapshotRoot, { withFileTypes: true });
   } catch (err) {
     if (err.code === "ENOENT") return [];
     throw err;
@@ -9730,14 +9899,14 @@ async function listSnapshots(projectRoot) {
   const result = [];
   for (const entry of entries) {
     if (!entry.isDirectory()) continue;
-    const dir = path43.join(snapshotRoot, entry.name);
+    const dir = path44.join(snapshotRoot, entry.name);
     let isoTs = null;
     let reason = null;
     try {
-      const raw = await fs31.readFile(path43.join(dir, META_FILE), "utf-8");
+      const raw = await fs32.readFile(path44.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;
@@ -9759,18 +9928,18 @@ async function pruneSnapshots(projectRoot, keep = DEFAULT_KEEP, opts = {}) {
   const toRemove = opts.protectedTs ? tail.filter((s) => s.ts !== opts.protectedTs) : tail;
   const removed = [];
   for (const snap of toRemove) {
-    await fs31.rm(snap.path, { recursive: true, force: true });
+    await fs32.rm(snap.path, { recursive: true, force: true });
     removed.push(snap.ts);
     logger.debug(`Pruned snapshot ${snap.ts}`);
   }
   return removed.reverse();
 }
 async function restoreSnapshot(projectRoot, ts) {
-  const snapshotRoot = path43.join(projectRoot, TEAMIX_DIR6, SNAPSHOTS_DIR);
-  const target = path43.join(snapshotRoot, ts);
+  const snapshotRoot = path44.join(projectRoot, TEAMIX_DIR6, SNAPSHOTS_DIR);
+  const target = path44.join(snapshotRoot, ts);
   try {
-    const stat5 = await fs31.stat(target);
-    if (!stat5.isDirectory()) {
+    const stat6 = await fs32.stat(target);
+    if (!stat6.isDirectory()) {
       throw new Error(`Snapshot path is not a directory: ${target}`);
     }
   } catch (err) {
@@ -9782,21 +9951,21 @@ async function restoreSnapshot(projectRoot, ts) {
     throw err;
   }
   await createSnapshot(projectRoot, { reason: "restore", protectedTs: ts });
-  const teamixDir = path43.join(projectRoot, TEAMIX_DIR6);
-  const live = await fs31.readdir(teamixDir, { withFileTypes: true });
+  const teamixDir = path44.join(projectRoot, TEAMIX_DIR6);
+  const live = await fs32.readdir(teamixDir, { withFileTypes: true });
   for (const entry of live) {
     if (entry.name === SNAPSHOTS_DIR) continue;
-    await fs31.rm(path43.join(teamixDir, entry.name), {
+    await fs32.rm(path44.join(teamixDir, entry.name), {
       recursive: true,
       force: true
     });
   }
-  const snapshotEntries = await fs31.readdir(target, { withFileTypes: true });
+  const snapshotEntries = await fs32.readdir(target, { withFileTypes: true });
   for (const entry of snapshotEntries) {
     if (entry.name === META_FILE) continue;
-    const src = path43.join(target, entry.name);
-    const dst = path43.join(teamixDir, entry.name);
-    await fs31.cp(src, dst, { recursive: true });
+    const src = path44.join(target, entry.name);
+    const dst = path44.join(teamixDir, entry.name);
+    await fs32.cp(src, dst, { recursive: true });
   }
   logger.debug(`Restored .teamix-evo/ from snapshot ${ts}`);
 }
@@ -9805,10 +9974,10 @@ async function restoreSnapshot(projectRoot, ts) {
 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 = path45.resolve(opts.cwd ?? process.cwd());
     try {
       const snapshots = await listSnapshots(cwd);
       if (opts.list) {
@@ -9904,14 +10073,14 @@ function printSnapshotTable(snapshots) {
 }
 
 // src/commands/switch/index.ts
-import { Command as Command40 } from "commander";
-import * as path46 from "path";
+import { Command as Command41 } from "commander";
+import * as path47 from "path";
 import * as prompts8 from "@clack/prompts";
 
 // src/core/variant-switch.ts
 init_fs();
-import * as path45 from "path";
-import * as fs32 from "fs/promises";
+import * as path46 from "path";
+import * as fs33 from "fs/promises";
 import {
   loadTokensPackageManifest as loadTokensPackageManifest3,
   getVariantEntry as getVariantEntry3
@@ -9948,8 +10117,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)
+      path46.basename(fileRel),
+      path46.join(packageRoot, fileRel)
     );
   }
   const prior = await readInstalledManifest(projectRoot) ?? {
@@ -9963,7 +10132,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 = path46.basename(resource.target);
     const upstreamBasename = lookupUpstreamBasename2(consumerBasename);
     const upstreamAbs = upstreamBasename ? upstreamByBasename.get(upstreamBasename) : void 0;
     if (resource.strategy === "frozen") {
@@ -9984,7 +10153,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 +10206,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 = path46.isAbsolute(resource.target) ? resource.target : path46.join(projectRoot, resource.target);
+    const consumerBasename = path46.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 +10221,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 +10253,7 @@ async function runVariantSwitch(options) {
     installedAt: now
   };
   await writeFileSafe(
-    path45.join(projectRoot, ".teamix-evo", "tokens-lock.json"),
+    path46.join(projectRoot, ".teamix-evo", "tokens-lock.json"),
     JSON.stringify(lock, null, 2) + "\n"
   );
   logger.debug(
@@ -10201,10 +10370,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 = path47.resolve(opts.cwd ?? process.cwd());
     const apply = opts.apply ?? false;
     try {
       const plan = await runVariantSwitch({
@@ -10320,7 +10489,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 +10500,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) {