teamix-evo 0.1.0 → 0.2.0

package/dist/index.js

@@ -1,59 +1,138 @@
 #!/usr/bin/env node
-var __defProp = Object.defineProperty;
-var __getOwnPropNames = Object.getOwnPropertyNames;
-var __esm = (fn, res) => function __init() {
-  return fn && (res = (0, fn[__getOwnPropNames(fn)[0]])(fn = 0)), res;
+
+// src/index.ts
+import { Command as Command15 } from "commander";
+import { createRequire as createRequire4 } from "module";
+
+// src/commands/design/index.ts
+import { Command as Command5 } from "commander";
+
+// src/commands/design/init.ts
+import { Command } from "commander";
+
+// src/ide/QoderAdapter.ts
+import * as os from "os";
+import * as path from "path";
+var QoderAdapter = class {
+  kind = "qoder";
+  name = "qoder";
+  getProjectRoot() {
+    return process.cwd();
+  }
+  detectIde() {
+    return true;
+  }
+  getSkillTargetDir(skillName, scope, projectRoot) {
+    const base = scope === "global" ? path.join(os.homedir(), ".qoder") : path.join(projectRoot ?? this.getProjectRoot(), ".qoder");
+    return path.join(base, "skills", skillName);
+  }
 };
-var __export = (target, all) => {
-  for (var name in all)
-    __defProp(target, name, { get: all[name], enumerable: true });
+
+// src/ide/ClaudeAdapter.ts
+import * as os2 from "os";
+import * as path2 from "path";
+var ClaudeAdapter = class {
+  kind = "claude";
+  name = "claude";
+  getProjectRoot() {
+    return process.cwd();
+  }
+  detectIde() {
+    return Boolean(process.env.CLAUDECODE);
+  }
+  getSkillTargetDir(skillName, scope, projectRoot) {
+    const base = scope === "global" ? path2.join(os2.homedir(), ".claude") : path2.join(projectRoot ?? this.getProjectRoot(), ".claude");
+    return path2.join(base, "skills", skillName);
+  }
 };
 
+// src/ide/index.ts
+var ALL_IDE_KINDS = ["qoder", "claude"];
+function getAdapter(kind) {
+  switch (kind) {
+    case "qoder":
+      return new QoderAdapter();
+    case "claude":
+      return new ClaudeAdapter();
+    default: {
+      const _exhaustive = kind;
+      throw new Error(`Unsupported IDE kind: ${_exhaustive}`);
+    }
+  }
+}
+function detectIde() {
+  const claude = new ClaudeAdapter();
+  if (claude.detectIde()) return claude;
+  return new QoderAdapter();
+}
+
+// src/core/registry-client.ts
+import * as path3 from "path";
+import * as fs from "fs/promises";
+import { createRequire } from "module";
+import { loadVariantManifest } from "@teamix-evo/registry";
+
 // src/utils/logger.ts
 import { red, yellow, cyan, green, gray } from "kolorist";
-var isDebug, logger;
-var init_logger = __esm({
-  "src/utils/logger.ts"() {
-    "use strict";
-    isDebug = process.env.TEAMIX_DEBUG === "1";
-    logger = {
-      info(msg) {
-        console.log(cyan("\u2139"), msg);
-      },
-      warn(msg) {
-        console.warn(yellow("\u26A0"), msg);
-      },
-      error(msg) {
-        console.error(red("\u2716"), msg);
-      },
-      success(msg) {
-        console.log(green("\u2714"), msg);
-      },
-      debug(msg) {
-        if (isDebug) {
-          console.log(gray("\u22A1"), gray(msg));
-        }
-      }
-    };
+var isDebug = process.env.TEAMIX_DEBUG === "1";
+var logger = {
+  info(msg) {
+    console.log(cyan("\u2139"), msg);
+  },
+  warn(msg) {
+    console.warn(yellow("\u26A0"), msg);
+  },
+  error(msg) {
+    console.error(red("\u2716"), msg);
+  },
+  success(msg) {
+    console.log(green("\u2714"), msg);
+  },
+  debug(msg) {
+    if (isDebug) {
+      console.log(gray("\u22A1"), gray(msg));
+    }
   }
-});
+};
+
+// src/core/registry-client.ts
+var require2 = createRequire(import.meta.url);
+function resolvePackageRoot(packageName) {
+  const pkgJsonPath = require2.resolve(`${packageName}/package.json`);
+  return path3.dirname(pkgJsonPath);
+}
+async function loadVariantData(packageName, variant) {
+  const packageRoot = resolvePackageRoot(packageName);
+  const variantDir = path3.join(packageRoot, "library", variant);
+  logger.debug(`Resolved variant dir: ${variantDir}`);
+  logger.debug(`Package root: ${packageRoot}`);
+  const manifest = await loadVariantManifest(variantDir);
+  let data = {};
+  const dataPath = path3.join(variantDir, "_data.json");
+  try {
+    const raw = await fs.readFile(dataPath, "utf-8");
+    data = JSON.parse(raw);
+  } catch (err) {
+    if (err.code !== "ENOENT") {
+      throw err;
+    }
+    logger.debug(`No _data.json found at ${dataPath}, using empty data`);
+  }
+  return { manifest, data, variantDir, packageRoot };
+}
+
+// src/core/installer.ts
+import * as path6 from "path";
+import * as fs5 from "fs/promises";
 
 // src/utils/fs.ts
-var fs_exports = {};
-__export(fs_exports, {
-  backupFile: () => backupFile,
-  ensureDir: () => ensureDir,
-  fileExists: () => fileExists,
-  readFileOrNull: () => readFileOrNull,
-  writeFileSafe: () => writeFileSafe
-});
 import * as fs2 from "fs/promises";
-import * as path2 from "path";
+import * as path4 from "path";
 async function ensureDir(dir) {
   await fs2.mkdir(dir, { recursive: true });
 }
 async function writeFileSafe(filePath, content) {
-  const dir = path2.dirname(filePath);
+  const dir = path4.dirname(filePath);
   await ensureDir(dir);
   const tmp = filePath + ".tmp";
   await fs2.writeFile(tmp, content, "utf-8");
@@ -75,17 +154,17 @@ async function backupFile(filePath, projectRoot) {
     logger.debug(`Skip backup: ${filePath} does not exist`);
     return;
   }
-  const rel = path2.relative(projectRoot, filePath);
+  const rel2 = path4.relative(projectRoot, filePath);
   const timestamp = (/* @__PURE__ */ new Date()).toISOString().replace(/[:.]/g, "-");
-  const backupPath = path2.join(
+  const backupPath = path4.join(
     projectRoot,
     ".teamix-evo",
     ".backups",
-    `${rel}.${timestamp}.bak`
+    `${rel2}.${timestamp}.bak`
   );
-  await ensureDir(path2.dirname(backupPath));
+  await ensureDir(path4.dirname(backupPath));
   await fs2.writeFile(backupPath, content, "utf-8");
-  logger.debug(`Backed up ${rel} \u2192 ${path2.relative(projectRoot, backupPath)}`);
+  logger.debug(`Backed up ${rel2} \u2192 ${path4.relative(projectRoot, backupPath)}`);
 }
 async function fileExists(filePath) {
   try {
@@ -95,76 +174,6 @@ async function fileExists(filePath) {
     return false;
   }
 }
-var init_fs = __esm({
-  "src/utils/fs.ts"() {
-    "use strict";
-    init_logger();
-  }
-});
-
-// src/index.ts
-import { Command as Command5 } from "commander";
-
-// src/commands/design/index.ts
-import { Command as Command4 } from "commander";
-
-// src/commands/design/init.ts
-import { Command } from "commander";
-
-// src/ide/QoderAdapter.ts
-var QoderAdapter = class {
-  name = "qoder";
-  getProjectRoot() {
-    return process.cwd();
-  }
-  detectIde() {
-    return true;
-  }
-};
-
-// src/ide/index.ts
-function detectIde() {
-  return new QoderAdapter();
-}
-
-// src/core/registry-client.ts
-init_logger();
-import * as path from "path";
-import * as fs from "fs/promises";
-import { createRequire } from "module";
-import { loadVariantManifest } from "@teamix-evo/registry";
-function resolveVariantPackage(packageName, variant) {
-  const require2 = createRequire(import.meta.url);
-  const pkgJsonPath = require2.resolve(`${packageName}/package.json`);
-  const pkgRoot = path.dirname(pkgJsonPath);
-  return path.join(pkgRoot, "library", variant);
-}
-async function loadVariantData(packageName, variant) {
-  const variantDir = resolveVariantPackage(packageName, variant);
-  const require2 = createRequire(import.meta.url);
-  const pkgJsonPath = require2.resolve(`${packageName}/package.json`);
-  const packageRoot = path.dirname(pkgJsonPath);
-  logger.debug(`Resolved variant dir: ${variantDir}`);
-  logger.debug(`Package root: ${packageRoot}`);
-  const manifest = await loadVariantManifest(variantDir);
-  let data = {};
-  const dataPath = path.join(variantDir, "_data.json");
-  try {
-    const raw = await fs.readFile(dataPath, "utf-8");
-    data = JSON.parse(raw);
-  } catch (err) {
-    if (err.code !== "ENOENT") {
-      throw err;
-    }
-    logger.debug(`No _data.json found at ${dataPath}, using empty data`);
-  }
-  return { manifest, data, variantDir, packageRoot };
-}
-
-// src/core/installer.ts
-init_fs();
-import * as path3 from "path";
-import * as fs4 from "fs/promises";
 
 // src/utils/hash.ts
 import { createHash } from "crypto";
@@ -179,16 +188,52 @@ import * as fs3 from "fs/promises";
 Handlebars.registerHelper("lowercase", (str) => {
   return typeof str === "string" ? str.toLowerCase() : String(str ?? "").toLowerCase();
 });
+var compiledCache = /* @__PURE__ */ new Map();
+var MAX_CACHE_SIZE = 64;
+function getCompiledTemplate(templateContent) {
+  let compiled = compiledCache.get(templateContent);
+  if (!compiled) {
+    if (compiledCache.size >= MAX_CACHE_SIZE) {
+      const firstKey = compiledCache.keys().next().value;
+      compiledCache.delete(firstKey);
+    }
+    compiled = Handlebars.compile(templateContent, { noEscape: true });
+    compiledCache.set(templateContent, compiled);
+  }
+  return compiled;
+}
 function renderTemplate(templateContent, data) {
-  const compiled = Handlebars.compile(templateContent, { noEscape: true });
+  const compiled = getCompiledTemplate(templateContent);
   return compiled(data);
 }
 async function loadTemplateFile(filePath) {
   return fs3.readFile(filePath, "utf-8");
 }
 
+// src/utils/path.ts
+import * as path5 from "path";
+import * as fs4 from "fs/promises";
+function resolveSourcePath(source, variantDir, packageRoot) {
+  if (source.startsWith("_template/")) {
+    return path5.join(packageRoot, source);
+  }
+  return path5.join(variantDir, source);
+}
+async function walkDir(dir) {
+  const files = [];
+  const entries = await fs4.readdir(dir, { withFileTypes: true });
+  for (const entry of entries) {
+    const fullPath = path5.join(dir, entry.name);
+    if (entry.isDirectory()) {
+      files.push(...await walkDir(fullPath));
+    } else if (entry.isFile()) {
+      files.push(fullPath);
+    }
+  }
+  return files;
+}
+
 // src/core/installer.ts
-init_logger();
 async function installResources(options) {
   const { projectRoot, manifest, data, variantDir, packageRoot } = options;
   const installedResources = [];
@@ -220,14 +265,18 @@ async function installResources(options) {
   };
 }
 async function installSingleResource(resource, projectRoot, data, variantDir, packageRoot) {
-  const sourcePath = resolveSourcePath(resource.source, variantDir, packageRoot);
-  const targetPath = path3.join(projectRoot, resource.target);
+  const sourcePath = resolveSourcePath(
+    resource.source,
+    variantDir,
+    packageRoot
+  );
+  const targetPath = path6.join(projectRoot, resource.target);
   let content;
   if (resource.template) {
     const templateContent = await loadTemplateFile(sourcePath);
     content = renderTemplate(templateContent, data);
   } else {
-    content = await fs4.readFile(sourcePath, "utf-8");
+    content = await fs5.readFile(sourcePath, "utf-8");
   }
   await writeFileSafe(targetPath, content);
   const hash = computeHash(content);
@@ -240,14 +289,18 @@ async function installSingleResource(resource, projectRoot, data, variantDir, pa
   };
 }
 async function installRecursiveResource(resource, projectRoot, data, variantDir, packageRoot) {
-  const sourcePath = resolveSourcePath(resource.source, variantDir, packageRoot);
-  const targetDir = path3.join(projectRoot, resource.target);
+  const sourcePath = resolveSourcePath(
+    resource.source,
+    variantDir,
+    packageRoot
+  );
+  const targetDir = path6.join(projectRoot, resource.target);
   const results = [];
   await ensureDir(targetDir);
   const entries = await walkDir(sourcePath);
   for (const entry of entries) {
-    const relPath = path3.relative(sourcePath, entry);
-    let targetFile = path3.join(targetDir, relPath);
+    const relPath = path6.relative(sourcePath, entry);
+    let targetFile = path6.join(targetDir, relPath);
     if (resource.template && targetFile.endsWith(".hbs")) {
       targetFile = targetFile.slice(0, -4);
     }
@@ -256,11 +309,11 @@ async function installRecursiveResource(resource, projectRoot, data, variantDir,
       const templateContent = await loadTemplateFile(entry);
       content = renderTemplate(templateContent, data);
     } else {
-      content = await fs4.readFile(entry, "utf-8");
+      content = await fs5.readFile(entry, "utf-8");
     }
     await writeFileSafe(targetFile, content);
     const hash = computeHash(content);
-    const targetRel = path3.relative(projectRoot, targetFile);
+    const targetRel = path6.relative(projectRoot, targetFile);
     results.push({
       id: `${resource.id}:${relPath}`,
       target: targetRel,
@@ -271,36 +324,15 @@ async function installRecursiveResource(resource, projectRoot, data, variantDir,
   }
   return results;
 }
-function resolveSourcePath(source, variantDir, packageRoot) {
-  if (source.startsWith("_template/")) {
-    return path3.join(packageRoot, source);
-  }
-  return path3.join(variantDir, source);
-}
-async function walkDir(dir) {
-  const files = [];
-  const entries = await fs4.readdir(dir, { withFileTypes: true });
-  for (const entry of entries) {
-    const fullPath = path3.join(dir, entry.name);
-    if (entry.isDirectory()) {
-      files.push(...await walkDir(fullPath));
-    } else if (entry.isFile()) {
-      files.push(fullPath);
-    }
-  }
-  return files;
-}
 
 // src/core/state.ts
-init_fs();
-init_logger();
-import * as path4 from "path";
+import * as path7 from "path";
 import { validateConfig, validateInstalled } from "@teamix-evo/registry";
 var TEAMIX_DIR = ".teamix-evo";
 var CONFIG_FILE = "config.json";
 var MANIFEST_FILE = "manifest.json";
 function getTeamixDir(projectRoot) {
-  return path4.join(projectRoot, TEAMIX_DIR);
+  return path7.join(projectRoot, TEAMIX_DIR);
 }
 async function ensureTeamixDir(projectRoot) {
   const dir = getTeamixDir(projectRoot);
@@ -308,7 +340,7 @@ async function ensureTeamixDir(projectRoot) {
   return dir;
 }
 async function readProjectConfig(projectRoot) {
-  const configPath = path4.join(projectRoot, TEAMIX_DIR, CONFIG_FILE);
+  const configPath = path7.join(projectRoot, TEAMIX_DIR, CONFIG_FILE);
   const raw = await readFileOrNull(configPath);
   if (raw === null) return null;
   try {
@@ -325,12 +357,12 @@ async function readProjectConfig(projectRoot) {
   }
 }
 async function writeProjectConfig(projectRoot, config) {
-  const configPath = path4.join(projectRoot, TEAMIX_DIR, CONFIG_FILE);
+  const configPath = path7.join(projectRoot, TEAMIX_DIR, CONFIG_FILE);
   await writeFileSafe(configPath, JSON.stringify(config, null, 2) + "\n");
   logger.debug(`Wrote config \u2192 ${configPath}`);
 }
 async function readInstalledManifest(projectRoot) {
-  const manifestPath = path4.join(projectRoot, TEAMIX_DIR, MANIFEST_FILE);
+  const manifestPath = path7.join(projectRoot, TEAMIX_DIR, MANIFEST_FILE);
   const raw = await readFileOrNull(manifestPath);
   if (raw === null) return null;
   try {
@@ -347,73 +379,117 @@ async function readInstalledManifest(projectRoot) {
   }
 }
 async function writeInstalledManifest(projectRoot, manifest) {
-  const manifestPath = path4.join(projectRoot, TEAMIX_DIR, MANIFEST_FILE);
+  const manifestPath = path7.join(projectRoot, TEAMIX_DIR, MANIFEST_FILE);
   await writeFileSafe(manifestPath, JSON.stringify(manifest, null, 2) + "\n");
   logger.debug(`Wrote manifest \u2192 ${manifestPath}`);
 }
 
+// src/core/design-init.ts
+var DEFAULT_DESIGN_PACKAGE = "@teamix-evo/design";
+async function runDesignInit(options) {
+  const { projectRoot, variant, tailwind, ide } = options;
+  const packageName = options.packageName ?? DEFAULT_DESIGN_PACKAGE;
+  await ensureTeamixDir(projectRoot);
+  const existingConfig = await readProjectConfig(projectRoot);
+  if (existingConfig?.packages?.design) {
+    return {
+      status: "already-initialized",
+      existingVariant: existingConfig.packages.design.variant
+    };
+  }
+  const { manifest, data, variantDir, packageRoot } = await loadVariantData(
+    packageName,
+    variant
+  );
+  const result = await installResources({
+    projectRoot,
+    manifest,
+    data,
+    variantDir,
+    packageRoot
+  });
+  const config = {
+    $schema: "https://teamix-evo.dev/schema/config/v1.json",
+    schemaVersion: 1,
+    ide,
+    packages: {
+      design: {
+        variant,
+        version: manifest.version,
+        tailwind
+      }
+    }
+  };
+  await writeProjectConfig(projectRoot, config);
+  const installedManifest = {
+    schemaVersion: 1,
+    installed: [
+      {
+        package: packageName,
+        variant,
+        version: manifest.version,
+        installedAt: (/* @__PURE__ */ new Date()).toISOString(),
+        resources: result.resources
+      }
+    ]
+  };
+  await writeInstalledManifest(projectRoot, installedManifest);
+  return {
+    status: "installed",
+    packageName,
+    variant,
+    version: manifest.version,
+    tailwind,
+    count: result.count,
+    resources: result.resources
+  };
+}
+
 // src/commands/design/init.ts
-init_logger();
 var DEFAULT_VARIANT = "opentrek";
-var DESIGN_PACKAGE = "@teamix-evo/design";
-var initCommand = new Command("init").description("\u521D\u59CB\u5316\u8BBE\u8BA1\u4F53\u7CFB\u8D44\u6E90").argument("[variant]", "\u8BBE\u8BA1\u53D8\u4F53\u540D\u79F0", DEFAULT_VARIANT).action(async (variant) => {
+var DEFAULT_TAILWIND = "v4";
+function normalizeTailwind(input) {
+  if (input === void 0) return DEFAULT_TAILWIND;
+  const lower = input.toLowerCase();
+  if (lower === "v3" || lower === "3") return "v3";
+  if (lower === "v4" || lower === "4") return "v4";
+  throw new Error(
+    `Invalid --tailwind value: "${input}". Expected "v3" or "v4".`
+  );
+}
+var initCommand = new Command("init").description("\u521D\u59CB\u5316\u8BBE\u8BA1\u4F53\u7CFB\u8D44\u6E90").argument("[variant]", "\u8BBE\u8BA1\u53D8\u4F53\u540D\u79F0", DEFAULT_VARIANT).option(
+  "--tailwind <version>",
+  "\u9879\u76EE\u4F7F\u7528\u7684 Tailwind CSS \u4E3B\u7248\u672C\uFF08v3 | v4\uFF09",
+  DEFAULT_TAILWIND
+).action(async (variant, opts) => {
   try {
+    const tailwind = normalizeTailwind(opts.tailwind);
     const ide = detectIde();
     const projectRoot = ide.getProjectRoot();
-    logger.info(`Initializing design system: variant="${variant}"`);
+    logger.info(
+      `Initializing design system: variant="${variant}", tailwind="${tailwind}"`
+    );
     logger.debug(`Project root: ${projectRoot}`);
     logger.debug(`IDE: ${ide.name}`);
-    await ensureTeamixDir(projectRoot);
-    const existingConfig = await readProjectConfig(projectRoot);
-    if (existingConfig?.packages?.design) {
+    logger.info(`Loading variant "${variant}"...`);
+    logger.info("Installing resources...");
+    const result = await runDesignInit({
+      projectRoot,
+      variant,
+      tailwind,
+      ide: ide.name
+    });
+    if (result.status === "already-initialized") {
       logger.warn(
-        `Design system already initialized (variant: ${existingConfig.packages.design.variant}). Use "teamix-evo design update" to update.`
+        `Design system already initialized (variant: ${result.existingVariant}). Use "teamix-evo design update" to update.`
       );
       return;
     }
-    logger.info(`Loading variant "${variant}" from ${DESIGN_PACKAGE}...`);
-    const { manifest, data, variantDir, packageRoot } = await loadVariantData(DESIGN_PACKAGE, variant);
-    logger.debug(
-      `Loaded manifest: ${manifest.displayName} v${manifest.version}`
-    );
-    logger.debug(`Resources: ${manifest.resources.length}`);
-    logger.info("Installing resources...");
-    const result = await installResources({
-      projectRoot,
-      manifest,
-      data,
-      variantDir,
-      packageRoot
-    });
-    const config = {
-      $schema: "https://teamix-evo.dev/schema/config/v1.json",
-      schemaVersion: 1,
-      ide: ide.name,
-      packages: {
-        design: {
-          variant,
-          version: manifest.version
-        }
-      }
-    };
-    await writeProjectConfig(projectRoot, config);
-    const installedManifest = {
-      schemaVersion: 1,
-      installed: [
-        {
-          package: DESIGN_PACKAGE,
-          variant,
-          version: manifest.version,
-          installedAt: (/* @__PURE__ */ new Date()).toISOString(),
-          resources: result.resources
-        }
-      ]
-    };
-    await writeInstalledManifest(projectRoot, installedManifest);
     logger.success(
-      `Design system initialized: ${manifest.displayName} v${manifest.version}`
+      `Design system initialized: ${result.packageName} v${result.version}`
     );
-    logger.info(`  Variant: ${variant}`);
+    logger.info(`  Variant:  ${result.variant}`);
+    logger.info(`  Tailwind: ${result.tailwind}`);
     logger.info(`  Resources: ${result.count} files installed`);
     logger.info("");
     logger.info('Run "teamix-evo design update" to update resources later.');
@@ -428,14 +504,9 @@ var initCommand = new Command("init").description("\u521D\u59CB\u5316\u8BBE\u8BA
 import { Command as Command2 } from "commander";
 
 // src/core/updater.ts
-init_fs();
-import * as path5 from "path";
-import * as fs5 from "fs/promises";
-import {
-  getUpdateAction,
-  replaceManagedRegion
-} from "@teamix-evo/registry";
-init_logger();
+import * as path8 from "path";
+import * as fs6 from "fs/promises";
+import { getUpdateAction, replaceManagedRegion } from "@teamix-evo/registry";
 async function updateResources(options) {
   const {
     projectRoot,
@@ -485,16 +556,20 @@ async function updateResources(options) {
   return { resources: updatedResources, summary };
 }
 async function updateSingleResource(resource, projectRoot, data, variantDir, packageRoot, installedMap, summary) {
-  const targetPath = path5.join(projectRoot, resource.target);
+  const targetPath = path8.join(projectRoot, resource.target);
   const exists = await fileExists(targetPath);
   const installed = installedMap.get(resource.id);
-  const sourcePath = resolveSourcePath2(resource.source, variantDir, packageRoot);
+  const sourcePath = resolveSourcePath(
+    resource.source,
+    variantDir,
+    packageRoot
+  );
   let newContent;
   if (resource.template) {
     const templateContent = await loadTemplateFile(sourcePath);
     newContent = renderTemplate(templateContent, data);
   } else {
-    newContent = await fs5.readFile(sourcePath, "utf-8");
+    newContent = await fs6.readFile(sourcePath, "utf-8");
   }
   const newHash = computeHash(newContent);
   const action = getUpdateAction(resource.updateStrategy, {
@@ -545,7 +620,11 @@ async function updateSingleResource(resource, projectRoot, data, variantDir, pac
       const regionIds = resource.managedRegions ?? [];
       for (const regionId of regionIds) {
         const regionPattern = new RegExp(
-          `<!-- teamix-evo:managed:start id="${escapeRegExp(regionId)}" -->([\\s\\S]*?)<!-- teamix-evo:managed:end id="${escapeRegExp(regionId)}" -->`
+          `<!-- teamix-evo:managed:start id="${escapeRegExp(
+            regionId
+          )}" -->([\\s\\S]*?)<!-- teamix-evo:managed:end id="${escapeRegExp(
+            regionId
+          )}" -->`
         );
         const match = newContent.match(regionPattern);
         if (match) {
@@ -584,8 +663,12 @@ async function updateSingleResource(resource, projectRoot, data, variantDir, pac
   }
 }
 async function updateRecursiveResource(resource, projectRoot, data, variantDir, packageRoot, installedMap, summary) {
-  const sourcePath = resolveSourcePath2(resource.source, variantDir, packageRoot);
-  const targetDir = path5.join(projectRoot, resource.target);
+  const sourcePath = resolveSourcePath(
+    resource.source,
+    variantDir,
+    packageRoot
+  );
+  const targetDir = path8.join(projectRoot, resource.target);
   const results = [];
   if (resource.updateStrategy === "frozen") {
     const anyInstalled = [...installedMap.keys()].some(
@@ -601,12 +684,11 @@ async function updateRecursiveResource(resource, projectRoot, data, variantDir,
       return results;
     }
   }
-  const { ensureDir: ensureDir2 } = await Promise.resolve().then(() => (init_fs(), fs_exports));
-  await ensureDir2(targetDir);
-  const entries = await walkDir2(sourcePath);
+  await ensureDir(targetDir);
+  const entries = await walkDir(sourcePath);
   for (const entry of entries) {
-    const relPath = path5.relative(sourcePath, entry);
-    let targetFile = path5.join(targetDir, relPath);
+    const relPath = path8.relative(sourcePath, entry);
+    let targetFile = path8.join(targetDir, relPath);
     if (resource.template && targetFile.endsWith(".hbs")) {
       targetFile = targetFile.slice(0, -4);
     }
@@ -615,11 +697,11 @@ async function updateRecursiveResource(resource, projectRoot, data, variantDir,
       const templateContent = await loadTemplateFile(entry);
       content = renderTemplate(templateContent, data);
     } else {
-      content = await fs5.readFile(entry, "utf-8");
+      content = await fs6.readFile(entry, "utf-8");
     }
     await writeFileSafe(targetFile, content);
     const hash = computeHash(content);
-    const targetRel = path5.relative(projectRoot, targetFile);
+    const targetRel = path8.relative(projectRoot, targetFile);
     results.push({
       id: `${resource.id}:${relPath}`,
       target: targetRel,
@@ -630,32 +712,12 @@ async function updateRecursiveResource(resource, projectRoot, data, variantDir,
   }
   return results;
 }
-function resolveSourcePath2(source, variantDir, packageRoot) {
-  if (source.startsWith("_template/")) {
-    return path5.join(packageRoot, source);
-  }
-  return path5.join(variantDir, source);
-}
-async function walkDir2(dir) {
-  const files = [];
-  const entries = await fs5.readdir(dir, { withFileTypes: true });
-  for (const entry of entries) {
-    const fullPath = path5.join(dir, entry.name);
-    if (entry.isDirectory()) {
-      files.push(...await walkDir2(fullPath));
-    } else if (entry.isFile()) {
-      files.push(fullPath);
-    }
-  }
-  return files;
-}
 function escapeRegExp(str) {
   return str.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
 }
 
 // src/commands/design/update.ts
-init_logger();
-var DESIGN_PACKAGE2 = "@teamix-evo/design";
+var DESIGN_PACKAGE = "@teamix-evo/design";
 var updateCommand = new Command2("update").description("\u66F4\u65B0\u8BBE\u8BA1\u4F53\u7CFB\u8D44\u6E90").action(async () => {
   try {
     const ide = detectIde();
@@ -678,8 +740,8 @@ var updateCommand = new Command2("update").description("\u66F4\u65B0\u8BBE\u8BA1
       process.exitCode = 1;
       return;
     }
-    logger.info(`Loading variant "${variant}" from ${DESIGN_PACKAGE2}...`);
-    const { manifest, data, variantDir, packageRoot } = await loadVariantData(DESIGN_PACKAGE2, variant);
+    logger.info(`Loading variant "${variant}" from ${DESIGN_PACKAGE}...`);
+    const { manifest, data, variantDir, packageRoot } = await loadVariantData(DESIGN_PACKAGE, variant);
     logger.info(
       `Current: v${currentVersion} \u2192 Available: v${manifest.version}`
     );
@@ -690,16 +752,16 @@ var updateCommand = new Command2("update").description("\u66F4\u65B0\u8BBE\u8BA1
       variantDir,
       packageRoot,
       installedManifest,
-      packageName: DESIGN_PACKAGE2
+      packageName: DESIGN_PACKAGE
     });
     config.packages.design.version = manifest.version;
     await writeProjectConfig(projectRoot, config);
     const updatedManifest = { ...installedManifest };
     const pkgIdx = updatedManifest.installed.findIndex(
-      (p) => p.package === DESIGN_PACKAGE2 && p.variant === variant
+      (p) => p.package === DESIGN_PACKAGE && p.variant === variant
     );
     const pkgEntry = {
-      package: DESIGN_PACKAGE2,
+      package: DESIGN_PACKAGE,
       variant,
       version: manifest.version,
       installedAt: (/* @__PURE__ */ new Date()).toISOString(),
@@ -728,7 +790,6 @@ var updateCommand = new Command2("update").description("\u66F4\u65B0\u8BBE\u8BA1
 
 // src/commands/design/list.ts
 import { Command as Command3 } from "commander";
-init_logger();
 var listCommand = new Command3("list").description("\u5217\u51FA\u5DF2\u5B89\u88C5\u7684\u8BBE\u8BA1\u53D8\u4F53").action(async () => {
   try {
     const ide = detectIde();
@@ -739,11 +800,11 @@ var listCommand = new Command3("list").description("\u5217\u51FA\u5DF2\u5B89\u88
       logger.info('Run "teamix-evo design init [variant]" to get started.');
       return;
     }
-    const { variant, version } = config.packages.design;
+    const { variant, version: version2 } = config.packages.design;
     logger.info("Installed design system:");
     logger.info(`  Package:  @teamix-evo/design`);
     logger.info(`  Variant:  ${variant}`);
-    logger.info(`  Version:  ${version}`);
+    logger.info(`  Version:  ${version2}`);
     logger.info(`  IDE:      ${config.ide}`);
     const manifest = await readInstalledManifest(projectRoot);
     if (manifest) {
@@ -763,15 +824,1348 @@ var listCommand = new Command3("list").description("\u5217\u51FA\u5DF2\u5B89\u88
   }
 });
 
-// src/commands/design/index.ts
-var designCommand = new Command4("design").description("\u7BA1\u7406\u8BBE\u8BA1\u4F53\u7CFB\u8D44\u6E90");
-designCommand.addCommand(initCommand);
-designCommand.addCommand(updateCommand);
-designCommand.addCommand(listCommand);
+// src/commands/design/uninstall.ts
+import { Command as Command4 } from "commander";
+import * as fs7 from "fs/promises";
+import * as path9 from "path";
+import * as prompts from "@clack/prompts";
+var DESIGN_PACKAGE2 = "@teamix-evo/design";
+var uninstallCommand = new Command4("uninstall").description("\u5378\u8F7D\u8BBE\u8BA1\u4F53\u7CFB\u8D44\u6E90\uFF08\u9ED8\u8BA4\u4F1A\u5220\u9664 frozen / regenerable \u8D44\u6E90\u6587\u4EF6\uFF09").option("-y, --yes", "\u8DF3\u8FC7\u786E\u8BA4").option(
+  "--keep-files",
+  "\u4EC5\u6E05\u7406 .teamix-evo \u4E2D\u7684\u8BB0\u8D26\u4FE1\u606F\uFF0C\u4E0D\u5220\u9664\u5DF2\u843D\u5730\u8D44\u6E90\u6587\u4EF6"
+).action(async (opts) => {
+  try {
+    const ide = detectIde();
+    const projectRoot = ide.getProjectRoot();
+    const config = await readProjectConfig(projectRoot);
+    if (!config?.packages?.design) {
+      logger.info("Design system is not installed. Nothing to do.");
+      return;
+    }
+    const installedManifest = await readInstalledManifest(projectRoot);
+    const pkg = installedManifest?.installed.find(
+      (p) => p.package === DESIGN_PACKAGE2
+    );
+    const resources = pkg?.resources ?? [];
+    const removable = opts.keepFiles ? [] : resources.filter((r) => r.strategy !== "managed");
+    const kept = resources.length - removable.length;
+    logger.info(
+      `Will remove ${removable.length} file(s); keep ${kept} managed file(s).`
+    );
+    if (!opts.yes) {
+      const confirm4 = await prompts.confirm({
+        message: "\u786E\u8BA4\u5378\u8F7D\u8BBE\u8BA1\u4F53\u7CFB\uFF1F",
+        initialValue: false
+      });
+      if (prompts.isCancel(confirm4) || !confirm4) {
+        logger.info("Cancelled.");
+        return;
+      }
+    }
+    let removed = 0;
+    for (const r of removable) {
+      const target = path9.isAbsolute(r.target) ? r.target : path9.join(projectRoot, r.target);
+      try {
+        await fs7.unlink(target);
+        removed++;
+      } catch (err) {
+        if (err.code !== "ENOENT") {
+          logger.warn(
+            `Failed to remove ${target}: ${err.message}`
+          );
+        }
+      }
+    }
+    if (installedManifest) {
+      installedManifest.installed = installedManifest.installed.filter(
+        (p) => p.package !== DESIGN_PACKAGE2
+      );
+      await writeInstalledManifest(projectRoot, installedManifest);
+    }
+    delete config.packages.design;
+    await writeProjectConfig(projectRoot, config);
+    logger.success(`Uninstalled ${DESIGN_PACKAGE2}`);
+    logger.info(`  Removed: ${removed} files`);
+    if (kept > 0) {
+      logger.info(
+        `  Kept:    ${kept} managed files (you may delete manually)`
+      );
+    }
+  } catch (err) {
+    logger.error(`Failed to uninstall: ${err.message}`);
+    logger.debug(err.stack ?? "");
+    process.exitCode = 1;
+  }
+});
+
+// src/commands/design/index.ts
+var designCommand = new Command5("design").description(
+  "\u7BA1\u7406\u8BBE\u8BA1\u4F53\u7CFB\u8D44\u6E90"
+);
+designCommand.addCommand(initCommand);
+designCommand.addCommand(updateCommand);
+designCommand.addCommand(listCommand);
+designCommand.addCommand(uninstallCommand);
+
+// src/commands/skills/index.ts
+import { Command as Command10 } from "commander";
+
+// src/commands/skills/add.ts
+import { Command as Command6 } from "commander";
+import * as prompts2 from "@clack/prompts";
+
+// src/core/skills-client.ts
+import * as path10 from "path";
+import * as fs8 from "fs/promises";
+import { createRequire as createRequire2 } from "module";
+import { loadSkillsPackageManifest } from "@teamix-evo/registry";
+var require3 = createRequire2(import.meta.url);
+function resolvePackageRoot2(packageName) {
+  const pkgJsonPath = require3.resolve(`${packageName}/package.json`);
+  return path10.dirname(pkgJsonPath);
+}
+async function loadSkillsData(packageName) {
+  const packageRoot = resolvePackageRoot2(packageName);
+  logger.debug(`Resolved skills package root: ${packageRoot}`);
+  const manifest = await loadSkillsPackageManifest(packageRoot);
+  let data = {};
+  const dataPath = path10.join(packageRoot, "_data.json");
+  try {
+    const raw = await fs8.readFile(dataPath, "utf-8");
+    data = JSON.parse(raw);
+  } catch (err) {
+    if (err.code !== "ENOENT") {
+      throw err;
+    }
+    logger.debug(`No _data.json found at ${dataPath}, using empty data`);
+  }
+  return { manifest, data, packageRoot };
+}
+
+// src/core/skills-installer.ts
+import * as path11 from "path";
+import * as fs9 from "fs/promises";
+import { replaceManagedRegion as replaceManagedRegion2 } from "@teamix-evo/registry";
+async function installSkills(options) {
+  const { manifest, ides, scope, onlyIds } = options;
+  const installed = [];
+  const targets = manifest.skills.filter(
+    (s) => !onlyIds || onlyIds.includes(s.id)
+  );
+  for (const skill of targets) {
+    const skillIdes = skill.ides.filter((i) => ides.includes(i));
+    if (skillIdes.length === 0) {
+      logger.warn(
+        `Skill "${skill.name}" supports [${skill.ides.join(
+          ","
+        )}], no overlap with [${ides.join(",")}]; skipped.`
+      );
+      continue;
+    }
+    for (const ide of skillIdes) {
+      const result = await installSkillForIde(skill, ide, scope, options);
+      installed.push(...result);
+    }
+  }
+  return { resources: installed, count: installed.length };
+}
+async function installSkillForIde(skill, ide, scope, options) {
+  const { data, packageRoot, projectRoot } = options;
+  const adapter = getAdapter(ide);
+  const targetDir = adapter.getSkillTargetDir(skill.name, scope, projectRoot);
+  const sourceAbs = path11.resolve(packageRoot, skill.source);
+  const stat2 = await fs9.stat(sourceAbs);
+  const results = [];
+  if (stat2.isFile()) {
+    const targetFile = path11.join(targetDir, "SKILL.md");
+    const content = await renderSkillContent(sourceAbs, skill, data);
+    await writeFileSafe(targetFile, content);
+    results.push(makeInstalledRecord(skill, targetFile, content, ide, scope));
+    logger.debug(`  Wrote ${ide}:${scope}: ${targetFile}`);
+    return results;
+  }
+  await ensureDir(targetDir);
+  const entries = await walkDir(sourceAbs);
+  for (const entry of entries) {
+    const rel2 = path11.relative(sourceAbs, entry);
+    let targetFile = path11.join(targetDir, rel2);
+    if (skill.template && targetFile.endsWith(".hbs")) {
+      targetFile = targetFile.slice(0, -4);
+    }
+    let content;
+    if (skill.template && entry.endsWith(".hbs")) {
+      const tpl = await loadTemplateFile(entry);
+      content = renderTemplate(tpl, { ...data, skill });
+    } else {
+      content = await fs9.readFile(entry, "utf-8");
+    }
+    await writeFileSafe(targetFile, content);
+    results.push(
+      makeInstalledRecord(skill, targetFile, content, ide, scope, rel2)
+    );
+    logger.debug(`  Wrote ${ide}:${scope}: ${targetFile}`);
+  }
+  return results;
+}
+async function renderSkillContent(sourceAbs, skill, data) {
+  if (skill.template ?? sourceAbs.endsWith(".hbs")) {
+    const tpl = await loadTemplateFile(sourceAbs);
+    return renderTemplate(tpl, { ...data, skill });
+  }
+  return fs9.readFile(sourceAbs, "utf-8");
+}
+function makeInstalledRecord(skill, targetAbs, content, ide, scope, rel2) {
+  const id = rel2 ? `${skill.id}:${rel2}` : skill.id;
+  return {
+    id,
+    target: targetAbs,
+    hash: computeHash(content),
+    strategy: skill.updateStrategy,
+    ide,
+    scope
+  };
+}
+async function updateSkills(options) {
+  const { manifest, ides, scope, installed, projectRoot, data, packageRoot } = options;
+  const summary = { overwritten: 0, managed: 0, skipped: 0, created: 0 };
+  const updated = [];
+  const installedMap = /* @__PURE__ */ new Map();
+  for (const r of installed) {
+    installedMap.set(installedKey(r), r);
+  }
+  for (const skill of manifest.skills) {
+    const skillIdes = skill.ides.filter((i) => ides.includes(i));
+    for (const ide of skillIdes) {
+      const records = await updateSkillForIde(
+        skill,
+        ide,
+        scope,
+        data,
+        packageRoot,
+        projectRoot,
+        installedMap,
+        summary
+      );
+      updated.push(...records);
+    }
+  }
+  return { resources: updated, summary };
+}
+async function updateSkillForIde(skill, ide, scope, data, packageRoot, projectRoot, installedMap, summary) {
+  const adapter = getAdapter(ide);
+  const targetDir = adapter.getSkillTargetDir(skill.name, scope, projectRoot);
+  const sourceAbs = path11.resolve(packageRoot, skill.source);
+  const stat2 = await fs9.stat(sourceAbs);
+  const records = [];
+  if (!stat2.isFile()) {
+    const entries = await walkDir(sourceAbs);
+    await ensureDir(targetDir);
+    for (const entry of entries) {
+      const rel2 = path11.relative(sourceAbs, entry);
+      let targetFile2 = path11.join(targetDir, rel2);
+      if (skill.template && targetFile2.endsWith(".hbs")) {
+        targetFile2 = targetFile2.slice(0, -4);
+      }
+      let content;
+      if (skill.template && entry.endsWith(".hbs")) {
+        content = renderTemplate(await loadTemplateFile(entry), {
+          ...data,
+          skill
+        });
+      } else {
+        content = await fs9.readFile(entry, "utf-8");
+      }
+      const exists2 = await fileExists(targetFile2);
+      if (exists2) {
+        await backupFile(targetFile2, projectRoot);
+        summary.overwritten++;
+      } else {
+        summary.created++;
+      }
+      await writeFileSafe(targetFile2, content);
+      records.push(
+        makeInstalledRecord(skill, targetFile2, content, ide, scope, rel2)
+      );
+    }
+    return records;
+  }
+  const targetFile = path11.join(targetDir, "SKILL.md");
+  const newContent = await renderSkillContent(sourceAbs, skill, data);
+  const exists = await fileExists(targetFile);
+  const installedKeyStr = `${skill.id}|${ide}|${scope}`;
+  const prior = installedMap.get(installedKeyStr);
+  if (skill.updateStrategy === "frozen") {
+    if (exists) {
+      summary.skipped++;
+      return [
+        prior ?? makeInstalledRecord(skill, targetFile, newContent, ide, scope)
+      ];
+    }
+    await writeFileSafe(targetFile, newContent);
+    summary.created++;
+    records.push(
+      makeInstalledRecord(skill, targetFile, newContent, ide, scope)
+    );
+    return records;
+  }
+  if (skill.updateStrategy === "regenerable" || !exists) {
+    if (exists) {
+      await backupFile(targetFile, projectRoot);
+      summary.overwritten++;
+    } else {
+      summary.created++;
+    }
+    await writeFileSafe(targetFile, newContent);
+    records.push(
+      makeInstalledRecord(skill, targetFile, newContent, ide, scope)
+    );
+    return records;
+  }
+  const current = await readFileOrNull(targetFile);
+  let updated = current ?? newContent;
+  const regionIds = skill.managedRegions ?? [];
+  for (const regionId of regionIds) {
+    const re = new RegExp(
+      `<!-- teamix-evo:managed:start id="${escapeRegExp2(
+        regionId
+      )}" -->([\\s\\S]*?)<!-- teamix-evo:managed:end id="${escapeRegExp2(
+        regionId
+      )}" -->`
+    );
+    const match = newContent.match(re);
+    if (match) {
+      const region = match[1].replace(/^\n/, "").replace(/\n$/, "");
+      try {
+        updated = replaceManagedRegion2(updated, regionId, region);
+      } catch {
+        logger.warn(
+          `Managed region "${regionId}" not found in ${targetFile}. Skipped.`
+        );
+      }
+    }
+  }
+  await backupFile(targetFile, projectRoot);
+  await writeFileSafe(targetFile, updated);
+  summary.managed++;
+  records.push(makeInstalledRecord(skill, targetFile, updated, ide, scope));
+  return records;
+}
+function installedKey(r) {
+  return `${r.id}|${r.ide ?? ""}|${r.scope ?? ""}`;
+}
+function escapeRegExp2(str) {
+  return str.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+}
+async function removeSkillFiles(records) {
+  const removed = [];
+  for (const r of records) {
+    try {
+      await fs9.unlink(r.target);
+      removed.push(r.target);
+    } catch (err) {
+      if (err.code !== "ENOENT") {
+        logger.warn(`Failed to remove ${r.target}: ${err.message}`);
+      }
+    }
+  }
+  const parents = new Set(records.map((r) => path11.dirname(r.target)));
+  for (const dir of parents) {
+    try {
+      const entries = await fs9.readdir(dir);
+      if (entries.length === 0) await fs9.rmdir(dir);
+    } catch {
+    }
+  }
+  return removed;
+}
+
+// src/core/skills-add.ts
+var DEFAULT_SKILLS_PACKAGE = "@teamix-evo/skills";
+var FLAT_VARIANT = "_flat";
+async function runSkillsAdd(options) {
+  const { projectRoot, names: requestedNames } = options;
+  const packageName = options.packageName ?? DEFAULT_SKILLS_PACKAGE;
+  const ideIdent = options.ide ?? "qoder";
+  const isIncremental = !!requestedNames && requestedNames.length > 0;
+  await ensureTeamixDir(projectRoot);
+  const existingConfig = await readProjectConfig(projectRoot);
+  const existingSkillsCfg = existingConfig?.packages?.skills;
+  if (!isIncremental && existingSkillsCfg) {
+    return { status: "already-added" };
+  }
+  const ides = options.ides && options.ides.length > 0 ? [...options.ides] : existingSkillsCfg?.ides ? [...existingSkillsCfg.ides] : [];
+  const scope = options.scope ?? existingSkillsCfg?.scope;
+  if (ides.length === 0) {
+    throw new Error("At least one IDE must be selected.");
+  }
+  if (!scope) {
+    throw new Error("Scope must be specified (project | global).");
+  }
+  const { manifest, data, packageRoot } = await loadSkillsData(packageName);
+  if (isIncremental) {
+    const known = new Set(manifest.skills.map((s) => s.id));
+    const unknown = requestedNames.filter((n) => !known.has(n));
+    if (unknown.length > 0) {
+      const available = [...known].join(", ");
+      throw new Error(
+        `Unknown skill id(s): ${unknown.join(", ")}. Available: ${available || "(none)"}.`
+      );
+    }
+  }
+  const existingInstalled = await readInstalledManifest(projectRoot);
+  const existingPkg = existingInstalled?.installed.find(
+    (p) => p.package === packageName
+  );
+  const existingSkillIds = new Set(
+    (existingPkg?.resources ?? []).map((r) => r.id.split(":")[0])
+  );
+  let onlyIds;
+  let skippedSkillIds;
+  if (isIncremental) {
+    skippedSkillIds = requestedNames.filter((n) => existingSkillIds.has(n));
+    onlyIds = requestedNames.filter((n) => !existingSkillIds.has(n));
+  } else {
+    skippedSkillIds = [];
+    onlyIds = manifest.skills.map((s) => s.id);
+  }
+  if (isIncremental && onlyIds.length === 0) {
+    return {
+      status: "installed",
+      packageName,
+      version: existingSkillsCfg?.version ?? manifest.version,
+      ides,
+      scope,
+      skillCount: 0,
+      fileCount: 0,
+      resources: [],
+      addedSkillIds: [],
+      skippedSkillIds
+    };
+  }
+  const result = await installSkills({
+    projectRoot,
+    manifest,
+    data,
+    packageRoot,
+    ides,
+    scope,
+    onlyIds
+  });
+  const config = existingConfig ?? {
+    $schema: "https://teamix-evo.dev/schema/config/v1.json",
+    schemaVersion: 1,
+    ide: ideIdent,
+    packages: {}
+  };
+  config.packages.skills = {
+    variant: FLAT_VARIANT,
+    version: manifest.version,
+    ides,
+    scope
+  };
+  await writeProjectConfig(projectRoot, config);
+  const installedManifest = existingInstalled ?? {
+    schemaVersion: 1,
+    installed: []
+  };
+  const idx = installedManifest.installed.findIndex(
+    (p) => p.package === packageName
+  );
+  const mergedResources = mergeInstalledResources(
+    existingPkg?.resources ?? [],
+    result.resources
+  );
+  const entry = {
+    package: packageName,
+    variant: FLAT_VARIANT,
+    version: manifest.version,
+    installedAt: (/* @__PURE__ */ new Date()).toISOString(),
+    resources: mergedResources
+  };
+  if (idx >= 0) installedManifest.installed[idx] = entry;
+  else installedManifest.installed.push(entry);
+  await writeInstalledManifest(projectRoot, installedManifest);
+  return {
+    status: "installed",
+    packageName,
+    version: manifest.version,
+    ides,
+    scope,
+    skillCount: onlyIds.length,
+    fileCount: result.count,
+    resources: result.resources,
+    addedSkillIds: onlyIds,
+    skippedSkillIds
+  };
+}
+function mergeInstalledResources(existing, next) {
+  const map = /* @__PURE__ */ new Map();
+  const key = (r) => `${r.id}|${r.ide ?? ""}|${r.scope ?? ""}`;
+  for (const r of existing) map.set(key(r), r);
+  for (const r of next) map.set(key(r), r);
+  return [...map.values()];
+}
+
+// src/commands/skills/add.ts
+var addCommand = new Command6("add").description(
+  "\u5411\u9879\u76EE\uFF08\u6216\u5168\u5C40 IDE \u914D\u7F6E\uFF09\u6DFB\u52A0 teamix-evo skills\uFF1B\u4E0D\u4F20 names \u5219\u6DFB\u52A0 manifest \u5185\u5168\u90E8 skill"
+).argument(
+  "[names...]",
+  "\u53EF\u9009\uFF1A\u4EC5\u6DFB\u52A0\u6307\u5B9A skill id\uFF08\u589E\u91CF\u6A21\u5F0F\uFF09\uFF1B\u7701\u7565\u5219\u6DFB\u52A0\u5168\u90E8"
+).option("--ide <list>", '\u9017\u53F7\u5206\u9694\u7684 IDE \u5217\u8868\uFF0C\u5982 "qoder,claude"').option(
+  "--scope <scope>",
+  "project | global\uFF08\u9ED8\u8BA4 project\uFF1B\u589E\u91CF\u6A21\u5F0F\u4E0B\u9ED8\u8BA4\u590D\u7528\u5DF2\u6709\u914D\u7F6E\uFF09"
+).option("-y, --yes", "\u4F7F\u7528\u9ED8\u8BA4\u503C\uFF0C\u8DF3\u8FC7\u4EA4\u4E92").action(async (names, opts) => {
+  try {
+    const ide = detectIde();
+    const projectRoot = ide.getProjectRoot();
+    const isIncremental = names.length > 0;
+    const { ides, scope } = await resolveIdesAndScope({
+      opts,
+      projectRoot,
+      isIncremental
+    });
+    logger.info(
+      isIncremental ? `Adding skills [${names.join(",")}]: ides=[${ides.join(
+        ","
+      )}], scope="${scope}"` : `Adding skills (all): ides=[${ides.join(",")}], scope="${scope}"`
+    );
+    logger.debug(`Project root: ${projectRoot}`);
+    const result = await runSkillsAdd({
+      projectRoot,
+      ides,
+      scope,
+      ide: ide.name,
+      names: isIncremental ? names : void 0
+    });
+    if (result.status === "already-added") {
+      logger.warn(
+        `Skills already added. Use "teamix-evo skills add <name>" to add specific skills, "teamix-evo skills update" to refresh, or "teamix-evo skills uninstall" to remove.`
+      );
+      return;
+    }
+    if (result.addedSkillIds.length === 0 && result.skippedSkillIds.length > 0) {
+      logger.warn(
+        `\u5DF2\u5B58\u5728\uFF0C\u65E0\u9700\u6DFB\u52A0\uFF1A${result.skippedSkillIds.join(
+          ", "
+        )}\u3002\u5982\u9700\u5237\u65B0\u5185\u5BB9\u8BF7\u8FD0\u884C "teamix-evo skills update"\u3002`
+      );
+      return;
+    }
+    logger.success(`Skills added: ${result.skillCount} skill(s)`);
+    logger.info(`  IDEs:    ${result.ides.join(", ")}`);
+    logger.info(`  Scope:   ${result.scope}`);
+    if (result.addedSkillIds.length > 0) {
+      logger.info(`  Added:   ${result.addedSkillIds.join(", ")}`);
+    }
+    if (result.skippedSkillIds.length > 0) {
+      logger.info(
+        `  Skipped: ${result.skippedSkillIds.join(", ")} (already added)`
+      );
+    }
+    logger.info(`  Files:   ${result.fileCount}`);
+    logger.info("");
+    logger.info('Run "teamix-evo skills list" to see installed skills.');
+  } catch (err) {
+    logger.error(`Failed to add skills: ${err.message}`);
+    logger.debug(err.stack ?? "");
+    process.exitCode = 1;
+  }
+});
+async function resolveIdesAndScope(args) {
+  const { opts, projectRoot, isIncremental } = args;
+  if (isIncremental && !opts.ide && !opts.scope && !opts.yes) {
+    const existing = await readProjectConfig(projectRoot);
+    const cfg = existing?.packages?.skills;
+    if (cfg && cfg.ides && cfg.ides.length > 0 && cfg.scope) {
+      logger.debug(
+        `Reusing existing skills config: ides=[${cfg.ides.join(",")}], scope="${cfg.scope}"`
+      );
+      return {
+        ides: [...cfg.ides],
+        scope: cfg.scope
+      };
+    }
+  }
+  if (opts.ide || opts.yes) {
+    const ides = opts.ide ? parseIdeList(opts.ide) : [...ALL_IDE_KINDS];
+    const scope = parseScope(opts.scope);
+    if (ides.length === 0) {
+      throw new Error("At least one IDE must be selected.");
+    }
+    return { ides, scope };
+  }
+  const idesAns = await prompts2.multiselect({
+    message: "\u9009\u62E9\u8981\u6CE8\u5165\u6280\u80FD\u7684 AI IDE\uFF08\u81F3\u5C11\u4E00\u4E2A\uFF09",
+    options: ALL_IDE_KINDS.map((k) => ({
+      value: k,
+      label: k === "qoder" ? "Qoder" : "Claude Code"
+    })),
+    initialValues: [...ALL_IDE_KINDS],
+    required: true
+  });
+  if (prompts2.isCancel(idesAns)) {
+    throw new Error("Cancelled by user.");
+  }
+  const scopeAns = await prompts2.select({
+    message: "\u5B89\u88C5\u8303\u56F4\uFF1F",
+    options: [
+      { value: "project", label: "\u9879\u76EE\u7EA7\uFF08.qoder/.claude \u5728\u5F53\u524D\u9879\u76EE\uFF09" },
+      { value: "global", label: "\u5168\u5C40\uFF08~/.qoder/~/.claude\uFF09" }
+    ],
+    initialValue: "project"
+  });
+  if (prompts2.isCancel(scopeAns)) {
+    throw new Error("Cancelled by user.");
+  }
+  return { ides: idesAns, scope: scopeAns };
+}
+function parseIdeList(input) {
+  const parts = input.split(",").map((s) => s.trim().toLowerCase()).filter(Boolean);
+  const result = [];
+  for (const p of parts) {
+    if (p === "qoder" || p === "claude") {
+      if (!result.includes(p)) result.push(p);
+    } else {
+      throw new Error(`Unknown IDE: "${p}". Expected qoder | claude.`);
+    }
+  }
+  return result;
+}
+function parseScope(input) {
+  const v = (input ?? "project").toLowerCase();
+  if (v === "project" || v === "global") return v;
+  throw new Error(`Invalid --scope: "${input}". Expected project | global.`);
+}
+
+// src/commands/skills/list.ts
+import { Command as Command7 } from "commander";
+var SKILLS_PACKAGE = "@teamix-evo/skills";
+var listCommand2 = new Command7("list").alias("ls").description(
+  "\u5217\u51FA teamix-evo skills\uFF08\u9ED8\u8BA4\u5C55\u793A\u5168\u90E8 skill \u5E76\u6807\u6CE8\u5DF2\u88C5/\u672A\u88C5\uFF1B--installed \u4EC5\u770B\u5DF2\u88C5\uFF09"
+).option("--installed", "\u4EC5\u5C55\u793A\u5DF2\u5B89\u88C5\u7684 skill\uFF08\u9690\u85CF\u672A\u5B89\u88C5\u9879\uFF09").action(async (opts) => {
+  try {
+    const ide = detectIde();
+    const projectRoot = ide.getProjectRoot();
+    const config = await readProjectConfig(projectRoot);
+    const installedManifest = await readInstalledManifest(projectRoot);
+    const pkg = installedManifest?.installed.find(
+      (p) => p.package === SKILLS_PACKAGE
+    );
+    const installedBySkill = /* @__PURE__ */ new Map();
+    for (const r of pkg?.resources ?? []) {
+      const skillId = r.id.split(":")[0];
+      installedBySkill.set(skillId, (installedBySkill.get(skillId) ?? 0) + 1);
+    }
+    if (opts.installed) {
+      if (!config?.packages?.skills || !pkg) {
+        logger.info("No skills installed.");
+        logger.info('Run "teamix-evo skills add" to get started.');
+        return;
+      }
+      printInstalledHeader(config.packages.skills, pkg.installedAt);
+      logger.info("");
+      logger.info("Installed skills:");
+      for (const [skillId, count] of installedBySkill) {
+        logger.info(`  \u2713 ${skillId}  (${count} file${count > 1 ? "s" : ""})`);
+      }
+      logger.info("");
+      logger.info(
+        `  Total: ${pkg.resources.length} files (${installedBySkill.size} skills \xD7 ides \xD7 scope)`
+      );
+      return;
+    }
+    const { manifest } = await loadSkillsData(SKILLS_PACKAGE);
+    const skills = [...manifest.skills].sort(
+      (a, b) => a.id.localeCompare(b.id)
+    );
+    const isInstalled = !!config?.packages?.skills && !!pkg;
+    if (isInstalled) {
+      printInstalledHeader(config.packages.skills, pkg.installedAt);
+    } else {
+      logger.info("Skills package not yet added.");
+      logger.info(
+        'Run "teamix-evo skills add" to add all, or "teamix-evo skills add <id>" for specific skills.'
+      );
+    }
+    logger.info("");
+    logger.info(`Available skills (${SKILLS_PACKAGE}@${manifest.version}):`);
+    let installedCount = 0;
+    for (const s of skills) {
+      const fileCount = installedBySkill.get(s.id);
+      const installed = fileCount !== void 0;
+      if (installed) installedCount++;
+      const mark = installed ? "\u2713" : "\u25CB";
+      const tail = installed ? `[installed, ${fileCount} file${fileCount > 1 ? "s" : ""}]` : `[not installed \u2014 run "teamix-evo skills add ${s.id}"]`;
+      logger.info(`  ${mark} ${s.id}@${s.version}  ${tail}`);
+      if (s.description) {
+        logger.info(`      ${s.description}`);
+      }
+    }
+    logger.info("");
+    logger.info(
+      `  Total: ${skills.length} skill(s) \u2014 ${installedCount} installed, ${skills.length - installedCount} available`
+    );
+  } catch (err) {
+    logger.error(`Failed to list: ${err.message}`);
+    process.exitCode = 1;
+  }
+});
+function printInstalledHeader(cfg, installedAt) {
+  logger.info("Installed skills package:");
+  logger.info(`  Package:    ${SKILLS_PACKAGE}`);
+  logger.info(`  Version:    ${cfg.version ?? "(unknown)"}`);
+  logger.info(`  IDEs:       ${(cfg.ides ?? []).join(", ") || "(unknown)"}`);
+  logger.info(`  Scope:      ${cfg.scope ?? "(unknown)"}`);
+  logger.info(`  Installed:  ${new Date(installedAt).toLocaleString()}`);
+}
+
+// src/commands/skills/update.ts
+import { Command as Command8 } from "commander";
+var SKILLS_PACKAGE2 = "@teamix-evo/skills";
+var FLAT_VARIANT2 = "_flat";
+var updateCommand2 = new Command8("update").description("\u66F4\u65B0\u5DF2\u5B89\u88C5\u7684 teamix-evo skills").action(async () => {
+  try {
+    const ide = detectIde();
+    const projectRoot = ide.getProjectRoot();
+    const config = await readProjectConfig(projectRoot);
+    if (!config?.packages?.skills) {
+      logger.error('Skills not added. Run "teamix-evo skills add" first.');
+      process.exitCode = 1;
+      return;
+    }
+    const installedManifest = await readInstalledManifest(projectRoot);
+    if (!installedManifest) {
+      logger.error("No installed manifest found.");
+      process.exitCode = 1;
+      return;
+    }
+    const skillsEntry = config.packages.skills;
+    const ides = skillsEntry.ides ?? [
+      "qoder",
+      "claude"
+    ];
+    const scope = skillsEntry.scope ?? "project";
+    logger.info(`Updating skills (ides=[${ides.join(",")}], scope=${scope})`);
+    const { manifest, data, packageRoot } = await loadSkillsData(
+      SKILLS_PACKAGE2
+    );
+    const pkgInstalled = installedManifest.installed.find(
+      (p) => p.package === SKILLS_PACKAGE2
+    );
+    const installedResources = pkgInstalled?.resources ?? [];
+    logger.info(
+      `Current: v${skillsEntry.version} \u2192 Available: v${manifest.version}`
+    );
+    const result = await updateSkills({
+      projectRoot,
+      manifest,
+      data,
+      packageRoot,
+      ides,
+      scope,
+      installed: installedResources
+    });
+    config.packages.skills.version = manifest.version;
+    await writeProjectConfig(projectRoot, config);
+    const idx = installedManifest.installed.findIndex(
+      (p) => p.package === SKILLS_PACKAGE2
+    );
+    const entry = {
+      package: SKILLS_PACKAGE2,
+      variant: FLAT_VARIANT2,
+      version: manifest.version,
+      installedAt: (/* @__PURE__ */ new Date()).toISOString(),
+      resources: result.resources
+    };
+    if (idx >= 0) installedManifest.installed[idx] = entry;
+    else installedManifest.installed.push(entry);
+    await writeInstalledManifest(projectRoot, installedManifest);
+    const { summary } = result;
+    logger.success(`Skills updated to v${manifest.version}`);
+    logger.info(`  Created:     ${summary.created}`);
+    logger.info(`  Overwritten: ${summary.overwritten}`);
+    logger.info(`  Managed:     ${summary.managed}`);
+    logger.info(`  Skipped:     ${summary.skipped}`);
+  } catch (err) {
+    logger.error(`Failed to update skills: ${err.message}`);
+    logger.debug(err.stack ?? "");
+    process.exitCode = 1;
+  }
+});
+
+// src/commands/skills/uninstall.ts
+import { Command as Command9 } from "commander";
+import * as prompts3 from "@clack/prompts";
+var SKILLS_PACKAGE3 = "@teamix-evo/skills";
+var uninstallCommand2 = new Command9("uninstall").description("\u5378\u8F7D\u5DF2\u5B89\u88C5\u7684 teamix-evo skills\uFF08\u5220\u9664\u6CE8\u5165\u5230 IDE \u7684\u6280\u80FD\u6587\u4EF6\uFF09").option("-y, --yes", "\u8DF3\u8FC7\u786E\u8BA4").action(async (opts) => {
+  try {
+    const ide = detectIde();
+    const projectRoot = ide.getProjectRoot();
+    const config = await readProjectConfig(projectRoot);
+    if (!config?.packages?.skills) {
+      logger.info("Skills are not installed. Nothing to do.");
+      return;
+    }
+    const installedManifest = await readInstalledManifest(projectRoot);
+    const pkg = installedManifest?.installed.find(
+      (p) => p.package === SKILLS_PACKAGE3
+    );
+    const resources = pkg?.resources ?? [];
+    logger.info(
+      `Will remove ${resources.length} skill file(s) installed by ${SKILLS_PACKAGE3}.`
+    );
+    if (!opts.yes) {
+      const confirm4 = await prompts3.confirm({
+        message: "\u786E\u8BA4\u5378\u8F7D\uFF1F\u6B64\u64CD\u4F5C\u4F1A\u5220\u9664\u4E0A\u8FF0\u6587\u4EF6\u3002",
+        initialValue: false
+      });
+      if (prompts3.isCancel(confirm4) || !confirm4) {
+        logger.info("Cancelled.");
+        return;
+      }
+    }
+    const removed = await removeSkillFiles(resources);
+    logger.debug(`Removed ${removed.length} files`);
+    if (installedManifest && pkg) {
+      installedManifest.installed = installedManifest.installed.filter(
+        (p) => p.package !== SKILLS_PACKAGE3
+      );
+      await writeInstalledManifest(projectRoot, installedManifest);
+    }
+    delete config.packages.skills;
+    await writeProjectConfig(projectRoot, config);
+    logger.success(`Uninstalled ${SKILLS_PACKAGE3}`);
+    logger.info(`  Removed: ${removed.length} files`);
+  } catch (err) {
+    logger.error(`Failed to uninstall: ${err.message}`);
+    logger.debug(err.stack ?? "");
+    process.exitCode = 1;
+  }
+});
+
+// src/commands/skills/index.ts
+var skillsCommand = new Command10("skills").description(
+  "\u7BA1\u7406 teamix-evo skills\uFF08\u5411 AI IDE \u6CE8\u5165\u6280\u80FD\uFF09"
+);
+skillsCommand.addCommand(addCommand);
+skillsCommand.addCommand(listCommand2);
+skillsCommand.addCommand(updateCommand2);
+skillsCommand.addCommand(uninstallCommand2);
+
+// src/commands/ui/index.ts
+import { Command as Command14 } from "commander";
+
+// src/commands/ui/init.ts
+import { Command as Command11 } from "commander";
+import * as prompts4 from "@clack/prompts";
+
+// src/core/ui-init.ts
+var DEFAULT_UI_ALIASES = {
+  components: "src/components/ui",
+  hooks: "src/hooks",
+  utils: "src/lib/utils",
+  lib: "src/lib"
+};
+var DEFAULT_UI_ICON_LIBRARY = "lucide";
+async function runUiInit(options) {
+  const { projectRoot } = options;
+  const ideIdent = options.ide ?? "qoder";
+  await ensureTeamixDir(projectRoot);
+  const existingConfig = await readProjectConfig(projectRoot);
+  if (existingConfig?.packages?.ui) {
+    return { status: "already-initialized" };
+  }
+  const aliases = {
+    components: options.aliases?.components ?? DEFAULT_UI_ALIASES.components,
+    hooks: options.aliases?.hooks ?? DEFAULT_UI_ALIASES.hooks,
+    utils: options.aliases?.utils ?? DEFAULT_UI_ALIASES.utils,
+    lib: options.aliases?.lib ?? DEFAULT_UI_ALIASES.lib
+  };
+  const iconLibrary = options.iconLibrary ?? DEFAULT_UI_ICON_LIBRARY;
+  const tsx = options.tsx ?? true;
+  const rsc = options.rsc ?? false;
+  const config = existingConfig ?? {
+    $schema: "https://teamix-evo.dev/schema/config/v1.json",
+    schemaVersion: 1,
+    ide: ideIdent,
+    packages: {}
+  };
+  config.packages.ui = {
+    variant: "_flat",
+    version: "0.0.0",
+    aliases,
+    iconLibrary,
+    tsx,
+    rsc
+  };
+  await writeProjectConfig(projectRoot, config);
+  return {
+    status: "installed",
+    aliases,
+    iconLibrary,
+    tsx,
+    rsc
+  };
+}
+
+// src/commands/ui/init.ts
+var initCommand2 = new Command11("init").description(
+  "\u521D\u59CB\u5316 teamix-evo ui \u914D\u7F6E\uFF08\u8BE2\u95EE aliases / iconLibrary / tsx / rsc\uFF09"
+).option("-y, --yes", "\u4F7F\u7528\u9ED8\u8BA4\u503C\uFF0C\u8DF3\u8FC7\u4EA4\u4E92").option(
+  "--components <path>",
+  "\u7EC4\u4EF6 alias \u8DEF\u5F84",
+  DEFAULT_UI_ALIASES.components
+).option("--hooks <path>", "hooks alias \u8DEF\u5F84", DEFAULT_UI_ALIASES.hooks).option("--utils <path>", "utils alias \u8DEF\u5F84", DEFAULT_UI_ALIASES.utils).option("--lib <path>", "lib alias \u8DEF\u5F84", DEFAULT_UI_ALIASES.lib).option("--icon-library <name>", "\u9ED8\u8BA4 icon \u5E93\uFF08\u58F0\u660E\u6027\uFF09", "lucide").option("--tsx", "\u4F7F\u7528 TSX", true).option("--rsc", "\u4F7F\u7528 React Server Components").action(async (opts) => {
+  try {
+    const ide = detectIde();
+    const projectRoot = ide.getProjectRoot();
+    const cfg = await resolveConfig(opts);
+    const result = await runUiInit({
+      projectRoot,
+      aliases: cfg.aliases,
+      iconLibrary: cfg.iconLibrary,
+      tsx: cfg.tsx,
+      rsc: cfg.rsc,
+      ide: ide.name
+    });
+    if (result.status === "already-initialized") {
+      logger.warn(
+        "UI already initialized. Edit `.teamix-evo/config.json` directly to change aliases, or run `teamix-evo ui list`."
+      );
+      return;
+    }
+    logger.success("UI initialized.");
+    logger.info(`  components: ${result.aliases.components}`);
+    logger.info(`  hooks:      ${result.aliases.hooks}`);
+    logger.info(`  utils:      ${result.aliases.utils}`);
+    logger.info(`  lib:        ${result.aliases.lib}`);
+    logger.info(`  iconLibrary: ${result.iconLibrary}`);
+    logger.info(`  tsx: ${result.tsx}, rsc: ${result.rsc}`);
+    logger.info("");
+    logger.info("Next: `npx teamix-evo ui add button`");
+  } catch (err) {
+    logger.error(`Failed to initialize ui: ${err.message}`);
+    logger.debug(err.stack ?? "");
+    process.exitCode = 1;
+  }
+});
+async function resolveConfig(opts) {
+  if (opts.yes) {
+    return {
+      aliases: {
+        components: opts.components ?? DEFAULT_UI_ALIASES.components,
+        hooks: opts.hooks ?? DEFAULT_UI_ALIASES.hooks,
+        utils: opts.utils ?? DEFAULT_UI_ALIASES.utils,
+        lib: opts.lib ?? DEFAULT_UI_ALIASES.lib
+      },
+      iconLibrary: opts.iconLibrary ?? "lucide",
+      tsx: opts.tsx ?? true,
+      rsc: opts.rsc ?? false
+    };
+  }
+  const components = await prompts4.text({
+    message: "components \u8DEF\u5F84\uFF08\u6CE8\u5165\u6309\u94AE\u7B49\u7EC4\u4EF6\u6E90\u7801\u7684\u76EE\u5F55\uFF09",
+    initialValue: opts.components ?? DEFAULT_UI_ALIASES.components
+  });
+  if (prompts4.isCancel(components)) throw new Error("Cancelled by user.");
+  const hooks = await prompts4.text({
+    message: "hooks \u8DEF\u5F84",
+    initialValue: opts.hooks ?? DEFAULT_UI_ALIASES.hooks
+  });
+  if (prompts4.isCancel(hooks)) throw new Error("Cancelled by user.");
+  const utils = await prompts4.text({
+    message: "utils \u8DEF\u5F84\uFF08cn \u7B49\u5DE5\u5177\uFF09",
+    initialValue: opts.utils ?? DEFAULT_UI_ALIASES.utils
+  });
+  if (prompts4.isCancel(utils)) throw new Error("Cancelled by user.");
+  const lib = await prompts4.text({
+    message: "lib \u8DEF\u5F84\uFF08\u5171\u4EAB\u4EE3\u7801\u6839\uFF09",
+    initialValue: opts.lib ?? DEFAULT_UI_ALIASES.lib
+  });
+  if (prompts4.isCancel(lib)) throw new Error("Cancelled by user.");
+  const iconLibrary = await prompts4.text({
+    message: "icon \u5E93\uFF08\u58F0\u660E\u6027\uFF0C\u7EC4\u4EF6\u6E90\u7801\u5DF2 hardcode lucide-react\uFF09",
+    initialValue: opts.iconLibrary ?? "lucide"
+  });
+  if (prompts4.isCancel(iconLibrary)) throw new Error("Cancelled by user.");
+  const tsxAns = await prompts4.confirm({
+    message: "\u4F7F\u7528 TSX\uFF1F",
+    initialValue: opts.tsx ?? true
+  });
+  if (prompts4.isCancel(tsxAns)) throw new Error("Cancelled by user.");
+  const rscAns = await prompts4.confirm({
+    message: "\u4F7F\u7528 React Server Components\uFF1F",
+    initialValue: opts.rsc ?? false
+  });
+  if (prompts4.isCancel(rscAns)) throw new Error("Cancelled by user.");
+  return {
+    aliases: { components, hooks, utils, lib },
+    iconLibrary,
+    tsx: tsxAns,
+    rsc: rscAns
+  };
+}
+
+// src/commands/ui/add.ts
+import { Command as Command12 } from "commander";
+
+// src/core/ui-client.ts
+import * as path12 from "path";
+import * as fs10 from "fs/promises";
+import { createRequire as createRequire3 } from "module";
+import { loadUiPackageManifest } from "@teamix-evo/registry";
+var require4 = createRequire3(import.meta.url);
+function resolvePackageRoot3(packageName) {
+  const pkgJsonPath = require4.resolve(`${packageName}/package.json`);
+  return path12.dirname(pkgJsonPath);
+}
+async function loadUiData(packageName) {
+  const packageRoot = resolvePackageRoot3(packageName);
+  logger.debug(`Resolved ui package root: ${packageRoot}`);
+  const manifest = await loadUiPackageManifest(packageRoot);
+  let data = {};
+  const dataPath = path12.join(packageRoot, "_data.json");
+  try {
+    const raw = await fs10.readFile(dataPath, "utf-8");
+    data = JSON.parse(raw);
+  } catch (err) {
+    if (err.code !== "ENOENT") {
+      throw err;
+    }
+    logger.debug(`No _data.json found at ${dataPath}, using empty data`);
+  }
+  return { manifest, data, packageRoot };
+}
+
+// src/core/ui-installer.ts
+import * as path13 from "path";
+import * as fs11 from "fs/promises";
+import { resolveUiEntryOrder } from "@teamix-evo/registry";
+
+// src/utils/transform-imports.ts
+var SOURCE_ROOT_TO_ALIAS_KEY = {
+  components: "components",
+  hooks: "hooks",
+  utils: "utils",
+  lib: "lib"
+};
+function rewriteImports(source, aliases) {
+  return source.replace(
+    /(['"])@\/([a-z][a-z0-9-]*)(\/[^'"]*)?\1/g,
+    (full, quote, root, rest) => {
+      const aliasKey = SOURCE_ROOT_TO_ALIAS_KEY[root];
+      if (!aliasKey) return full;
+      const alias = aliases[aliasKey];
+      const normalized = aliasToImportPath(alias);
+      return `${quote}${normalized}${rest ?? ""}${quote}`;
+    }
+  );
+}
+function aliasToImportPath(alias) {
+  const trimmed = alias.replace(/^\.\//, "").replace(/\/$/, "");
+  if (trimmed.startsWith("src/")) {
+    return `@/${trimmed.slice("src/".length)}`;
+  }
+  return `@/${trimmed}`;
+}
+
+// src/core/ui-installer.ts
+var DESIGN_COMPONENTS_DIR = ".teamix-evo/design/components";
+async function installUiEntries(options) {
+  const {
+    projectRoot,
+    manifest,
+    packageRoot,
+    aliases,
+    requested,
+    skipExisting = true
+  } = options;
+  const orderedIds = resolveUiEntryOrder(manifest.entries, requested);
+  const idToEntry = new Map(manifest.entries.map((e) => [e.id, e]));
+  const resources = [];
+  const npmDeps = {};
+  const metaFiles = [];
+  let written = 0;
+  let skipped = 0;
+  for (const id of orderedIds) {
+    const entry = idToEntry.get(id);
+    if (!entry) continue;
+    if (entry.dependencies) {
+      for (const [name, range] of Object.entries(entry.dependencies)) {
+        npmDeps[name] = range;
+      }
+    }
+    for (const file of entry.files) {
+      const targetAbs = resolveTargetPath(projectRoot, aliases, entry, file);
+      const exists = await fileExists(targetAbs);
+      if (exists && skipExisting && (entry.updateStrategy ?? "frozen") === "frozen") {
+        logger.info(`  skip (frozen, exists): ${rel(projectRoot, targetAbs)}`);
+        skipped++;
+        continue;
+      }
+      const sourceAbs = path13.resolve(packageRoot, file.source);
+      const raw = await fs11.readFile(sourceAbs, "utf-8");
+      const transformed = rewriteImports(raw, aliases);
+      await writeFileSafe(targetAbs, transformed);
+      written++;
+      logger.info(`  write: ${rel(projectRoot, targetAbs)}`);
+      resources.push({
+        id: `${entry.id}:${file.targetName}`,
+        target: targetAbs,
+        hash: computeHash(transformed),
+        strategy: entry.updateStrategy ?? "frozen"
+      });
+    }
+    if (entry.meta) {
+      const metaSourceAbs = path13.resolve(packageRoot, entry.meta);
+      const metaContent = await fs11.readFile(metaSourceAbs, "utf-8");
+      const metaTargetAbs = path13.join(
+        projectRoot,
+        DESIGN_COMPONENTS_DIR,
+        `${entry.id}.meta.md`
+      );
+      await writeFileSafe(metaTargetAbs, metaContent);
+      metaFiles.push(metaTargetAbs);
+      resources.push({
+        id: `${entry.id}:meta`,
+        target: metaTargetAbs,
+        hash: computeHash(metaContent),
+        strategy: "regenerable"
+      });
+      logger.info(`  meta:  ${rel(projectRoot, metaTargetAbs)}`);
+    }
+  }
+  return {
+    orderedIds,
+    resources,
+    npmDependencies: npmDeps,
+    written,
+    skipped,
+    metaFiles
+  };
+}
+function resolveTargetPath(projectRoot, aliases, entry, file) {
+  const aliasDir = aliases[file.targetAlias];
+  if (!aliasDir) {
+    throw new Error(
+      `Entry "${entry.id}" requires alias "${file.targetAlias}" but it is not configured.`
+    );
+  }
+  return path13.join(projectRoot, aliasDir, file.targetName);
+}
+function rel(projectRoot, abs) {
+  return path13.relative(projectRoot, abs);
+}
+
+// src/core/ui-add.ts
+var DEFAULT_UI_PACKAGE = "@teamix-evo/ui";
+async function runUiAdd(options) {
+  const { projectRoot, ids, overwrite } = options;
+  const packageName = options.packageName ?? DEFAULT_UI_PACKAGE;
+  if (ids.length === 0) {
+    throw new Error("At least one entry id must be provided.");
+  }
+  const config = await readProjectConfig(projectRoot);
+  const uiCfg = config?.packages?.ui;
+  if (!config || !uiCfg?.aliases) {
+    throw new Error(
+      "UI not initialized. Run `runUiInit` (or `teamix-evo ui init`) first."
+    );
+  }
+  const { manifest, packageRoot } = await loadUiData(packageName);
+  const knownIds = new Set(manifest.entries.map((e) => e.id));
+  const unknown = ids.filter((id) => !knownIds.has(id));
+  if (unknown.length > 0) {
+    throw new Error(
+      `Unknown entry id(s): ${unknown.map((s) => `"${s}"`).join(", ")}. Run \`teamix-evo ui list\` to see options.`
+    );
+  }
+  const result = await installUiEntries({
+    projectRoot,
+    manifest,
+    packageRoot,
+    aliases: uiCfg.aliases,
+    requested: ids,
+    skipExisting: !overwrite
+  });
+  const installed = await readInstalledManifest(
+    projectRoot
+  ) ?? { schemaVersion: 1, installed: [] };
+  const idx = installed.installed.findIndex((p) => p.package === packageName);
+  const prior = idx >= 0 ? installed.installed[idx] : null;
+  const mergedResources = mergeResources(
+    prior?.resources ?? [],
+    result.resources
+  );
+  const entry = {
+    package: packageName,
+    variant: "_flat",
+    version: manifest.version,
+    installedAt: (/* @__PURE__ */ new Date()).toISOString(),
+    resources: mergedResources
+  };
+  if (idx >= 0) installed.installed[idx] = entry;
+  else installed.installed.push(entry);
+  await writeInstalledManifest(projectRoot, installed);
+  if (uiCfg.version !== manifest.version) {
+    uiCfg.version = manifest.version;
+    await writeProjectConfig(projectRoot, config);
+  }
+  return {
+    packageName,
+    orderedIds: result.orderedIds,
+    written: result.written,
+    skipped: result.skipped,
+    metaFiles: result.metaFiles,
+    npmDependencies: result.npmDependencies,
+    resources: result.resources
+  };
+}
+function mergeResources(prior, next) {
+  const merged = /* @__PURE__ */ new Map();
+  for (const r of prior) merged.set(r.id, r);
+  for (const r of next) merged.set(r.id, r);
+  return Array.from(merged.values());
+}
+
+// src/commands/ui/add.ts
+var addCommand2 = new Command12("add").description(
+  "\u5B89\u88C5\u4E00\u4E2A\u6216\u591A\u4E2A ui entry\uFF08\u6309 id\uFF0C\u81EA\u52A8\u5C55\u5F00 registryDependencies\uFF09"
+).argument("<ids...>", 'entry id \u5217\u8868\uFF0C\u5982 "button" "dialog"').option("--overwrite", "\u5373\u4F7F\u76EE\u6807\u6587\u4EF6\u5DF2\u5B58\u5728\u4E5F\u8986\u76D6\uFF08\u7ED5\u8FC7 frozen \u8DF3\u8FC7\uFF09").action(async (ids, opts) => {
+  try {
+    const ide = detectIde();
+    const projectRoot = ide.getProjectRoot();
+    logger.info(`Installing entries: ${ids.join(", ")}`);
+    const result = await runUiAdd({
+      projectRoot,
+      ids,
+      overwrite: opts.overwrite
+    });
+    logger.success(
+      `UI add complete: ${result.written} written, ${result.skipped} skipped, ${result.metaFiles.length} meta.`
+    );
+    logger.info("");
+    logger.info(`Resolved order: ${result.orderedIds.join(" \u2192 ")}`);
+    const npmDeps = Object.entries(result.npmDependencies);
+    if (npmDeps.length > 0) {
+      logger.info("");
+      logger.info("Install npm dependencies in your project:");
+      const installCmd = npmDeps.map(([name, range]) => `${name}@${range}`).join(" ");
+      logger.info(`  pnpm add ${installCmd}`);
+      logger.info(`  # or: npm install ${installCmd}`);
+    }
+    if (result.metaFiles.length > 0) {
+      logger.info("");
+      logger.info(
+        "Component meta dropped under .teamix-evo/design/components/ (AI-readable)."
+      );
+    }
+  } catch (err) {
+    const message = err.message;
+    if (message.startsWith("UI not initialized")) {
+      logger.error("UI not initialized. Run `npx teamix-evo ui init` first.");
+    } else {
+      logger.error(`Failed to add ui entries: ${message}`);
+    }
+    logger.debug(err.stack ?? "");
+    process.exitCode = 1;
+  }
+});
+
+// src/commands/ui/list.ts
+import { Command as Command13 } from "commander";
+
+// src/core/ui-list.ts
+var DEFAULT_UI_PACKAGE2 = "@teamix-evo/ui";
+async function runUiList(options) {
+  const { projectRoot, installedOnly } = options;
+  const packageName = options.packageName ?? DEFAULT_UI_PACKAGE2;
+  const { manifest } = await loadUiData(packageName);
+  const installedManifest = await readInstalledManifest(projectRoot);
+  const installedIds = /* @__PURE__ */ new Set();
+  const uiPkg = installedManifest?.installed.find(
+    (p) => p.package === packageName
+  );
+  for (const r of uiPkg?.resources ?? []) {
+    const colon = r.id.indexOf(":");
+    installedIds.add(colon >= 0 ? r.id.slice(0, colon) : r.id);
+  }
+  const entries = manifest.entries.filter((e) => !installedOnly || installedIds.has(e.id)).map((e) => ({
+    id: e.id,
+    type: e.type,
+    description: e.description,
+    installed: installedIds.has(e.id)
+  }));
+  return {
+    packageName,
+    total: manifest.entries.length,
+    installedCount: installedIds.size,
+    entries
+  };
+}
+
+// src/commands/ui/list.ts
+var listCommand3 = new Command13("list").description("\u5217\u51FA @teamix-evo/ui \u7684\u6240\u6709 entry \u53CA\u5DF2\u5B89\u88C5\u72B6\u6001").option("--installed", "\u4EC5\u5C55\u793A\u5DF2\u5B89\u88C5\u7684 entry").action(async (opts) => {
+  try {
+    const ide = detectIde();
+    const projectRoot = ide.getProjectRoot();
+    const { entries, total, installedCount } = await runUiList({
+      projectRoot,
+      installedOnly: opts.installed
+    });
+    if (entries.length === 0) {
+      logger.info(
+        opts.installed ? "No ui entries installed." : "No ui entries available."
+      );
+      return;
+    }
+    const idWidth = Math.max(...entries.map((e) => e.id.length), 4);
+    const typeWidth = Math.max(...entries.map((e) => e.type.length), 4);
+    logger.info(
+      `${"ID".padEnd(idWidth)}  ${"TYPE".padEnd(
+        typeWidth
+      )}  STATUS   DESCRIPTION`
+    );
+    logger.info(
+      `${"\u2500".repeat(idWidth)}  ${"\u2500".repeat(
+        typeWidth
+      )}  \u2500\u2500\u2500\u2500\u2500\u2500\u2500  \u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500`
+    );
+    for (const e of entries) {
+      const status = e.installed ? "INSTALLED" : "\u2013";
+      logger.info(
+        `${e.id.padEnd(idWidth)}  ${e.type.padEnd(
+          typeWidth
+        )}  ${status.padEnd(7)}  ${e.description}`
+      );
+    }
+    logger.info("");
+    logger.info(
+      `Total: ${total} entr${total === 1 ? "y" : "ies"}, ${installedCount} installed.`
+    );
+  } catch (err) {
+    logger.error(`Failed to list ui entries: ${err.message}`);
+    logger.debug(err.stack ?? "");
+    process.exitCode = 1;
+  }
+});
+
+// src/commands/ui/index.ts
+var uiCommand = new Command14("ui").description(
+  "\u7BA1\u7406 teamix-evo ui \u7EC4\u4EF6\uFF08\u6E90\u7801\u6CE8\u5165\u5F0F\u5B89\u88C5\uFF0Cshadcn \u98CE\u683C\uFF09"
+);
+uiCommand.addCommand(initCommand2);
+uiCommand.addCommand(addCommand2);
+uiCommand.addCommand(listCommand3);
 
 // src/index.ts
-var program = new Command5();
-program.name("teamix-evo").description("Where ideas evolve. \u2014 AI Coding \u5957\u4EF6").version("0.0.0");
+var require5 = createRequire4(import.meta.url);
+var { version } = require5("../package.json");
+var program = new Command15();
+program.name("teamix-evo").description("Where ideas evolve. \u2014 AI Coding \u5957\u4EF6").version(version);
 program.addCommand(designCommand);
+program.addCommand(skillsCommand);
+program.addCommand(uiCommand);
 program.parse();
 //# sourceMappingURL=index.js.map