teamix-evo 0.1.0 → 0.3.0

package/dist/core/index.js

@@ -0,0 +1,1521 @@
+// src/core/design-init.ts
+import * as path9 from "path";
+import * as fs6 from "fs/promises";
+import { createRequire as createRequire2 } from "module";
+import {
+  loadDesignPack,
+  loadDesignPackageManifest,
+  mergeDefaultAndVariant
+} from "@teamix-evo/registry";
+
+// src/utils/fs.ts
+import * as fs from "fs/promises";
+import * as path from "path";
+
+// src/utils/logger.ts
+import { red, yellow, cyan, green, gray } from "kolorist";
+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/utils/fs.ts
+async function ensureDir(dir) {
+  await fs.mkdir(dir, { recursive: true });
+}
+async function writeFileSafe(filePath, content) {
+  const dir = path.dirname(filePath);
+  await ensureDir(dir);
+  const tmp = filePath + ".tmp";
+  await fs.writeFile(tmp, content, "utf-8");
+  await fs.rename(tmp, filePath);
+}
+async function readFileOrNull(filePath) {
+  try {
+    return await fs.readFile(filePath, "utf-8");
+  } catch (err) {
+    if (err.code === "ENOENT") {
+      return null;
+    }
+    throw err;
+  }
+}
+async function backupFile(filePath, projectRoot) {
+  const content = await readFileOrNull(filePath);
+  if (content === null) {
+    logger.debug(`Skip backup: ${filePath} does not exist`);
+    return;
+  }
+  const rel2 = path.relative(projectRoot, filePath);
+  const timestamp = (/* @__PURE__ */ new Date()).toISOString().replace(/[:.]/g, "-");
+  const backupPath = path.join(
+    projectRoot,
+    ".teamix-evo",
+    ".backups",
+    `${rel2}.${timestamp}.bak`
+  );
+  await ensureDir(path.dirname(backupPath));
+  await fs.writeFile(backupPath, content, "utf-8");
+  logger.debug(`Backed up ${rel2} \u2192 ${path.relative(projectRoot, backupPath)}`);
+}
+async function fileExists(filePath) {
+  try {
+    await fs.access(filePath);
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+// src/utils/hash.ts
+import { createHash } from "crypto";
+function computeHash(content) {
+  const hash = createHash("sha256").update(content, "utf-8").digest("hex");
+  return `sha256:${hash}`;
+}
+
+// src/core/design-pack-classify.ts
+import * as path2 from "path";
+var TEAMIX_DIR = ".teamix-evo/design";
+var TOKENS_DIR = ".teamix-evo/tokens";
+var TOKENS_PACK_PREFIX = "foundations/tokens/";
+var ROOT_MANAGED_FILES = {
+  "DESIGN.md": { target: "DESIGN.md", managedRegions: ["core"] },
+  "AGENTS.md": { target: "AGENTS.md", managedRegions: ["teamix-evo"] },
+  "CLAUDE.md": { target: "CLAUDE.md", managedRegions: ["teamix-evo"] }
+};
+var FROZEN_FILES = /* @__PURE__ */ new Set([
+  "foundations/tokens/tokens.overrides.css"
+]);
+function classifyPackFile(relPath) {
+  if (path2.basename(relPath) === "README.md") {
+    return null;
+  }
+  const rootManaged = ROOT_MANAGED_FILES[relPath];
+  if (rootManaged) {
+    return {
+      target: rootManaged.target,
+      strategy: "managed",
+      managedRegions: rootManaged.managedRegions,
+      isFrozen: false
+    };
+  }
+  if (relPath.startsWith(TOKENS_PACK_PREFIX)) {
+    const rel2 = relPath.slice(TOKENS_PACK_PREFIX.length);
+    const target = path2.posix.join(TOKENS_DIR, rel2);
+    if (FROZEN_FILES.has(relPath)) {
+      return { target, strategy: "frozen", isFrozen: true };
+    }
+    return { target, strategy: "regenerable", isFrozen: false };
+  }
+  if (FROZEN_FILES.has(relPath)) {
+    return {
+      target: path2.posix.join(TEAMIX_DIR, relPath),
+      strategy: "frozen",
+      isFrozen: true
+    };
+  }
+  return {
+    target: path2.posix.join(TEAMIX_DIR, relPath),
+    strategy: "regenerable",
+    isFrozen: false
+  };
+}
+
+// src/core/state.ts
+import * as path3 from "path";
+import {
+  validateConfig,
+  validateInstalled,
+  validateSkillsLock,
+  DesignPackLockSchema
+} from "@teamix-evo/registry";
+var TEAMIX_DIR2 = ".teamix-evo";
+var CONFIG_FILE = "config.json";
+var MANIFEST_FILE = "manifest.json";
+var DESIGN_DIR = "design";
+var DESIGN_LOCK_FILE = "pack.lock.json";
+var SKILLS_DIR = "skills";
+var SKILLS_LOCK_FILE = "manifest.lock.json";
+function getTeamixDir(projectRoot) {
+  return path3.join(projectRoot, TEAMIX_DIR2);
+}
+async function ensureTeamixDir(projectRoot) {
+  const dir = getTeamixDir(projectRoot);
+  await ensureDir(dir);
+  return dir;
+}
+async function readProjectConfig(projectRoot) {
+  const configPath = path3.join(projectRoot, TEAMIX_DIR2, CONFIG_FILE);
+  const raw = await readFileOrNull(configPath);
+  if (raw === null) return null;
+  try {
+    const data = JSON.parse(raw);
+    const result = validateConfig(data);
+    if (!result.success) {
+      logger.warn(`Invalid config.json: ${result.error}`);
+      return null;
+    }
+    return result.data;
+  } catch (err) {
+    logger.warn(`Failed to parse config.json: ${err.message}`);
+    return null;
+  }
+}
+async function writeProjectConfig(projectRoot, config) {
+  const configPath = path3.join(projectRoot, TEAMIX_DIR2, CONFIG_FILE);
+  await writeFileSafe(configPath, JSON.stringify(config, null, 2) + "\n");
+  logger.debug(`Wrote config \u2192 ${configPath}`);
+}
+async function readInstalledManifest(projectRoot) {
+  const manifestPath = path3.join(projectRoot, TEAMIX_DIR2, MANIFEST_FILE);
+  const raw = await readFileOrNull(manifestPath);
+  if (raw === null) return null;
+  try {
+    const data = JSON.parse(raw);
+    const result = validateInstalled(data);
+    if (!result.success) {
+      logger.warn(`Invalid manifest.json: ${result.error}`);
+      return null;
+    }
+    return result.data;
+  } catch (err) {
+    logger.warn(`Failed to parse manifest.json: ${err.message}`);
+    return null;
+  }
+}
+async function writeInstalledManifest(projectRoot, manifest) {
+  const manifestPath = path3.join(projectRoot, TEAMIX_DIR2, MANIFEST_FILE);
+  await writeFileSafe(manifestPath, JSON.stringify(manifest, null, 2) + "\n");
+  logger.debug(`Wrote manifest \u2192 ${manifestPath}`);
+}
+async function readDesignPackLock(projectRoot) {
+  const lockPath = path3.join(
+    projectRoot,
+    TEAMIX_DIR2,
+    DESIGN_DIR,
+    DESIGN_LOCK_FILE
+  );
+  const raw = await readFileOrNull(lockPath);
+  if (raw === null) return null;
+  try {
+    const parsed = DesignPackLockSchema.safeParse(JSON.parse(raw));
+    if (!parsed.success) {
+      logger.warn(`Invalid design pack.lock.json: ${parsed.error.message}`);
+      return null;
+    }
+    return parsed.data;
+  } catch (err) {
+    logger.warn(
+      `Failed to parse design pack.lock.json: ${err.message}`
+    );
+    return null;
+  }
+}
+async function readDesignVariant(projectRoot) {
+  const lock = await readDesignPackLock(projectRoot);
+  return lock?.variant.name ?? null;
+}
+function getSkillsSourceDir(projectRoot, skillName) {
+  const base = path3.join(projectRoot, TEAMIX_DIR2, SKILLS_DIR);
+  return skillName ? path3.join(base, skillName) : base;
+}
+async function readSkillsLock(projectRoot) {
+  const lockPath = path3.join(
+    projectRoot,
+    TEAMIX_DIR2,
+    SKILLS_DIR,
+    SKILLS_LOCK_FILE
+  );
+  const raw = await readFileOrNull(lockPath);
+  if (raw === null) return null;
+  try {
+    const data = JSON.parse(raw);
+    const result = validateSkillsLock(data);
+    if (!result.success) {
+      logger.warn(`Invalid skills manifest.lock.json: ${result.error}`);
+      return null;
+    }
+    return result.data;
+  } catch (err) {
+    logger.warn(
+      `Failed to parse skills manifest.lock.json: ${err.message}`
+    );
+    return null;
+  }
+}
+async function writeSkillsLock(projectRoot, lock) {
+  const lockPath = path3.join(
+    projectRoot,
+    TEAMIX_DIR2,
+    SKILLS_DIR,
+    SKILLS_LOCK_FILE
+  );
+  await writeFileSafe(lockPath, JSON.stringify(lock, null, 2) + "\n");
+  logger.debug(`Wrote skills lock \u2192 ${lockPath}`);
+}
+
+// src/core/skills-client.ts
+import * as path4 from "path";
+import * as fs2 from "fs/promises";
+import { createRequire } from "module";
+import { loadSkillsPackageManifest } from "@teamix-evo/registry";
+var require2 = createRequire(import.meta.url);
+function resolvePackageRoot(packageName) {
+  const pkgJsonPath = require2.resolve(`${packageName}/package.json`);
+  return path4.dirname(pkgJsonPath);
+}
+async function loadSkillsData(packageName) {
+  const packageRoot = resolvePackageRoot(packageName);
+  logger.debug(`Resolved skills package root: ${packageRoot}`);
+  const manifest = await loadSkillsPackageManifest(packageRoot);
+  let data = {};
+  const dataPath = path4.join(packageRoot, "_data.json");
+  try {
+    const raw = await fs2.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 path8 from "path";
+import * as fs5 from "fs/promises";
+import { replaceManagedRegion } from "@teamix-evo/registry";
+
+// src/ide/QoderAdapter.ts
+import * as os from "os";
+import * as path5 from "path";
+var QoderAdapter = class {
+  kind = "qoder";
+  name = "qoder";
+  getProjectRoot() {
+    return process.cwd();
+  }
+  detectIde() {
+    return true;
+  }
+  getSkillTargetDir(skillName, scope, projectRoot) {
+    const base = scope === "global" ? path5.join(os.homedir(), ".qoder") : path5.join(projectRoot ?? this.getProjectRoot(), ".qoder");
+    return path5.join(base, "skills", skillName);
+  }
+};
+
+// src/ide/ClaudeAdapter.ts
+import * as os2 from "os";
+import * as path6 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" ? path6.join(os2.homedir(), ".claude") : path6.join(projectRoot ?? this.getProjectRoot(), ".claude");
+    return path6.join(base, "skills", skillName);
+  }
+};
+
+// src/ide/index.ts
+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}`);
+    }
+  }
+}
+
+// src/utils/template.ts
+import Handlebars from "handlebars";
+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 = getCompiledTemplate(templateContent);
+  return compiled(data);
+}
+async function loadTemplateFile(filePath) {
+  return fs3.readFile(filePath, "utf-8");
+}
+
+// src/utils/path.ts
+import * as path7 from "path";
+import * as fs4 from "fs/promises";
+function resolveSourcePath(source, variantDir, packageRoot) {
+  if (source.startsWith("_template/")) {
+    return path7.join(packageRoot, source);
+  }
+  return path7.join(variantDir, source);
+}
+async function walkDir(dir) {
+  const files = [];
+  const entries = await fs4.readdir(dir, { withFileTypes: true });
+  for (const entry of entries) {
+    const fullPath = path7.join(dir, entry.name);
+    if (entry.isDirectory()) {
+      files.push(...await walkDir(fullPath));
+    } else if (entry.isFile()) {
+      files.push(fullPath);
+    }
+  }
+  return files;
+}
+
+// src/core/skills-installer.ts
+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;
+    }
+    const sourceRecords = await writeSkillSource(skill, options);
+    installed.push(...sourceRecords);
+    for (const ide of skillIdes) {
+      const mirrorRecords = await mirrorSkillToIde(
+        skill,
+        ide,
+        scope,
+        options.projectRoot
+      );
+      installed.push(...mirrorRecords);
+    }
+  }
+  return { resources: installed, count: installed.length };
+}
+async function writeSkillSource(skill, options) {
+  const { data, packageRoot, projectRoot } = options;
+  const sourceAbs = path8.resolve(packageRoot, skill.source);
+  const targetDir = getSkillsSourceDir(projectRoot, skill.name);
+  const stat2 = await fs5.stat(sourceAbs);
+  const records = [];
+  if (stat2.isFile()) {
+    const targetFile = path8.join(targetDir, "SKILL.md");
+    const content = await renderSkillContent(sourceAbs, skill, data);
+    await writeFileSafe(targetFile, content);
+    records.push(makeSourceRecord(skill, targetFile, content));
+    logger.debug(`  Wrote source: ${targetFile}`);
+    return records;
+  }
+  await ensureDir(targetDir);
+  const entries = await walkDir(sourceAbs);
+  for (const entry of entries) {
+    const rel2 = path8.relative(sourceAbs, entry);
+    let targetFile = path8.join(targetDir, rel2);
+    if (skill.template && targetFile.endsWith(".hbs")) {
+      targetFile = targetFile.slice(0, -4);
+    }
+    const content = skill.template && entry.endsWith(".hbs") ? renderTemplate(await loadTemplateFile(entry), { ...data, skill }) : await fs5.readFile(entry, "utf-8");
+    await writeFileSafe(targetFile, content);
+    const relWritten = path8.relative(targetDir, targetFile);
+    records.push(makeSourceRecord(skill, targetFile, content, relWritten));
+    logger.debug(`  Wrote source: ${targetFile}`);
+  }
+  return records;
+}
+async function mirrorSkillToIde(skill, ide, scope, projectRoot) {
+  const sourceDir = getSkillsSourceDir(projectRoot, skill.name);
+  const adapter = getAdapter(ide);
+  const targetDir = adapter.getSkillTargetDir(skill.name, scope, projectRoot);
+  const records = [];
+  const sourceFiles = await walkDir(sourceDir);
+  await ensureDir(targetDir);
+  for (const src of sourceFiles) {
+    const rel2 = path8.relative(sourceDir, src);
+    const targetFile = path8.join(targetDir, rel2);
+    const content = await fs5.readFile(src, "utf-8");
+    await writeFileSafe(targetFile, content);
+    records.push(makeMirrorRecord(skill, targetFile, content, ide, scope, rel2));
+    logger.debug(`  Mirrored ${ide}:${scope}: ${targetFile}`);
+  }
+  return records;
+}
+async function renderSkillContent(sourceAbs, skill, data) {
+  if (skill.template ?? sourceAbs.endsWith(".hbs")) {
+    const tpl = await loadTemplateFile(sourceAbs);
+    return renderTemplate(tpl, { ...data, skill });
+  }
+  return fs5.readFile(sourceAbs, "utf-8");
+}
+function makeSourceRecord(skill, targetAbs, content, rel2) {
+  const id = rel2 ? `${skill.id}:source:${rel2}` : `${skill.id}:source`;
+  return {
+    id,
+    target: targetAbs,
+    hash: computeHash(content),
+    strategy: skill.updateStrategy
+  };
+}
+function makeMirrorRecord(skill, targetAbs, content, ide, scope, rel2) {
+  const id = rel2 && rel2 !== "SKILL.md" ? `${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, projectRoot } = options;
+  const summary = { overwritten: 0, managed: 0, skipped: 0, created: 0 };
+  const updated = [];
+  for (const skill of manifest.skills) {
+    const skillIdes = skill.ides.filter((i) => ides.includes(i));
+    if (skillIdes.length === 0) continue;
+    const sourceRecords = await rewriteSkillSource(
+      skill,
+      options,
+      summary
+    );
+    updated.push(...sourceRecords);
+    for (const ide of skillIdes) {
+      const mirrorRecords = await mirrorSkillToIde(
+        skill,
+        ide,
+        scope,
+        projectRoot
+      );
+      updated.push(...mirrorRecords);
+    }
+  }
+  return { resources: updated, summary };
+}
+async function rewriteSkillSource(skill, options, summary) {
+  const { data, packageRoot, projectRoot } = options;
+  const sourceAbs = path8.resolve(packageRoot, skill.source);
+  const targetDir = getSkillsSourceDir(projectRoot, skill.name);
+  const stat2 = await fs5.stat(sourceAbs);
+  if (!stat2.isFile()) {
+    await ensureDir(targetDir);
+    const entries = await walkDir(sourceAbs);
+    const records = [];
+    for (const entry of entries) {
+      const rel2 = path8.relative(sourceAbs, entry);
+      let targetFile2 = path8.join(targetDir, rel2);
+      if (skill.template && targetFile2.endsWith(".hbs")) {
+        targetFile2 = targetFile2.slice(0, -4);
+      }
+      const content = skill.template && entry.endsWith(".hbs") ? renderTemplate(await loadTemplateFile(entry), { ...data, skill }) : await fs5.readFile(entry, "utf-8");
+      const exists2 = await fileExists(targetFile2);
+      if (exists2) {
+        await backupFile(targetFile2, projectRoot);
+        summary.overwritten++;
+      } else {
+        summary.created++;
+      }
+      await writeFileSafe(targetFile2, content);
+      const relWritten = path8.relative(targetDir, targetFile2);
+      records.push(makeSourceRecord(skill, targetFile2, content, relWritten));
+    }
+    return records;
+  }
+  const targetFile = path8.join(targetDir, "SKILL.md");
+  const newContent = await renderSkillContent(sourceAbs, skill, data);
+  const exists = await fileExists(targetFile);
+  if (skill.updateStrategy === "frozen") {
+    if (exists) {
+      summary.skipped++;
+      const current2 = await readFileOrNull(targetFile) ?? newContent;
+      return [makeSourceRecord(skill, targetFile, current2)];
+    }
+    await writeFileSafe(targetFile, newContent);
+    summary.created++;
+    return [makeSourceRecord(skill, targetFile, newContent)];
+  }
+  if (skill.updateStrategy === "regenerable" || !exists) {
+    if (exists) {
+      await backupFile(targetFile, projectRoot);
+      summary.overwritten++;
+    } else {
+      summary.created++;
+    }
+    await writeFileSafe(targetFile, newContent);
+    return [makeSourceRecord(skill, targetFile, newContent)];
+  }
+  const current = await readFileOrNull(targetFile);
+  let merged = current ?? newContent;
+  for (const regionId of skill.managedRegions ?? []) {
+    const re = new RegExp(
+      `<!-- teamix-evo:managed:start id="${escapeRegExp(
+        regionId
+      )}" -->([\\s\\S]*?)<!-- teamix-evo:managed:end id="${escapeRegExp(
+        regionId
+      )}" -->`
+    );
+    const match = newContent.match(re);
+    if (match) {
+      const region = match[1].replace(/^\n/, "").replace(/\n$/, "");
+      try {
+        merged = replaceManagedRegion(merged, regionId, region);
+      } catch {
+        logger.warn(
+          `Managed region "${regionId}" not found in ${targetFile}. Skipped.`
+        );
+      }
+    }
+  }
+  await backupFile(targetFile, projectRoot);
+  await writeFileSafe(targetFile, merged);
+  summary.managed++;
+  return [makeSourceRecord(skill, targetFile, merged)];
+}
+function escapeRegExp(str) {
+  return str.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+}
+async function syncSkillsToIdes(options) {
+  const { projectRoot, skills, ides, scope, onlyIds } = options;
+  const out = [];
+  const targets = skills.filter((s) => !onlyIds || onlyIds.includes(s.id));
+  for (const skill of targets) {
+    const sourceDir = getSkillsSourceDir(projectRoot, skill.name);
+    if (!await fileExists(sourceDir)) {
+      logger.warn(
+        `Skill "${skill.id}" has no source at ${sourceDir}; skipped.`
+      );
+      continue;
+    }
+    for (const ide of ides) {
+      const adapter = getAdapter(ide);
+      const targetDir = adapter.getSkillTargetDir(
+        skill.name,
+        scope,
+        projectRoot
+      );
+      await ensureDir(targetDir);
+      const sourceFiles = await walkDir(sourceDir);
+      for (const src of sourceFiles) {
+        const rel2 = path8.relative(sourceDir, src);
+        const targetFile = path8.join(targetDir, rel2);
+        const content = await fs5.readFile(src, "utf-8");
+        await writeFileSafe(targetFile, content);
+        out.push({
+          id: rel2 === "SKILL.md" ? skill.id : `${skill.id}:${rel2}`,
+          target: targetFile,
+          hash: computeHash(content),
+          strategy: skill.updateStrategy,
+          ide,
+          scope
+        });
+      }
+    }
+  }
+  return { resources: out, count: out.length };
+}
+async function removeSkillFiles(records) {
+  const removed = [];
+  for (const r of records) {
+    try {
+      await fs5.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) => path8.dirname(r.target)));
+  for (const dir of parents) {
+    try {
+      const entries = await fs5.readdir(dir);
+      if (entries.length === 0) await fs5.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);
+  const currentDesignVariant = await readDesignVariant(projectRoot);
+  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 existingLock = await readSkillsLock(projectRoot);
+  const existingSkillIds = /* @__PURE__ */ new Set([
+    ...Object.keys(existingLock?.skills ?? {}),
+    // Legacy fallback: pre-ADR-0013 installs only had manifest.json. Derive
+    // skill ids by stripping the trailing :source / :sub-file suffix.
+    ...(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.filter((s) => {
+      if (!s.variant) return true;
+      if (!currentDesignVariant) {
+        logger.debug(
+          `Skipping variant-bound skill "${s.id}" (variant=${s.variant}): no design pack installed; will be picked up when "design init" runs.`
+        );
+        return false;
+      }
+      if (s.variant !== currentDesignVariant) {
+        logger.debug(
+          `Skipping variant-bound skill "${s.id}" (variant=${s.variant}): current design variant is "${currentDesignVariant}".`
+        );
+        return false;
+      }
+      return true;
+    }).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 installedAt = (/* @__PURE__ */ new Date()).toISOString();
+  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,
+    resources: mergedResources
+  };
+  if (idx >= 0) installedManifest.installed[idx] = entry;
+  else installedManifest.installed.push(entry);
+  await writeInstalledManifest(projectRoot, installedManifest);
+  const lock = existingLock ?? {
+    schemaVersion: 1,
+    skills: {}
+  };
+  for (const skillId of onlyIds) {
+    const skillDef = manifest.skills.find((s) => s.id === skillId);
+    if (!skillDef) continue;
+    const mirroredTo = skillDef.ides.filter((i) => ides.includes(i));
+    lock.skills[skillId] = {
+      version: skillDef.version,
+      from: packageName,
+      installedAt,
+      scope,
+      mirroredTo
+    };
+  }
+  await writeSkillsLock(projectRoot, lock);
+  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/core/design-init.ts
+var BASELINE_DESIGN_RULES_SKILL = "teamix-evo-design-rules";
+var DEFAULT_SKILLS_PACKAGE2 = "@teamix-evo/skills";
+var DEFAULT_AUTO_SKILL_IDES = ["qoder", "claude"];
+var DEFAULT_AUTO_SKILL_SCOPE = "project";
+var DEFAULT_DESIGN_PACKAGE = "@teamix-evo/design";
+var require3 = createRequire2(import.meta.url);
+async function runDesignInit(options) {
+  const { projectRoot, variant, 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 packageRoot = options.packageRoot ?? resolveDesignPackageRoot(packageName);
+  const catalog = await loadDesignPackageManifest(packageRoot);
+  const variantEntry = catalog.variants.find((v) => v.name === variant);
+  if (!variantEntry) {
+    const known = catalog.variants.map((v) => v.name).join(", ");
+    throw new Error(
+      `Design variant not found: "${variant}". Known variants: ${known || "(none)"}. Hint: run "teamix-evo design list-variants" to see all.`
+    );
+  }
+  const defaultDir = path9.join(packageRoot, "default");
+  const variantDir = path9.join(packageRoot, "variants", variant);
+  const defaultPack = await loadDesignPack(defaultDir);
+  const variantPack = await loadDesignPack(variantDir);
+  const merge = await mergeDefaultAndVariant(defaultDir, variantDir);
+  const installed = [];
+  for (const file of merge.files) {
+    const result = await installPackFile(file, projectRoot);
+    if (result) installed.push(result);
+  }
+  const lock = {
+    schemaVersion: 1,
+    default: { version: defaultPack.version, from: packageName },
+    variant: {
+      name: variantPack.name,
+      displayName: variantPack.displayName,
+      version: variantPack.version,
+      from: packageName
+    },
+    linked: variantPack.linked,
+    installedAt: (/* @__PURE__ */ new Date()).toISOString()
+  };
+  await writeFileSafe(
+    path9.join(projectRoot, ".teamix-evo", "design", "pack.lock.json"),
+    JSON.stringify(lock, null, 2) + "\n"
+  );
+  const config = {
+    $schema: "https://teamix-evo.dev/schema/config/v1.json",
+    schemaVersion: 1,
+    ide,
+    packages: {
+      design: {
+        variant,
+        version: variantPack.version,
+        tailwind: "v4"
+      }
+    }
+  };
+  await writeProjectConfig(projectRoot, config);
+  const installedManifest = {
+    schemaVersion: 1,
+    installed: [
+      {
+        package: packageName,
+        variant,
+        version: variantPack.version,
+        installedAt: (/* @__PURE__ */ new Date()).toISOString(),
+        resources: installed
+      }
+    ]
+  };
+  await writeInstalledManifest(projectRoot, installedManifest);
+  const skills = await tryAutoInstallVariantSkills({
+    projectRoot,
+    variant,
+    ide
+  });
+  return {
+    status: "installed",
+    packageName,
+    variant,
+    version: variantPack.version,
+    count: installed.length,
+    resources: installed,
+    merge: {
+      overrides: merge.overrides,
+      variantAdds: merge.variantAdds,
+      defaultPassThrough: merge.defaultPassThrough
+    },
+    skills
+  };
+}
+async function tryAutoInstallVariantSkills(args) {
+  const { projectRoot, variant, ide } = args;
+  const variantSkillId = `${BASELINE_DESIGN_RULES_SKILL}-${variant}`;
+  const desired = [BASELINE_DESIGN_RULES_SKILL, variantSkillId];
+  let manifestSkillIds;
+  try {
+    const { manifest } = await loadSkillsData(DEFAULT_SKILLS_PACKAGE2);
+    manifestSkillIds = new Set(manifest.skills.map((s) => s.id));
+  } catch (err) {
+    logger.warn(
+      `Skipping skills auto-install: could not load skills manifest (${err.message}).`
+    );
+    return {
+      attempted: [],
+      addedSkillIds: [],
+      skippedSkillIds: [],
+      missing: desired
+    };
+  }
+  const present = desired.filter((id) => manifestSkillIds.has(id));
+  const missing = desired.filter((id) => !manifestSkillIds.has(id));
+  if (missing.length > 0) {
+    logger.warn(
+      `Skills auto-install: not found in manifest, skipping: ${missing.join(", ")}.`
+    );
+  }
+  if (present.length === 0) {
+    return {
+      attempted: desired,
+      addedSkillIds: [],
+      skippedSkillIds: [],
+      missing
+    };
+  }
+  try {
+    const result = await runSkillsAdd({
+      projectRoot,
+      names: present,
+      ides: DEFAULT_AUTO_SKILL_IDES,
+      scope: DEFAULT_AUTO_SKILL_SCOPE,
+      ide
+    });
+    if (result.status !== "installed") {
+      return {
+        attempted: desired,
+        addedSkillIds: [],
+        skippedSkillIds: present,
+        missing
+      };
+    }
+    return {
+      attempted: desired,
+      addedSkillIds: result.addedSkillIds,
+      skippedSkillIds: result.skippedSkillIds,
+      missing
+    };
+  } catch (err) {
+    logger.warn(
+      `Skills auto-install failed (continuing): ${err.message}`
+    );
+    return {
+      attempted: desired,
+      addedSkillIds: [],
+      skippedSkillIds: [],
+      missing
+    };
+  }
+}
+async function installPackFile(file, projectRoot) {
+  const cls = classifyPackFile(file.relPath);
+  if (cls === null) return null;
+  const targetAbs = path9.join(projectRoot, cls.target);
+  if (cls.isFrozen && await fileExists(targetAbs)) {
+    const existing = await fs6.readFile(targetAbs, "utf-8");
+    return {
+      id: `pack:${file.relPath}`,
+      target: cls.target,
+      hash: computeHash(existing),
+      strategy: cls.strategy
+    };
+  }
+  const content = await fs6.readFile(file.sourcePath, "utf-8");
+  await writeFileSafe(targetAbs, content);
+  return {
+    id: `pack:${file.relPath}`,
+    target: cls.target,
+    hash: computeHash(content),
+    strategy: cls.strategy
+  };
+}
+function resolveDesignPackageRoot(packageName) {
+  const pkgJson = require3.resolve(`${packageName}/package.json`);
+  return path9.dirname(pkgJson);
+}
+
+// src/core/ui-init.ts
+var DEFAULT_UI_ALIASES = {
+  components: "src/components/ui",
+  hooks: "src/hooks",
+  utils: "src/lib/utils",
+  lib: "src/lib",
+  business: "src/components/business",
+  templates: "src/templates"
+};
+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,
+    business: options.aliases?.business ?? DEFAULT_UI_ALIASES.business,
+    templates: options.aliases?.templates ?? DEFAULT_UI_ALIASES.templates
+  };
+  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/core/ui-client.ts
+import * as path10 from "path";
+import * as fs7 from "fs/promises";
+import { createRequire as createRequire3 } from "module";
+import { loadUiPackageManifest } from "@teamix-evo/registry";
+var require4 = createRequire3(import.meta.url);
+function resolvePackageRoot2(packageName) {
+  const pkgJsonPath = require4.resolve(`${packageName}/package.json`);
+  return path10.dirname(pkgJsonPath);
+}
+async function loadUiData(packageName) {
+  const packageRoot = resolvePackageRoot2(packageName);
+  logger.debug(`Resolved ui package root: ${packageRoot}`);
+  const manifest = await loadUiPackageManifest(packageRoot);
+  let data = {};
+  const dataPath = path10.join(packageRoot, "_data.json");
+  try {
+    const raw = await fs7.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 path11 from "path";
+import * as fs8 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);
+      const flatRest = flattenRestPath(rest);
+      return `${quote}${normalized}${flatRest}${quote}`;
+    }
+  );
+}
+function flattenRestPath(rest) {
+  if (!rest) return "";
+  const segments = rest.split("/");
+  if (segments.length === 3) {
+    return `/${segments[2]}`;
+  }
+  return rest;
+}
+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 = path11.resolve(packageRoot, file.source);
+      const raw = await fs8.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 = path11.resolve(packageRoot, entry.meta);
+      const metaContent = await fs8.readFile(metaSourceAbs, "utf-8");
+      const metaTargetAbs = path11.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 path11.join(projectRoot, aliasDir, file.targetName);
+}
+function rel(projectRoot, abs) {
+  return path11.relative(projectRoot, abs);
+}
+async function removeUiFiles(records) {
+  const removed = [];
+  for (const r of records) {
+    try {
+      await fs8.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 fs8.readdir(dir);
+      if (entries.length === 0) await fs8.rmdir(dir);
+    } catch {
+    }
+  }
+  return removed;
+}
+
+// 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/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/core/installer.ts
+import * as path12 from "path";
+import * as fs9 from "fs/promises";
+async function installResources(options) {
+  const { projectRoot, manifest, data, variantDir, packageRoot } = options;
+  const installedResources = [];
+  for (const resource of manifest.resources) {
+    logger.debug(`Installing resource: ${resource.id} \u2192 ${resource.target}`);
+    if (resource.recursive) {
+      const results = await installRecursiveResource(
+        resource,
+        projectRoot,
+        data,
+        variantDir,
+        packageRoot
+      );
+      installedResources.push(...results);
+    } else {
+      const result = await installSingleResource(
+        resource,
+        projectRoot,
+        data,
+        variantDir,
+        packageRoot
+      );
+      installedResources.push(result);
+    }
+  }
+  return {
+    resources: installedResources,
+    count: installedResources.length
+  };
+}
+async function installSingleResource(resource, projectRoot, data, variantDir, packageRoot) {
+  const sourcePath = resolveSourcePath(
+    resource.source,
+    variantDir,
+    packageRoot
+  );
+  const targetPath = path12.join(projectRoot, resource.target);
+  let content;
+  if (resource.template) {
+    const templateContent = await loadTemplateFile(sourcePath);
+    content = renderTemplate(templateContent, data);
+  } else {
+    content = await fs9.readFile(sourcePath, "utf-8");
+  }
+  await writeFileSafe(targetPath, content);
+  const hash = computeHash(content);
+  logger.debug(`  Written: ${resource.target} (${resource.updateStrategy})`);
+  return {
+    id: resource.id,
+    target: resource.target,
+    hash,
+    strategy: resource.updateStrategy
+  };
+}
+async function installRecursiveResource(resource, projectRoot, data, variantDir, packageRoot) {
+  const sourcePath = resolveSourcePath(
+    resource.source,
+    variantDir,
+    packageRoot
+  );
+  const targetDir = path12.join(projectRoot, resource.target);
+  const results = [];
+  await ensureDir(targetDir);
+  const entries = await walkDir(sourcePath);
+  for (const entry of entries) {
+    const relPath = path12.relative(sourcePath, entry);
+    let targetFile = path12.join(targetDir, relPath);
+    if (resource.template && targetFile.endsWith(".hbs")) {
+      targetFile = targetFile.slice(0, -4);
+    }
+    let content;
+    if (resource.template && entry.endsWith(".hbs")) {
+      const templateContent = await loadTemplateFile(entry);
+      content = renderTemplate(templateContent, data);
+    } else {
+      content = await fs9.readFile(entry, "utf-8");
+    }
+    await writeFileSafe(targetFile, content);
+    const hash = computeHash(content);
+    const targetRel = path12.relative(projectRoot, targetFile);
+    results.push({
+      id: `${resource.id}:${relPath}`,
+      target: targetRel,
+      hash,
+      strategy: resource.updateStrategy
+    });
+    logger.debug(`  Written: ${targetRel}`);
+  }
+  return results;
+}
+
+// src/core/registry-client.ts
+import * as path13 from "path";
+import * as fs10 from "fs/promises";
+import { createRequire as createRequire4 } from "module";
+import { loadVariantManifest } from "@teamix-evo/registry";
+var require5 = createRequire4(import.meta.url);
+function resolvePackageRoot3(packageName) {
+  const pkgJsonPath = require5.resolve(`${packageName}/package.json`);
+  return path13.dirname(pkgJsonPath);
+}
+async function loadVariantData(packageName, variant) {
+  const packageRoot = resolvePackageRoot3(packageName);
+  const variantDir = path13.join(packageRoot, "library", variant);
+  logger.debug(`Resolved variant dir: ${variantDir}`);
+  logger.debug(`Package root: ${packageRoot}`);
+  const manifest = await loadVariantManifest(variantDir);
+  let data = {};
+  const dataPath = path13.join(variantDir, "_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, variantDir, packageRoot };
+}
+export {
+  DEFAULT_UI_ALIASES,
+  DEFAULT_UI_ICON_LIBRARY,
+  ensureTeamixDir,
+  getTeamixDir,
+  installResources,
+  installSkills,
+  installUiEntries,
+  loadSkillsData,
+  loadUiData,
+  loadVariantData,
+  readInstalledManifest,
+  readProjectConfig,
+  removeSkillFiles,
+  removeUiFiles,
+  runDesignInit,
+  runSkillsAdd,
+  runUiAdd,
+  runUiInit,
+  runUiList,
+  syncSkillsToIdes,
+  updateSkills,
+  writeInstalledManifest,
+  writeProjectConfig
+};
+//# sourceMappingURL=index.js.map