teamix-evo 0.15.6 → 0.17.0

package/dist/core/index.js

@@ -461,9 +461,9 @@ async function installSkills(options) {
 async function renderSkillFiles(skill, options) {
   const { data, packageRoot } = options;
   const sourceAbs = path7.resolve(packageRoot, skill.source);
-  const stat3 = await fs6.stat(sourceAbs);
+  const stat4 = await fs6.stat(sourceAbs);
   const rendered = /* @__PURE__ */ new Map();
-  if (stat3.isFile()) {
+  if (stat4.isFile()) {
     const content = await renderSkillContent(sourceAbs, skill, data);
     rendered.set("SKILL.md", content);
     return rendered;
@@ -726,13 +726,13 @@ async function pruneEmptyIdeSkillDirs(args) {
     }
     for (const name of entries) {
       const dir = path7.join(skillsRoot, name);
-      let stat3;
+      let stat4;
       try {
-        stat3 = await fs6.stat(dir);
+        stat4 = await fs6.stat(dir);
       } catch {
         continue;
       }
-      if (!stat3.isDirectory()) continue;
+      if (!stat4.isDirectory()) continue;
       let children;
       try {
         children = await fs6.readdir(dir);
@@ -2789,13 +2789,44 @@ async function detectProjectState2(cwd) {
       significantEntries: []
     };
   }
+  let legacyLib = "unknown";
+  let buildTool = "unknown";
+  let allDeps = {};
+  if (hasPackageJson) {
+    const pkgRaw = await readFileOrNull(path15.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(path15.join(absCwd, "build.json"))) {
+    buildTool = "ice";
+  } else if (await fileExists(path15.join(absCwd, "vite.config.ts")) || await fileExists(path15.join(absCwd, "vite.config.js")) || await fileExists(path15.join(absCwd, "vite.config.mts"))) {
+    buildTool = "vite";
+  } else if (await fileExists(path15.join(absCwd, "webpack.config.js")) || await fileExists(path15.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,
     hasComponentsJson,
-    significantEntries: significant.slice(0, 20).sort()
+    significantEntries: significant.slice(0, 20).sort(),
+    legacyLib,
+    buildTool
   };
 }
 
@@ -2803,7 +2834,8 @@ async function detectProjectState2(cwd) {
 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",
@@ -2814,13 +2846,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];
@@ -2834,13 +2867,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;
 }
@@ -2892,8 +2918,8 @@ var STYLELINT_CONFIG_CANDIDATES = [
 ];
 async function isDir(target) {
   try {
-    const stat3 = await fs15.stat(target);
-    return stat3.isDirectory();
+    const stat4 = await fs15.stat(target);
+    return stat4.isDirectory();
   } catch {
     return false;
   }
@@ -3117,8 +3143,30 @@ async function detectStylelintConfig(cwd) {
   };
 }
 
-// src/core/meta-installer.ts
+// src/core/html-theme-patch.ts
 import * as path17 from "path";
+async function patchHtmlDataTheme(projectRoot, variant) {
+  const htmlPath = path17.join(projectRoot, "index.html");
+  const content = await readFileOrNull(htmlPath);
+  if (content === null) {
+    return { status: "not-found", htmlPath };
+  }
+  if (/data-theme\s*=/.test(content)) {
+    return { status: "already-set", htmlPath };
+  }
+  const patched = content.replace(
+    /<html([^>]*)>/,
+    `<html$1 data-theme="${variant}">`
+  );
+  if (patched === content) {
+    return { status: "not-found", htmlPath };
+  }
+  await writeFileSafe(htmlPath, patched);
+  return { status: "patched", htmlPath };
+}
+
+// src/core/meta-installer.ts
+import * as path18 from "path";
 import * as fs16 from "fs/promises";
 import { createRequire as createRequire5 } from "module";
 import {
@@ -3129,11 +3177,11 @@ var require6 = createRequire5(import.meta.url);
 var META_DIR = "meta";
 function resolvePackageRoot4(packageName) {
   const pkgJsonPath = require6.resolve(`${packageName}/package.json`);
-  return path17.dirname(pkgJsonPath);
+  return path18.dirname(pkgJsonPath);
 }
 function getMetaDir(projectRoot, category) {
-  const base = path17.join(getTeamixDir(projectRoot), META_DIR);
-  return category ? path17.join(base, category) : base;
+  const base = path18.join(getTeamixDir(projectRoot), META_DIR);
+  return category ? path18.join(base, category) : base;
 }
 async function landUiMeta(projectRoot) {
   const packageRoot = resolvePackageRoot4("@teamix-evo/ui");
@@ -3147,7 +3195,7 @@ async function landUiMeta(projectRoot) {
 }
 async function landBizUiMeta(projectRoot, variant) {
   const packageRoot = resolvePackageRoot4("@teamix-evo/biz-ui");
-  const variantRoot = path17.join(packageRoot, "variants", variant);
+  const variantRoot = path18.join(packageRoot, "variants", variant);
   const manifest = await loadVariantUiPackageManifest2(variantRoot);
   return landManifestMeta({
     projectRoot,
@@ -3161,8 +3209,8 @@ async function landManifestMeta(opts) {
   await ensureTeamixDir(projectRoot);
   const metaDir = getMetaDir(projectRoot, category);
   await ensureDir(metaDir);
-  const manifestDest = path17.join(metaDir, "manifest.json");
-  const manifestSrc = path17.join(packageRoot, "manifest.json");
+  const manifestDest = path18.join(metaDir, "manifest.json");
+  const manifestSrc = path18.join(packageRoot, "manifest.json");
   await fs16.copyFile(manifestSrc, manifestDest);
   logger.debug(`meta: copied manifest.json \u2192 ${manifestDest}`);
   let written = 0;
@@ -3170,8 +3218,8 @@ async function landManifestMeta(opts) {
   for (const entry of manifest.entries) {
     if (!entry.meta) continue;
     total++;
-    const srcPath = path17.join(packageRoot, entry.meta);
-    const destPath = path17.join(metaDir, `${entry.id}.md`);
+    const srcPath = path18.join(packageRoot, entry.meta);
+    const destPath = path18.join(metaDir, `${entry.id}.md`);
     try {
       await fs16.copyFile(srcPath, destPath);
       written++;
@@ -3197,17 +3245,17 @@ async function landManifestMeta(opts) {
 
 // src/core/deps-install.ts
 import * as fs17 from "fs/promises";
-import * as path18 from "path";
+import * as path19 from "path";
 import { exec } from "child_process";
 import { promisify } from "util";
 var execAsync = promisify(exec);
 async function detectPackageManager(projectRoot) {
-  if (await fileExists(path18.join(projectRoot, "pnpm-lock.yaml"))) return "pnpm";
-  if (await fileExists(path18.join(projectRoot, "pnpm-workspace.yaml")))
+  if (await fileExists(path19.join(projectRoot, "pnpm-lock.yaml"))) return "pnpm";
+  if (await fileExists(path19.join(projectRoot, "pnpm-workspace.yaml")))
     return "pnpm";
-  if (await fileExists(path18.join(projectRoot, "bun.lockb"))) return "bun";
-  if (await fileExists(path18.join(projectRoot, "bun.lock"))) return "bun";
-  if (await fileExists(path18.join(projectRoot, "yarn.lock"))) return "yarn";
+  if (await fileExists(path19.join(projectRoot, "bun.lockb"))) return "bun";
+  if (await fileExists(path19.join(projectRoot, "bun.lock"))) return "bun";
+  if (await fileExists(path19.join(projectRoot, "yarn.lock"))) return "yarn";
   return "npm";
 }
 function getInstallCommand(pm) {
@@ -3224,7 +3272,7 @@ function getInstallCommand(pm) {
 }
 async function installProjectDeps(options) {
   const { projectRoot, npmDependencies, skipInstall = false } = options;
-  const pkgPath = path18.join(projectRoot, "package.json");
+  const pkgPath = path19.join(projectRoot, "package.json");
   const raw = await readFileOrNull(pkgPath);
   if (!raw) {
     throw new Error(
@@ -3316,18 +3364,18 @@ ${stepLines}
 
 // src/core/file-changes.ts
 import * as fs18 from "fs/promises";
-import * as path19 from "path";
+import * as path20 from "path";
 function toRelativePosix(p, projectRoot) {
   let rel2 = p;
-  if (path19.isAbsolute(p)) {
-    rel2 = path19.relative(projectRoot, p);
+  if (path20.isAbsolute(p)) {
+    rel2 = path20.relative(projectRoot, p);
   }
-  return rel2.split(path19.sep).join("/");
+  return rel2.split(path20.sep).join("/");
 }
 
 // src/core/project-init.ts
 import * as fsNode from "fs/promises";
-import * as path20 from "path";
+import * as path21 from "path";
 var CRITICAL_STEPS = /* @__PURE__ */ new Set([
   "tokens",
   "skills",
@@ -3395,6 +3443,38 @@ async function runProjectInit(options) {
       recordFailure("tokens", err);
     }
   }
+  if (dryRun) {
+    record({
+      name: "html-theme",
+      status: "planned",
+      detail: `patchHtmlDataTheme(variant=${variant})`
+    });
+  } else if (aborted) {
+    record({
+      name: "html-theme",
+      status: "skip",
+      detail: "aborted: earlier critical step failed"
+    });
+  } else {
+    try {
+      const htmlResult = await patchHtmlDataTheme(projectRoot, variant);
+      record({
+        name: "html-theme",
+        status: "ok",
+        detail: htmlResult.status,
+        changes: htmlResult.status === "patched" ? [
+          {
+            kind: "modified",
+            path: "index.html",
+            step: "html-theme",
+            detail: `data-theme="${variant}"`
+          }
+        ] : []
+      });
+    } catch (err) {
+      recordFailure("html-theme", err);
+    }
+  }
   if (dryRun) {
     record({
       name: "skills",
@@ -3669,7 +3749,7 @@ async function runProjectInit(options) {
           detail: "projectRoot does not exist"
         });
       } else {
-        const giPath = path20.join(projectRoot, ".gitignore");
+        const giPath = path21.join(projectRoot, ".gitignore");
         let giContent = "";
         try {
           giContent = await fsNode.readFile(giPath, "utf-8");
@@ -3729,12 +3809,12 @@ async function runProjectInit(options) {
   if (!dryRun && hasFailures) {
     try {
       const checklistContent = renderInitChecklist({ variant, status, steps });
-      const checklistPath = path20.join(
+      const checklistPath = path21.join(
         projectRoot,
         ".teamix-evo",
         "init-checklist.md"
       );
-      await fsNode.mkdir(path20.dirname(checklistPath), { recursive: true });
+      await fsNode.mkdir(path21.dirname(checklistPath), { recursive: true });
       await fsNode.writeFile(checklistPath, checklistContent, "utf-8");
       logger.info("  wrote .teamix-evo/init-checklist.md");
     } catch {
@@ -3773,9 +3853,438 @@ function deriveLintChanges(result) {
   return out;
 }
 
-// src/core/installer.ts
-import * as path21 from "path";
+// src/core/graft-init.ts
+import { hasManagedRegion as hasManagedRegion3, replaceManagedRegion as replaceManagedRegion3 } from "@teamix-evo/registry";
+
+// src/core/snapshot.ts
 import * as fs19 from "fs/promises";
+import * as path22 from "path";
+var TEAMIX_DIR2 = ".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 isoToFsSafe(iso) {
+  return iso.replace(/[:.]/g, "-");
+}
+function fsSafeToIso(safe) {
+  return safe.replace(
+    /^(\d{4}-\d{2}-\d{2})T(\d{2})-(\d{2})-(\d{2})-(\d{3})(Z)$/,
+    "$1T$2:$3:$4.$5$6"
+  );
+}
+async function createSnapshot(projectRoot, opts = {}) {
+  const teamixDir = path22.join(projectRoot, TEAMIX_DIR2);
+  try {
+    const stat4 = await fs19.stat(teamixDir);
+    if (!stat4.isDirectory()) return null;
+  } catch (err) {
+    if (err.code === "ENOENT") return null;
+    throw err;
+  }
+  const isoTs = (/* @__PURE__ */ new Date()).toISOString();
+  const ts = isoToFsSafe(isoTs);
+  const snapshotRoot = path22.join(teamixDir, SNAPSHOTS_DIR);
+  const target = path22.join(snapshotRoot, ts);
+  await fs19.mkdir(target, { recursive: true });
+  const entries = await fs19.readdir(teamixDir, { withFileTypes: true });
+  for (const entry of entries) {
+    if (entry.name === SNAPSHOTS_DIR) continue;
+    const src = path22.join(teamixDir, entry.name);
+    const dst = path22.join(target, entry.name);
+    await fs19.cp(src, dst, { recursive: true });
+  }
+  const meta = {
+    ts: isoTs,
+    reason: opts.reason ?? "manual"
+  };
+  await fs19.writeFile(
+    path22.join(target, META_FILE),
+    JSON.stringify(meta, null, 2) + "\n",
+    "utf-8"
+  );
+  logger.debug(
+    `Snapshot created \u2192 ${path22.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 = path22.join(projectRoot, TEAMIX_DIR2, SNAPSHOTS_DIR);
+  let entries;
+  try {
+    entries = await fs19.readdir(snapshotRoot, { withFileTypes: true });
+  } catch (err) {
+    if (err.code === "ENOENT") return [];
+    throw err;
+  }
+  const result = [];
+  for (const entry of entries) {
+    if (!entry.isDirectory()) continue;
+    const dir = path22.join(snapshotRoot, entry.name);
+    let isoTs = null;
+    let reason = null;
+    try {
+      const raw = await fs19.readFile(path22.join(dir, META_FILE), "utf-8");
+      const parsed = JSON.parse(raw);
+      if (typeof parsed.ts === "string") isoTs = parsed.ts;
+      if (typeof parsed.reason === "string" && SNAPSHOT_REASONS.includes(
+        parsed.reason
+      )) {
+        reason = parsed.reason;
+      }
+    } catch {
+      isoTs = fsSafeToIso(entry.name);
+    }
+    result.push({ ts: entry.name, isoTs, reason, path: dir });
+  }
+  result.sort((a, b) => a.ts < b.ts ? 1 : a.ts > b.ts ? -1 : 0);
+  return result;
+}
+async function pruneSnapshots(projectRoot, keep = DEFAULT_KEEP, opts = {}) {
+  if (keep < 0)
+    throw new Error(`pruneSnapshots: keep must be >= 0, got ${keep}`);
+  const snapshots = await listSnapshots(projectRoot);
+  if (snapshots.length <= keep) return [];
+  const tail = snapshots.slice(keep);
+  const toRemove = opts.protectedTs ? tail.filter((s) => s.ts !== opts.protectedTs) : tail;
+  const removed = [];
+  for (const snap of toRemove) {
+    await fs19.rm(snap.path, { recursive: true, force: true });
+    removed.push(snap.ts);
+    logger.debug(`Pruned snapshot ${snap.ts}`);
+  }
+  return removed.reverse();
+}
+
+// src/core/graft-init.ts
+import * as fsNode2 from "fs/promises";
+import * as path23 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 = path23.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 (hasManagedRegion3(existing, AGENTS_MD_GRAFT_MANAGED_ID)) {
+        output = replaceManagedRegion3(
+          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 = path23.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/core/installer.ts
+import * as path24 from "path";
+import * as fs20 from "fs/promises";
 async function installResources(options) {
   const { projectRoot, manifest, data, variantDir, packageRoot } = options;
   const installedResources = [];
@@ -3812,13 +4321,13 @@ async function installSingleResource(resource, projectRoot, data, variantDir, pa
     variantDir,
     packageRoot
   );
-  const targetPath = path21.join(projectRoot, resource.target);
+  const targetPath = path24.join(projectRoot, resource.target);
   let content;
   if (resource.template) {
     const templateContent = await loadTemplateFile(sourcePath);
     content = renderTemplate(templateContent, data);
   } else {
-    content = await fs19.readFile(sourcePath, "utf-8");
+    content = await fs20.readFile(sourcePath, "utf-8");
   }
   await writeFileSafe(targetPath, content);
   const hash = computeHash(content);
@@ -3836,13 +4345,13 @@ async function installRecursiveResource(resource, projectRoot, data, variantDir,
     variantDir,
     packageRoot
   );
-  const targetDir = path21.join(projectRoot, resource.target);
+  const targetDir = path24.join(projectRoot, resource.target);
   const results = [];
   await ensureDir(targetDir);
   const entries = await walkDir(sourcePath);
   for (const entry of entries) {
-    const relPath = path21.relative(sourcePath, entry);
-    let targetFile = path21.join(targetDir, relPath);
+    const relPath = path24.relative(sourcePath, entry);
+    let targetFile = path24.join(targetDir, relPath);
     if (resource.template && targetFile.endsWith(".hbs")) {
       targetFile = targetFile.slice(0, -4);
     }
@@ -3851,11 +4360,11 @@ async function installRecursiveResource(resource, projectRoot, data, variantDir,
       const templateContent = await loadTemplateFile(entry);
       content = renderTemplate(templateContent, data);
     } else {
-      content = await fs19.readFile(entry, "utf-8");
+      content = await fs20.readFile(entry, "utf-8");
     }
     await writeFileSafe(targetFile, content);
     const hash = computeHash(content);
-    const targetRel = path21.relative(projectRoot, targetFile);
+    const targetRel = path24.relative(projectRoot, targetFile);
     results.push({
       id: `${resource.id}:${relPath}`,
       target: targetRel,
@@ -3868,25 +4377,25 @@ async function installRecursiveResource(resource, projectRoot, data, variantDir,
 }
 
 // src/core/registry-client.ts
-import * as path22 from "path";
-import * as fs20 from "fs/promises";
+import * as path25 from "path";
+import * as fs21 from "fs/promises";
 import { createRequire as createRequire6 } from "module";
 import { loadVariantManifest } from "@teamix-evo/registry";
 var require7 = createRequire6(import.meta.url);
 function resolvePackageRoot5(packageName) {
   const pkgJsonPath = require7.resolve(`${packageName}/package.json`);
-  return path22.dirname(pkgJsonPath);
+  return path25.dirname(pkgJsonPath);
 }
 async function loadVariantData(packageName, variant) {
   const packageRoot = resolvePackageRoot5(packageName);
-  const variantDir = path22.join(packageRoot, "library", variant);
+  const variantDir = path25.join(packageRoot, "library", variant);
   logger.debug(`Resolved variant dir: ${variantDir}`);
   logger.debug(`Package root: ${packageRoot}`);
   const manifest = await loadVariantManifest(variantDir);
   let data = {};
-  const dataPath = path22.join(variantDir, "_data.json");
+  const dataPath = path25.join(variantDir, "_data.json");
   try {
-    const raw = await fs20.readFile(dataPath, "utf-8");
+    const raw = await fs21.readFile(dataPath, "utf-8");
     data = JSON.parse(raw);
   } catch (err) {
     if (err.code !== "ENOENT") {
@@ -3922,6 +4431,7 @@ export {
   removeUiFiles,
   runBizUiAdd,
   runGenerateAgentsMd,
+  runGraftInit,
   runLintInit,
   runProjectInit,
   runSkillsAdd,