teamix-evo 0.1.0 → 0.2.0

package/dist/core/index.js

@@ -0,0 +1,1166 @@
+// src/core/registry-client.ts
+import * as path 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 = 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 path.dirname(pkgJsonPath);
+}
+async function loadVariantData(packageName, variant) {
+  const packageRoot = resolvePackageRoot(packageName);
+  const variantDir = path.join(packageRoot, "library", variant);
+  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
+import * as path4 from "path";
+import * as fs5 from "fs/promises";
+
+// src/utils/fs.ts
+import * as fs2 from "fs/promises";
+import * as path2 from "path";
+async function ensureDir(dir) {
+  await fs2.mkdir(dir, { recursive: true });
+}
+async function writeFileSafe(filePath, content) {
+  const dir = path2.dirname(filePath);
+  await ensureDir(dir);
+  const tmp = filePath + ".tmp";
+  await fs2.writeFile(tmp, content, "utf-8");
+  await fs2.rename(tmp, filePath);
+}
+async function readFileOrNull(filePath) {
+  try {
+    return await fs2.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 = path2.relative(projectRoot, filePath);
+  const timestamp = (/* @__PURE__ */ new Date()).toISOString().replace(/[:.]/g, "-");
+  const backupPath = path2.join(
+    projectRoot,
+    ".teamix-evo",
+    ".backups",
+    `${rel2}.${timestamp}.bak`
+  );
+  await ensureDir(path2.dirname(backupPath));
+  await fs2.writeFile(backupPath, content, "utf-8");
+  logger.debug(`Backed up ${rel2} \u2192 ${path2.relative(projectRoot, backupPath)}`);
+}
+async function fileExists(filePath) {
+  try {
+    await fs2.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/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 path3 from "path";
+import * as fs4 from "fs/promises";
+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/installer.ts
+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 = path4.join(projectRoot, resource.target);
+  let content;
+  if (resource.template) {
+    const templateContent = await loadTemplateFile(sourcePath);
+    content = renderTemplate(templateContent, data);
+  } else {
+    content = await fs5.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 = path4.join(projectRoot, resource.target);
+  const results = [];
+  await ensureDir(targetDir);
+  const entries = await walkDir(sourcePath);
+  for (const entry of entries) {
+    const relPath = path4.relative(sourcePath, entry);
+    let targetFile = path4.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 fs5.readFile(entry, "utf-8");
+    }
+    await writeFileSafe(targetFile, content);
+    const hash = computeHash(content);
+    const targetRel = path4.relative(projectRoot, targetFile);
+    results.push({
+      id: `${resource.id}:${relPath}`,
+      target: targetRel,
+      hash,
+      strategy: resource.updateStrategy
+    });
+    logger.debug(`  Written: ${targetRel}`);
+  }
+  return results;
+}
+
+// src/core/state.ts
+import * as path5 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 path5.join(projectRoot, TEAMIX_DIR);
+}
+async function ensureTeamixDir(projectRoot) {
+  const dir = getTeamixDir(projectRoot);
+  await ensureDir(dir);
+  return dir;
+}
+async function readProjectConfig(projectRoot) {
+  const configPath = path5.join(projectRoot, TEAMIX_DIR, 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 = path5.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 = path5.join(projectRoot, TEAMIX_DIR, 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 = path5.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/core/skills-client.ts
+import * as path6 from "path";
+import * as fs6 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 path6.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 = path6.join(packageRoot, "_data.json");
+  try {
+    const raw = await fs6.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 path9 from "path";
+import * as fs7 from "fs/promises";
+import { replaceManagedRegion } from "@teamix-evo/registry";
+
+// src/ide/QoderAdapter.ts
+import * as os from "os";
+import * as path7 from "path";
+var QoderAdapter = class {
+  kind = "qoder";
+  name = "qoder";
+  getProjectRoot() {
+    return process.cwd();
+  }
+  detectIde() {
+    return true;
+  }
+  getSkillTargetDir(skillName, scope, projectRoot) {
+    const base = scope === "global" ? path7.join(os.homedir(), ".qoder") : path7.join(projectRoot ?? this.getProjectRoot(), ".qoder");
+    return path7.join(base, "skills", skillName);
+  }
+};
+
+// src/ide/ClaudeAdapter.ts
+import * as os2 from "os";
+import * as path8 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" ? path8.join(os2.homedir(), ".claude") : path8.join(projectRoot ?? this.getProjectRoot(), ".claude");
+    return path8.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/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;
+    }
+    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 = path9.resolve(packageRoot, skill.source);
+  const stat2 = await fs7.stat(sourceAbs);
+  const results = [];
+  if (stat2.isFile()) {
+    const targetFile = path9.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 = path9.relative(sourceAbs, entry);
+    let targetFile = path9.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 fs7.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 fs7.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 = path9.resolve(packageRoot, skill.source);
+  const stat2 = await fs7.stat(sourceAbs);
+  const records = [];
+  if (!stat2.isFile()) {
+    const entries = await walkDir(sourceAbs);
+    await ensureDir(targetDir);
+    for (const entry of entries) {
+      const rel2 = path9.relative(sourceAbs, entry);
+      let targetFile2 = path9.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 fs7.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 = path9.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="${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 {
+        updated = replaceManagedRegion(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 escapeRegExp(str) {
+  return str.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+}
+async function removeSkillFiles(records) {
+  const removed = [];
+  for (const r of records) {
+    try {
+      await fs7.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) => path9.dirname(r.target)));
+  for (const dir of parents) {
+    try {
+      const entries = await fs7.readdir(dir);
+      if (entries.length === 0) await fs7.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/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/core/ui-client.ts
+import * as path10 from "path";
+import * as fs8 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 path10.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 = 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/ui-installer.ts
+import * as path11 from "path";
+import * as fs9 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 = path11.resolve(packageRoot, file.source);
+      const raw = await fs9.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 fs9.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 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/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
+  };
+}
+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,
+  updateSkills,
+  writeInstalledManifest,
+  writeProjectConfig
+};
+//# sourceMappingURL=index.js.map