teamix-evo 0.5.0 → 0.6.1

package/dist/core/index.js

@@ -517,9 +517,11 @@ function makeMirrorRecord(skill, targetAbs, content, ide, scope, rel2) {
 }
 async function updateSkills(options) {
   const { manifest, ides, scope, projectRoot } = options;
+  const idFilter = options.onlyIds ? new Set(options.onlyIds) : null;
   const summary = { overwritten: 0, managed: 0, skipped: 0, created: 0 };
   const updated = [];
   for (const skill of manifest.skills) {
+    if (idFilter && !idFilter.has(skill.id)) continue;
     const skillIdes = skill.ides.filter((i) => ides.includes(i));
     if (skillIdes.length === 0) continue;
     const sourceRecords = await rewriteSkillSource(
@@ -721,11 +723,73 @@ async function ensureMcpJson(projectRoot) {
 // src/core/skills-add.ts
 var DEFAULT_SKILLS_PACKAGE = "@teamix-evo/skills";
 var FLAT_VARIANT = "_flat";
+async function runSkillsInit(options) {
+  const { projectRoot } = options;
+  const packageName = options.packageName ?? DEFAULT_SKILLS_PACKAGE;
+  const ides = [...options.ides];
+  const scope = options.scope;
+  if (ides.length === 0) {
+    throw new Error("At least one IDE must be selected.");
+  }
+  await ensureTeamixDir(projectRoot);
+  const existingConfig = await readProjectConfig(projectRoot);
+  const existingSkillsCfg = existingConfig?.packages?.skills;
+  const { manifest, data, packageRoot } = await loadSkillsData(packageName);
+  const currentTokensVariant = await readTokensVariant(projectRoot);
+  const existing = await readExistingState(projectRoot, packageName);
+  const candidateIds = manifest.skills.filter((s) => {
+    const effectiveScope = s.scope ?? "project";
+    if (effectiveScope !== scope) {
+      logger.debug(
+        `Skipping skill "${s.id}" (scope=${effectiveScope}): current install scope is "${scope}". Use \`skills add ${s.id} --scope ${effectiveScope}\` to install.`
+      );
+      return false;
+    }
+    if (!s.variant) return true;
+    if (!currentTokensVariant) {
+      logger.debug(
+        `Skipping variant-bound skill "${s.id}" (variant=${s.variant}): no tokens variant installed; will be picked up when "tokens init" runs.`
+      );
+      return false;
+    }
+    if (s.variant !== currentTokensVariant) {
+      logger.debug(
+        `Skipping variant-bound skill "${s.id}" (variant=${s.variant}): current tokens variant is "${currentTokensVariant}".`
+      );
+      return false;
+    }
+    return true;
+  }).map((s) => s.id);
+  const skippedSkillIds = candidateIds.filter(
+    (id) => existing.skillIds.has(id)
+  );
+  const onlyIds = candidateIds.filter((id) => !existing.skillIds.has(id));
+  if (existingSkillsCfg && onlyIds.length === 0) {
+    return { status: "already-initialized" };
+  }
+  return finalizeSkillsInstall({
+    projectRoot,
+    packageName,
+    ideIdent: options.ide ?? "qoder",
+    manifest,
+    data,
+    packageRoot,
+    ides,
+    scope,
+    onlyIds,
+    skippedSkillIds,
+    existing,
+    existingConfig
+  });
+}
 async function runSkillsAdd(options) {
+  if (!options.names || options.names.length === 0) {
+    throw new Error(
+      "runSkillsAdd requires at least one skill id. Use runSkillsInit() for bulk install."
+    );
+  }
   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;
@@ -738,57 +802,27 @@ async function runSkillsAdd(options) {
     throw new Error("Scope must be specified (project | global).");
   }
   const { manifest, data, packageRoot } = await loadSkillsData(packageName);
-  const currentTokensVariant = await readTokensVariant(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 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)"}.`
+    );
+  }
+  for (const s of manifest.skills) {
+    if (requestedNames.includes(s.id) && s.scope && s.scope !== scope) {
+      logger.warn(
+        `"${s.id}" \u63A8\u8350 ${s.scope} scope \u5B89\u88C5\u3002\u5F53\u524D\u4EE5 ${scope} scope \u5F3A\u5236\u5B89\u88C5,\u53EF\u80FD\u4E0E\u53E6\u4E00 scope \u7684\u526F\u672C\u51B2\u7A81\u3002\u5EFA\u8BAE\u6539\u7528 \`skills add ${s.id} --scope ${s.scope}\`\u3002`
       );
     }
   }
-  const existingInstalled = await readInstalledManifest(projectRoot);
-  const existingPkg = existingInstalled?.installed.find(
-    (p) => p.package === packageName
+  const existing = await readExistingState(projectRoot, packageName);
+  const skippedSkillIds = requestedNames.filter(
+    (n) => existing.skillIds.has(n)
   );
-  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 {
-    const candidateIds = manifest.skills.filter((s) => {
-      if (!s.variant) return true;
-      if (!currentTokensVariant) {
-        logger.debug(
-          `Skipping variant-bound skill "${s.id}" (variant=${s.variant}): no tokens variant installed; will be picked up when "tokens init" runs.`
-        );
-        return false;
-      }
-      if (s.variant !== currentTokensVariant) {
-        logger.debug(
-          `Skipping variant-bound skill "${s.id}" (variant=${s.variant}): current tokens variant is "${currentTokensVariant}".`
-        );
-        return false;
-      }
-      return true;
-    }).map((s) => s.id);
-    skippedSkillIds = candidateIds.filter((id) => existingSkillIds.has(id));
-    onlyIds = candidateIds.filter((id) => !existingSkillIds.has(id));
-  }
-  if (!isIncremental && existingSkillsCfg && onlyIds.length === 0) {
-    return { status: "already-added" };
-  }
-  if (isIncremental && onlyIds.length === 0) {
+  const onlyIds = requestedNames.filter((n) => !existing.skillIds.has(n));
+  if (onlyIds.length === 0) {
     return {
       status: "installed",
       packageName,
@@ -802,6 +836,48 @@ async function runSkillsAdd(options) {
       skippedSkillIds
     };
   }
+  return finalizeSkillsInstall({
+    projectRoot,
+    packageName,
+    ideIdent: options.ide ?? "qoder",
+    manifest,
+    data,
+    packageRoot,
+    ides,
+    scope,
+    onlyIds,
+    skippedSkillIds,
+    existing,
+    existingConfig
+  });
+}
+async function readExistingState(projectRoot, packageName) {
+  const installed = await readInstalledManifest(projectRoot);
+  const pkg = installed?.installed.find((p) => p.package === packageName);
+  const lock = await readSkillsLock(projectRoot);
+  const skillIds = /* @__PURE__ */ new Set([
+    ...Object.keys(lock?.skills ?? {}),
+    // Legacy fallback: pre-ADR-0013 installs only had manifest.json. Derive
+    // skill ids by stripping the trailing :source / :sub-file suffix.
+    ...(pkg?.resources ?? []).map((r) => r.id.split(":")[0] ?? r.id)
+  ]);
+  return { installed, pkg, lock, skillIds };
+}
+async function finalizeSkillsInstall(args) {
+  const {
+    projectRoot,
+    packageName,
+    ideIdent,
+    manifest,
+    data,
+    packageRoot,
+    ides,
+    scope,
+    onlyIds,
+    skippedSkillIds,
+    existing,
+    existingConfig
+  } = args;
   const result = await installSkills({
     projectRoot,
     manifest,
@@ -825,7 +901,7 @@ async function runSkillsAdd(options) {
   };
   await writeProjectConfig(projectRoot, config);
   const installedAt = (/* @__PURE__ */ new Date()).toISOString();
-  const installedManifest = existingInstalled ?? {
+  const installedManifest = existing.installed ?? {
     schemaVersion: 1,
     installed: []
   };
@@ -833,7 +909,7 @@ async function runSkillsAdd(options) {
     (p) => p.package === packageName
   );
   const mergedResources = mergeInstalledResources(
-    existingPkg?.resources ?? [],
+    existing.pkg?.resources ?? [],
     result.resources
   );
   const entry = {
@@ -846,7 +922,7 @@ async function runSkillsAdd(options) {
   if (idx >= 0) installedManifest.installed[idx] = entry;
   else installedManifest.installed.push(entry);
   await writeInstalledManifest(projectRoot, installedManifest);
-  const lock = existingLock ?? {
+  const lock = existing.lock ?? {
     schemaVersion: 1,
     skills: {}
   };
@@ -1138,6 +1214,176 @@ async function listTokenVariants(packageName = DEFAULT_TOKENS_PACKAGE, packageRo
   };
 }
 
+// src/core/skills-update.ts
+var DEFAULT_SKILLS_PACKAGE3 = "@teamix-evo/skills";
+var FLAT_VARIANT2 = "_flat";
+async function runSkillsUpdate(options) {
+  const { projectRoot, names: requestedNames, dryRun } = options;
+  const packageName = options.packageName ?? DEFAULT_SKILLS_PACKAGE3;
+  const config = await readProjectConfig(projectRoot);
+  const skillsCfg = config?.packages?.skills;
+  if (!skillsCfg) {
+    return { status: "no-skills" };
+  }
+  const ides = skillsCfg.ides ?? ["qoder", "claude"];
+  const scope = skillsCfg.scope ?? "project";
+  const existingLock = await readSkillsLock(projectRoot);
+  if (!existingLock || Object.keys(existingLock.skills).length === 0) {
+    return { status: "no-skills" };
+  }
+  const { manifest, data, packageRoot } = await loadSkillsData(packageName);
+  const manifestById = new Map(manifest.skills.map((s) => [s.id, s]));
+  const lockIds = Object.keys(existingLock.skills);
+  const requestedSet = requestedNames ? new Set(requestedNames) : null;
+  if (requestedSet) {
+    const unknown = requestedNames.filter(
+      (n) => !lockIds.includes(n) && !manifestById.has(n)
+    );
+    if (unknown.length > 0) {
+      throw new Error(
+        `Unknown skill id(s): ${unknown.join(
+          ", "
+        )}. Available (installed): ${lockIds.join(", ") || "(none)"}.`
+      );
+    }
+  }
+  const targetIds = [];
+  const skippedSkillIds = [];
+  for (const id of lockIds) {
+    if (requestedSet && !requestedSet.has(id)) continue;
+    const entry2 = manifestById.get(id);
+    if (!entry2) {
+      logger.debug(
+        `Skipping "${id}": no longer in upstream manifest. Use \`skills uninstall ${id}\` to remove.`
+      );
+      skippedSkillIds.push(id);
+      continue;
+    }
+    const effectiveScope = entry2.scope ?? "project";
+    if (effectiveScope !== scope) {
+      logger.debug(
+        `Skipping "${id}" (scope=${effectiveScope}): current install scope is "${scope}".`
+      );
+      skippedSkillIds.push(id);
+      continue;
+    }
+    targetIds.push(id);
+  }
+  const allSame = targetIds.every((id) => {
+    const lockVer = existingLock.skills[id].version;
+    const manVer = manifestById.get(id).version;
+    return lockVer === manVer;
+  });
+  if (targetIds.length > 0 && allSame && !dryRun) {
+    return {
+      status: "no-changes",
+      packageName,
+      version: manifest.version,
+      checkedSkillIds: targetIds
+    };
+  }
+  if (dryRun) {
+    const plan = targetIds.map((id) => {
+      const lockVer = existingLock.skills[id].version;
+      const entry2 = manifestById.get(id);
+      const sameVersion = lockVer === entry2.version;
+      return {
+        id,
+        current: lockVer,
+        next: entry2.version,
+        strategy: entry2.updateStrategy ?? "managed",
+        action: sameVersion ? "up-to-date" : "version-bump"
+      };
+    });
+    return {
+      status: "dry-run",
+      packageName,
+      currentVersion: skillsCfg.version,
+      availableVersion: manifest.version,
+      plan
+    };
+  }
+  if (targetIds.length === 0) {
+    return {
+      status: "updated",
+      packageName,
+      version: manifest.version,
+      ides,
+      scope,
+      updatedSkillIds: [],
+      skippedSkillIds,
+      summary: { overwritten: 0, managed: 0, skipped: 0, created: 0 },
+      resources: []
+    };
+  }
+  const result = await updateSkills({
+    projectRoot,
+    manifest,
+    data,
+    packageRoot,
+    ides,
+    scope,
+    onlyIds: targetIds
+  });
+  config.packages.skills = {
+    ...skillsCfg,
+    version: manifest.version
+  };
+  await writeProjectConfig(projectRoot, config);
+  const installedManifest = await readInstalledManifest(projectRoot) ?? {
+    schemaVersion: 1,
+    installed: []
+  };
+  const idx = installedManifest.installed.findIndex(
+    (p) => p.package === packageName
+  );
+  const installedAt = (/* @__PURE__ */ new Date()).toISOString();
+  const prior = idx >= 0 ? installedManifest.installed[idx].resources : [];
+  const targetSet = new Set(targetIds);
+  const preserved = prior.filter((r) => {
+    const skillId = r.id.split(":")[0];
+    return skillId ? !targetSet.has(skillId) : true;
+  });
+  const entry = {
+    package: packageName,
+    variant: FLAT_VARIANT2,
+    version: manifest.version,
+    installedAt,
+    resources: [...preserved, ...result.resources]
+  };
+  if (idx >= 0) installedManifest.installed[idx] = entry;
+  else installedManifest.installed.push(entry);
+  await writeInstalledManifest(projectRoot, installedManifest);
+  const lock = {
+    schemaVersion: 1,
+    skills: { ...existingLock.skills }
+  };
+  for (const id of targetIds) {
+    const skillDef = manifestById.get(id);
+    if (!skillDef) continue;
+    const mirroredTo = skillDef.ides.filter((i) => ides.includes(i));
+    lock.skills[id] = {
+      version: skillDef.version,
+      from: packageName,
+      installedAt,
+      scope,
+      mirroredTo
+    };
+  }
+  await writeSkillsLock(projectRoot, lock);
+  return {
+    status: "updated",
+    packageName,
+    version: manifest.version,
+    ides,
+    scope,
+    updatedSkillIds: targetIds,
+    skippedSkillIds,
+    summary: result.summary,
+    resources: result.resources
+  };
+}
+
 // src/core/ui-init.ts
 var DEFAULT_UI_ALIASES = {
   components: "src/components/ui",
@@ -1471,9 +1717,277 @@ async function runUiList(options) {
   };
 }
 
-// src/core/installer.ts
+// src/core/variant-ui-add.ts
 import * as path12 from "path";
-import * as fs9 from "fs/promises";
+import { createRequire as createRequire4 } from "module";
+import {
+  loadUiPackageManifest as loadUiPackageManifest2,
+  loadVariantUiPackageCatalog,
+  loadVariantUiPackageManifest
+} from "@teamix-evo/registry";
+var require5 = createRequire4(import.meta.url);
+function resolvePackageRoot3(packageName) {
+  const pkgJsonPath = require5.resolve(`${packageName}/package.json`);
+  return path12.dirname(pkgJsonPath);
+}
+async function runVariantUiAdd(packageName, options) {
+  const { projectRoot, variant, ids, overwrite } = options;
+  const fullPackageName = options.packageName ?? `@teamix-evo/${packageName}`;
+  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 \`teamix-evo ui init\` first \u2014 \`${packageName} add\` writes into the same alias map (business / templates).`
+    );
+  }
+  const packageRoot = options.packageRoot ?? resolvePackageRoot3(fullPackageName);
+  const catalog = await loadVariantUiPackageCatalog(packageRoot);
+  if (!catalog.variants.some((v) => v.name === variant)) {
+    const known = catalog.variants.map((v) => v.name).join(", ");
+    throw new Error(
+      `Variant "${variant}" not found in ${fullPackageName}. Known variants: ${known}. Hint: \`teamix-evo ${packageName} list-variants\` shows all.`
+    );
+  }
+  const variantDir = path12.join(packageRoot, "variants", variant);
+  const variantManifest = await loadVariantUiPackageManifest(variantDir);
+  const knownIds = new Set(variantManifest.entries.map((e) => e.id));
+  const unknown = ids.filter((id) => !knownIds.has(id));
+  if (unknown.length > 0) {
+    throw new Error(
+      `Unknown entry id(s) in ${packageName}#${variant}: ${unknown.map((s) => `"${s}"`).join(", ")}. Run \`teamix-evo ${packageName} list-variants\` to see this package's variants, or \`teamix-evo ${packageName} list --variant ${variant}\` for its entries.`
+    );
+  }
+  const uiPackageRoot = resolvePackageRoot3("@teamix-evo/ui");
+  const uiManifest = await loadUiPackageManifest2(uiPackageRoot);
+  const entryPackageRoot = /* @__PURE__ */ new Map();
+  const mergedEntries = [];
+  for (const e of variantManifest.entries) {
+    entryPackageRoot.set(e.id, variantDir);
+    mergedEntries.push(e);
+  }
+  for (const e of uiManifest.entries) {
+    if (entryPackageRoot.has(e.id)) continue;
+    entryPackageRoot.set(e.id, uiPackageRoot);
+    mergedEntries.push(e);
+  }
+  const adaptedManifest = {
+    schemaVersion: 1,
+    package: "ui",
+    version: variantManifest.version,
+    engines: variantManifest.engines,
+    entries: mergedEntries
+  };
+  const result = await installUiEntries({
+    projectRoot,
+    manifest: adaptedManifest,
+    packageRoot: variantDir,
+    // default for variant entries
+    entryPackageRoot,
+    // ui entries resolve from uiPackageRoot
+    aliases: uiCfg.aliases,
+    requested: ids,
+    skipExisting: !overwrite
+  });
+  const installed = await readInstalledManifest(
+    projectRoot
+  ) ?? { schemaVersion: 1, installed: [] };
+  const idx = installed.installed.findIndex(
+    (p) => p.package === fullPackageName && p.variant === variant
+  );
+  const prior = idx >= 0 ? installed.installed[idx] : null;
+  const mergedResources = mergeResources2(
+    prior?.resources ?? [],
+    result.resources
+  );
+  const entry = {
+    package: fullPackageName,
+    variant,
+    version: variantManifest.version,
+    installedAt: (/* @__PURE__ */ new Date()).toISOString(),
+    resources: mergedResources
+  };
+  if (idx >= 0) installed.installed[idx] = entry;
+  else installed.installed.push(entry);
+  await writeInstalledManifest(projectRoot, installed);
+  return {
+    packageName: fullPackageName,
+    variant,
+    orderedIds: result.orderedIds,
+    written: result.written,
+    skipped: result.skipped,
+    npmDependencies: result.npmDependencies,
+    resources: result.resources
+  };
+}
+function mergeResources2(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());
+}
+async function runBizUiAdd(options) {
+  return runVariantUiAdd("biz-ui", options);
+}
+async function runTemplatesAdd(options) {
+  return runVariantUiAdd("templates", options);
+}
+async function listVariantUi(packageName, packageRoot) {
+  const fullPackageName = `@teamix-evo/${packageName}`;
+  const root = packageRoot ?? resolvePackageRoot3(fullPackageName);
+  const catalog = await loadVariantUiPackageCatalog(root);
+  return {
+    packageName: fullPackageName,
+    variants: catalog.variants.map((v) => ({
+      name: v.name,
+      displayName: v.displayName,
+      version: v.version,
+      description: v.description
+    }))
+  };
+}
+async function listBizUiVariants(packageRoot) {
+  return listVariantUi("biz-ui", packageRoot);
+}
+async function listTemplatesVariants(packageRoot) {
+  return listVariantUi("templates", packageRoot);
+}
+async function listVariantUiEntries(packageName, variant, packageRoot) {
+  const fullPackageName = `@teamix-evo/${packageName}`;
+  const root = packageRoot ?? resolvePackageRoot3(fullPackageName);
+  const catalog = await loadVariantUiPackageCatalog(root);
+  if (!catalog.variants.some((v) => v.name === variant)) {
+    const known = catalog.variants.map((v) => v.name).join(", ");
+    throw new Error(
+      `Variant "${variant}" not found in ${fullPackageName}. Known: ${known}.`
+    );
+  }
+  const variantDir = path12.join(root, "variants", variant);
+  const variantManifest = await loadVariantUiPackageManifest(variantDir);
+  return {
+    packageName: fullPackageName,
+    variant,
+    entries: variantManifest.entries.map((e) => ({
+      id: e.id,
+      name: e.name,
+      type: e.type,
+      description: e.description,
+      registryDependencies: e.registryDependencies ?? []
+    }))
+  };
+}
+async function listBizUiEntries(variant, packageRoot) {
+  return listVariantUiEntries("biz-ui", variant, packageRoot);
+}
+async function listTemplatesEntries(variant, packageRoot) {
+  return listVariantUiEntries("templates", variant, packageRoot);
+}
+
+// src/core/lint-init.ts
+import * as path13 from "path";
+import * as fs9 from "fs";
+import { execa } from "execa";
+var ESLINT_CONFIG_CONTENT = `/**
+ * teamix-evo consumer ESLint preset \u2014 9 token-discipline rules.
+ * - Repo-wide: no-color-literal / no-arbitrary-tw-value / no-raw-color-scale /
+ *   no-large-radius / prefer-gap-over-space / no-manual-dark-classnames /
+ *   dialog-must-have-title (all error)
+ * - src/components/ui/** only: no-relative-ui-import / icon-from-lucide (error)
+ *
+ * See ADR 0008 / docs/principles.md \xA7P4.
+ */
+import consumerPreset from '@teamix-evo/eslint-config/presets/consumer';
+
+export default [...consumerPreset];
+`;
+var STYLELINT_CONFIG_CONTENT = `/** @type {import('stylelint').Config} */
+module.exports = {
+  extends: ['@teamix-evo/stylelint-config/presets/consumer'],
+};
+`;
+var ESLINT_DEPS = [
+  "@teamix-evo/eslint-config",
+  "eslint",
+  "@typescript-eslint/parser"
+];
+var STYLELINT_DEPS = ["@teamix-evo/stylelint-config", "stylelint"];
+async function runLintInit(options) {
+  const { projectRoot, skipInstall } = options;
+  const eslintConfigPath = path13.join(projectRoot, "eslint.config.js");
+  const stylelintConfigPath = path13.join(projectRoot, "stylelint.config.cjs");
+  const eslintExists = await fileExists(eslintConfigPath);
+  const stylelintExists = await fileExists(stylelintConfigPath);
+  if (eslintExists && stylelintExists) {
+    return { status: "already-initialized" };
+  }
+  if (!skipInstall) {
+    const depsToInstall = [
+      ...eslintExists ? [] : ESLINT_DEPS,
+      ...stylelintExists ? [] : STYLELINT_DEPS
+    ];
+    if (depsToInstall.length > 0) {
+      const pm = detectPm(projectRoot);
+      const args = pm === "yarn" ? ["add", "--dev", ...depsToInstall] : pm === "pnpm" ? ["add", "-D", ...depsToInstall] : ["install", "--save-dev", ...depsToInstall];
+      logger.info(`Installing lint deps via ${pm}...`);
+      await execa(pm, args, { cwd: projectRoot, stdio: "inherit" });
+    }
+  }
+  let wroteEslint = false;
+  let wroteStylelint = false;
+  if (!eslintExists) {
+    await writeFileSafe(eslintConfigPath, ESLINT_CONFIG_CONTENT);
+    logger.debug(`Wrote eslint.config.js \u2192 ${eslintConfigPath}`);
+    wroteEslint = true;
+  }
+  if (!stylelintExists) {
+    await writeFileSafe(stylelintConfigPath, STYLELINT_CONFIG_CONTENT);
+    logger.debug(`Wrote stylelint.config.cjs \u2192 ${stylelintConfigPath}`);
+    wroteStylelint = true;
+  }
+  await patchPackageJsonScripts(projectRoot);
+  return {
+    status: "installed",
+    eslint: wroteEslint,
+    stylelint: wroteStylelint
+  };
+}
+function detectPm(projectRoot) {
+  if (fs9.existsSync(path13.join(projectRoot, "pnpm-lock.yaml"))) return "pnpm";
+  if (fs9.existsSync(path13.join(projectRoot, "yarn.lock"))) return "yarn";
+  return "npm";
+}
+async function patchPackageJsonScripts(projectRoot) {
+  const pkgPath = path13.join(projectRoot, "package.json");
+  const raw = await readFileOrNull(pkgPath);
+  if (!raw) return;
+  let pkg;
+  try {
+    pkg = JSON.parse(raw);
+  } catch {
+    return;
+  }
+  const scripts = pkg.scripts ?? {};
+  let changed = false;
+  if (!scripts.lint) {
+    scripts.lint = "eslint src/";
+    changed = true;
+  }
+  if (!scripts["lint:css"]) {
+    scripts["lint:css"] = "stylelint 'src/**/*.css'";
+    changed = true;
+  }
+  if (changed) {
+    pkg.scripts = scripts;
+    await writeFileSafe(pkgPath, JSON.stringify(pkg, null, 2) + "\n");
+    logger.debug("Patched package.json scripts with lint / lint:css");
+  }
+}
+
+// src/core/installer.ts
+import * as path14 from "path";
+import * as fs10 from "fs/promises";
 async function installResources(options) {
   const { projectRoot, manifest, data, variantDir, packageRoot } = options;
   const installedResources = [];
@@ -1510,13 +2024,13 @@ async function installSingleResource(resource, projectRoot, data, variantDir, pa
     variantDir,
     packageRoot
   );
-  const targetPath = path12.join(projectRoot, resource.target);
+  const targetPath = path14.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");
+    content = await fs10.readFile(sourcePath, "utf-8");
   }
   await writeFileSafe(targetPath, content);
   const hash = computeHash(content);
@@ -1534,13 +2048,13 @@ async function installRecursiveResource(resource, projectRoot, data, variantDir,
     variantDir,
     packageRoot
   );
-  const targetDir = path12.join(projectRoot, resource.target);
+  const targetDir = path14.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);
+    const relPath = path14.relative(sourcePath, entry);
+    let targetFile = path14.join(targetDir, relPath);
     if (resource.template && targetFile.endsWith(".hbs")) {
       targetFile = targetFile.slice(0, -4);
     }
@@ -1549,11 +2063,11 @@ async function installRecursiveResource(resource, projectRoot, data, variantDir,
       const templateContent = await loadTemplateFile(entry);
       content = renderTemplate(templateContent, data);
     } else {
-      content = await fs9.readFile(entry, "utf-8");
+      content = await fs10.readFile(entry, "utf-8");
     }
     await writeFileSafe(targetFile, content);
     const hash = computeHash(content);
-    const targetRel = path12.relative(projectRoot, targetFile);
+    const targetRel = path14.relative(projectRoot, targetFile);
     results.push({
       id: `${resource.id}:${relPath}`,
       target: targetRel,
@@ -1566,25 +2080,25 @@ async function installRecursiveResource(resource, projectRoot, data, variantDir,
 }
 
 // src/core/registry-client.ts
-import * as path13 from "path";
-import * as fs10 from "fs/promises";
-import { createRequire as createRequire4 } from "module";
+import * as path15 from "path";
+import * as fs11 from "fs/promises";
+import { createRequire as createRequire5 } 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);
+var require6 = createRequire5(import.meta.url);
+function resolvePackageRoot4(packageName) {
+  const pkgJsonPath = require6.resolve(`${packageName}/package.json`);
+  return path15.dirname(pkgJsonPath);
 }
 async function loadVariantData(packageName, variant) {
-  const packageRoot = resolvePackageRoot3(packageName);
-  const variantDir = path13.join(packageRoot, "library", variant);
+  const packageRoot = resolvePackageRoot4(packageName);
+  const variantDir = path15.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");
+  const dataPath = path15.join(variantDir, "_data.json");
   try {
-    const raw = await fs10.readFile(dataPath, "utf-8");
+    const raw = await fs11.readFile(dataPath, "utf-8");
     data = JSON.parse(raw);
   } catch (err) {
     if (err.code !== "ENOENT") {
@@ -1602,6 +2116,10 @@ export {
   installResources,
   installSkills,
   installUiEntries,
+  listBizUiEntries,
+  listBizUiVariants,
+  listTemplatesEntries,
+  listTemplatesVariants,
   listTokenVariants,
   loadSkillsData,
   loadUiData,
@@ -1610,7 +2128,12 @@ export {
   readProjectConfig,
   removeSkillFiles,
   removeUiFiles,
+  runBizUiAdd,
+  runLintInit,
   runSkillsAdd,
+  runSkillsInit,
+  runSkillsUpdate,
+  runTemplatesAdd,
   runTokensInit,
   runUiAdd,
   runUiInit,