@teamix-evo/registry 0.2.0 → 0.5.0

package/dist/index.js

@@ -82,7 +82,20 @@ var SkillEntrySchema = z.object({
   /** Managed region IDs to maintain on update */
   managedRegions: z.array(z.string()).optional(),
   /** Whether the source is a Handlebars template */
-  template: z.boolean().optional()
+  template: z.boolean().optional(),
+  /**
+   * Variant identifier when this skill is bound to a specific design variant
+   * (e.g. `"opentrek"`, `"uni-manager"`). Optional — neutral skills (manage,
+   * coding-conventions, baseline design-rules) leave it unset.
+   *
+   * When present, the CLI installs this skill ONLY if the consumer's
+   * `.teamix-evo/tokens-lock.json` records the same variant. MUST equal
+   * the variant directory name in `@teamix-evo/tokens/variants/<name>/`.
+   *
+   * Mirrors `UiEntrySchema.variant` semantics in @teamix-evo/biz-ui &
+   * @teamix-evo/templates per ADR 0014.
+   */
+  variant: z.string().optional()
 });
 var SkillsPackageManifestSchema = z.object({
   $schema: z.string().optional(),
@@ -102,9 +115,17 @@ var UiEntryTypeSchema = z.enum([
   "component",
   "hook",
   "util",
-  "block"
+  "block",
+  "template"
+]);
+var UiAliasSchema = z.enum([
+  "components",
+  "hooks",
+  "utils",
+  "lib",
+  "business",
+  "templates"
 ]);
-var UiAliasSchema = z.enum(["components", "hooks", "utils", "lib"]);
 var UiEntryStatusSchema = z.enum([
   "stable",
   "experimental",
@@ -134,8 +155,8 @@ var UiEntrySchema = z.object({
   files: z.array(UiEntryFileSchema).min(1),
   /**
    * Optional path to an AI-readable meta document (frontmatter + Markdown).
-   * When set, CLI install drops it at `.teamix-evo/design/components/<id>.meta.md`
-   * for design's ai-rules to consume.
+   * Read directly from `@teamix-evo/ui` by MCP at runtime — no consumer-side
+   * copy is written (per ADR 0020 §3).
    */
   meta: z.string().optional(),
   /** Other UI entries this one depends on (e.g. "button" depends on "cn") */
@@ -167,7 +188,14 @@ var UiEntrySchema = z.object({
    * If this entry is `deprecated`, the id of the entry that supersedes it.
    * Consumers (and AI) should migrate to `replacedBy` rather than this entry.
    */
-  replacedBy: z.string().optional()
+  replacedBy: z.string().optional(),
+  /**
+   * Variant identifier when this entry is shipped from a variant-aware
+   * package (`@teamix-evo/biz-ui` or `@teamix-evo/templates` per ADR 0014).
+   * Optional — entries from `@teamix-evo/ui` (variant-agnostic) leave it unset.
+   * MUST equal the variant directory name when present.
+   */
+  variant: z.string().optional()
 });
 var UiPackageManifestSchema = z.object({
   $schema: z.string().optional(),
@@ -180,28 +208,160 @@ var UiPackageManifestSchema = z.object({
   engines: z.object({
     "teamix-evo": z.string().min(1)
   }),
-  /** Flat list of entries shipped by this package */
-  entries: z.array(UiEntrySchema)
+  /** Active list of entries shipped (and exposed) by this package. */
+  entries: z.array(UiEntrySchema),
+  /**
+   * Archived entries that are kept in source for Storybook documentation only
+   * and are NOT exposed through the active distribution chain. Per ADR 0028:
+   *   - `teamix-evo ui add <id>` rejects ids found here unless `--include-deprecated` is passed
+   *   - MCP `list_components` / `find_components` exclude these by default
+   *   - Storybook keeps the story under `废弃 · Deprecated/` with a banner
+   * Optional for backwards compatibility — older manifests without this field
+   * still validate.
+   */
+  deprecatedEntries: z.array(UiEntrySchema).optional()
 });
 
-// src/schema/config.ts
+// src/schema/tokens-pack.ts
 import { z as z2 } from "zod";
-var TailwindVersionSchema = z2.enum(["v3", "v4"]);
-var UiAliasesSchema = z2.object({
-  components: z2.string().min(1),
-  hooks: z2.string().min(1),
-  utils: z2.string().min(1),
-  lib: z2.string().min(1)
+var VARIANT_NAME_RE = /^[a-z][a-z0-9-]*$/;
+var SEMVER_RE = /^\d+\.\d+\.\d+/;
+var TokensPackLinkedSchema = z2.object({
+  "biz-ui": z2.string().optional(),
+  templates: z2.string().optional()
+});
+var TokensVariantEntrySchema = z2.object({
+  /** Variant id — lowercase kebab-case. */
+  name: z2.string().min(1).regex(
+    VARIANT_NAME_RE,
+    "Variant name must be lowercase letters/digits/hyphens (no leading hyphen)."
+  ),
+  /** Human-readable display name (e.g. "OpenTrek" for variant id "opentrek"). */
+  displayName: z2.string().min(1),
+  /** Variant version — semver. May trail the package version when only a subset of variants change. */
+  version: z2.string().regex(SEMVER_RE, "Invalid semver version"),
+  /** Optional one-liner description; surfaced in `tokens list-variants` output. */
+  description: z2.string().optional(),
+  /**
+   * Files this variant advertises, paths relative to the tokens package root
+   * (e.g. `variants/opentrek/theme.css`). The validator walks these to
+   * confirm presence; the CLI consumes them at install time.
+   */
+  files: z2.array(z2.string().min(1)).min(1),
+  /** Soft cross-package links (biz-ui / templates with the same variant name). */
+  linked: TokensPackLinkedSchema.optional()
+});
+var TokensPackageManifestSchema = z2.object({
+  $schema: z2.string().optional(),
+  schemaVersion: z2.literal(1),
+  /** Always `"tokens"` — disambiguates from other teamix-evo package manifests. */
+  package: z2.literal("tokens"),
+  /** Semver of the entire tokens package. */
+  version: z2.string().regex(SEMVER_RE, "Invalid semver version"),
+  /** Engine compatibility. */
+  engines: z2.object({ "teamix-evo": z2.string().min(1) }),
+  /** Optional package-level description. */
+  description: z2.string().optional(),
+  /** All shipped variants (excluding scaffold dirs that begin with `_`). */
+  variants: z2.array(TokensVariantEntrySchema),
+  /**
+   * Reserved for future shared assets that span variants (e.g. browser
+   * quirks resets co-shipped at the package root). Empty array today.
+   */
+  shared: z2.array(z2.string()).optional()
+});
+var TokensPackLockSchema = z2.object({
+  $schema: z2.string().optional(),
+  schemaVersion: z2.literal(1),
+  variant: z2.object({
+    name: z2.string().min(1),
+    displayName: z2.string().min(1),
+    version: z2.string().regex(SEMVER_RE),
+    from: z2.string().min(1)
+    // e.g. "@teamix-evo/tokens"
+  }),
+  /** Tokens package version — useful when variant version trails the package. */
+  packageVersion: z2.string().regex(SEMVER_RE),
+  linked: TokensPackLinkedSchema.optional(),
+  installedAt: z2.string().datetime()
+});
+
+// src/schema/variant-ui-pack.ts
+import { z as z3 } from "zod";
+var SEMVER_RE2 = /^\d+\.\d+\.\d+/;
+var VARIANT_NAME_RE2 = /^[a-z][a-z0-9-]*$/;
+var VariantUiPackageNameSchema = z3.enum(["biz-ui", "templates"]);
+var VariantUiPackageManifestSchema = z3.object({
+  $schema: z3.string().optional(),
+  schemaVersion: z3.literal(1),
+  /** Discriminator. */
+  package: VariantUiPackageNameSchema,
+  /**
+   * Variant identifier — lowercase kebab-case, MUST match the parent
+   * directory name (e.g. `opentrek` for `variants/opentrek/manifest.json`).
+   * `_template` is also accepted for the variant scaffold.
+   */
+  variant: z3.string().min(1).regex(
+    VARIANT_NAME_RE2,
+    'Variant id must be lowercase letters/digits/hyphens (no leading hyphen). Special: "_template" allowed.'
+  ).or(z3.literal("_template")),
+  /** Semver of this variant. */
+  version: z3.string().regex(SEMVER_RE2, "Invalid semver version"),
+  /** Engine compatibility. */
+  engines: z3.object({ "teamix-evo": z3.string().min(1) }),
+  /** Flat list of entries shipped by this variant. */
+  entries: z3.array(UiEntrySchema)
+}).superRefine((data, ctx) => {
+  for (const [i, entry] of data.entries.entries()) {
+    if (entry.variant !== void 0 && entry.variant !== data.variant) {
+      ctx.addIssue({
+        code: z3.ZodIssueCode.custom,
+        path: ["entries", i, "variant"],
+        message: `Entry "${entry.id}" declares variant "${entry.variant}" but lives in manifest of variant "${data.variant}".`
+      });
+    }
+  }
 });
-var PackageEntrySchema = z2.object({
+var VariantUiPackageCatalogSchema = z3.object({
+  $schema: z3.string().optional(),
+  schemaVersion: z3.literal(1),
+  package: VariantUiPackageNameSchema,
+  /** Semver of the entire package. */
+  version: z3.string().regex(SEMVER_RE2, "Invalid semver version"),
+  engines: z3.object({ "teamix-evo": z3.string().min(1) }),
+  /** Variants this package ships (excluding `_template`). */
+  variants: z3.array(
+    z3.object({
+      name: z3.string().min(1).regex(VARIANT_NAME_RE2),
+      displayName: z3.string().min(1),
+      version: z3.string().regex(SEMVER_RE2),
+      description: z3.string().optional()
+    })
+  )
+});
+
+// src/schema/config.ts
+import { z as z4 } from "zod";
+var TailwindVersionSchema = z4.literal("v4");
+var UiAliasesSchema = z4.object({
+  components: z4.string().min(1),
+  hooks: z4.string().min(1),
+  utils: z4.string().min(1),
+  lib: z4.string().min(1),
+  /** Biz-ui components (variant-bound). Defaults to `src/components/business/`. */
+  business: z4.string().min(1).default("src/components/business"),
+  /** Page templates (variant-bound). Defaults to `src/templates/`. */
+  templates: z4.string().min(1).default("src/templates")
+});
+var PackageEntrySchema = z4.object({
   /** Variant identifier (e.g. "opentrek"; use "_flat" for skills/ui) */
-  variant: z2.string().min(1),
+  variant: z4.string().min(1),
   /** Semver version string */
-  version: z2.string().min(1),
+  version: z4.string().min(1),
   /** Tailwind CSS version this project uses (only meaningful for design package). */
   tailwind: TailwindVersionSchema.optional(),
   /** IDEs this package was installed for (only meaningful for skills package). */
-  ides: z2.array(SkillIdeSchema).optional(),
+  ides: z4.array(SkillIdeSchema).optional(),
   /** Install scope (only meaningful for skills package). */
   scope: SkillScopeSchema.optional(),
   /** Path aliases for ui entry installation (only meaningful for ui package). */
@@ -210,53 +370,79 @@ var PackageEntrySchema = z2.object({
    * Default icon library declared by the project (only meaningful for ui).
    * Declarative only — does NOT trigger code rewrites; ui entries hardcode imports.
    */
-  iconLibrary: z2.string().min(1).optional(),
+  iconLibrary: z4.string().min(1).optional(),
   /** Whether the project uses TSX (true) or JSX (false). ui-specific. */
-  tsx: z2.boolean().optional(),
+  tsx: z4.boolean().optional(),
   /** Whether to emit React Server Components markers (`"use client"`). ui-specific. */
-  rsc: z2.boolean().optional()
+  rsc: z4.boolean().optional()
 });
-var ProjectConfigSchema = z2.object({
-  $schema: z2.string().optional(),
-  schemaVersion: z2.literal(1),
+var ProjectConfigSchema = z4.object({
+  $schema: z4.string().optional(),
+  schemaVersion: z4.literal(1),
   /** IDE identifier */
-  ide: z2.string().min(1),
+  ide: z4.string().min(1),
   /** Installed packages keyed by package name */
-  packages: z2.record(z2.string(), PackageEntrySchema)
+  packages: z4.record(z4.string(), PackageEntrySchema)
 });
 
 // src/schema/installed.ts
-import { z as z3 } from "zod";
-var InstalledResourceSchema = z3.object({
+import { z as z5 } from "zod";
+var InstalledResourceSchema = z5.object({
   /** Resource identifier matching the variant manifest */
-  id: z3.string().min(1),
+  id: z5.string().min(1),
   /** Target path where the resource was installed (absolute or project-relative) */
-  target: z3.string().min(1),
+  target: z5.string().min(1),
   /** Content hash for change detection (e.g. "sha256:...") */
-  hash: z3.string().min(1),
+  hash: z5.string().min(1),
   /** Update strategy that was applied */
-  strategy: z3.enum(["frozen", "regenerable", "managed"]),
+  strategy: z5.enum(["frozen", "regenerable", "managed"]),
   /** IDE this resource was installed for (skill resources only) */
   ide: SkillIdeSchema.optional(),
   /** Install scope (skill resources only) */
   scope: SkillScopeSchema.optional()
 });
-var InstalledPackageSchema = z3.object({
-  /** Full package name (e.g. "@teamix-evo/design") */
-  package: z3.string().min(1),
+var InstalledPackageSchema = z5.object({
+  /** Full package name (e.g. "@teamix-evo/tokens") */
+  package: z5.string().min(1),
   /** Variant identifier (use "_flat" for non-variant packages such as skills) */
-  variant: z3.string().min(1),
+  variant: z5.string().min(1),
   /** Installed version */
-  version: z3.string().min(1),
+  version: z5.string().min(1),
   /** ISO 8601 timestamp of installation */
-  installedAt: z3.string().min(1),
+  installedAt: z5.string().min(1),
   /** List of installed resources */
-  resources: z3.array(InstalledResourceSchema)
+  resources: z5.array(InstalledResourceSchema)
 });
-var InstalledManifestSchema = z3.object({
-  schemaVersion: z3.literal(1),
+var InstalledManifestSchema = z5.object({
+  schemaVersion: z5.literal(1),
   /** List of installed packages */
-  installed: z3.array(InstalledPackageSchema)
+  installed: z5.array(InstalledPackageSchema)
+});
+
+// src/schema/skills-lock.ts
+import { z as z6 } from "zod";
+var SkillsLockEntrySchema = z6.object({
+  /** Semver version installed from upstream */
+  version: z6.string().min(1),
+  /** Upstream package name (typically `@teamix-evo/skills`) */
+  from: z6.string().min(1),
+  /** ISO 8601 install / last-sync timestamp */
+  installedAt: z6.string().min(1),
+  /** Install scope at time of mirror */
+  scope: SkillScopeSchema,
+  /**
+   * IDEs this skill was mirrored to. Each ide ↔ a mirror path under
+   * `<projectRoot>/.<ide>/skills/<id>/` (project) or `~/.<ide>/skills/<id>/`
+   * (global). The path itself is reconstructed from `scope` + adapter; we
+   * record the ide identifier rather than the full path to keep the lock
+   * portable across machines.
+   */
+  mirroredTo: z6.array(SkillIdeSchema)
+});
+var SkillsLockSchema = z6.object({
+  schemaVersion: z6.literal(1),
+  /** Map of skill id → lock entry */
+  skills: z6.record(z6.string().min(1), SkillsLockEntrySchema)
 });
 
 // src/loader.ts
@@ -266,8 +452,8 @@ import * as path from "path";
 // src/validator.ts
 function formatZodError(error) {
   return error.issues.map((issue) => {
-    const path2 = issue.path.length > 0 ? issue.path.join(".") : "(root)";
-    return `  - ${path2}: ${issue.message}`;
+    const path4 = issue.path.length > 0 ? issue.path.join(".") : "(root)";
+    return `  - ${path4}: ${issue.message}`;
   }).join("\n");
 }
 function validateManifest(data) {
@@ -303,6 +489,17 @@ function validateInstalled(data) {
 ${formatZodError(result.error)}`
   };
 }
+function validateSkillsLock(data) {
+  const result = SkillsLockSchema.safeParse(data);
+  if (result.success) {
+    return { success: true, data: result.data };
+  }
+  return {
+    success: false,
+    error: `Invalid skills lock:
+${formatZodError(result.error)}`
+  };
+}
 function validateSkillsPackage(data) {
   const result = SkillsPackageManifestSchema.safeParse(data);
   if (result.success) {
@@ -359,22 +556,22 @@ function validateUiDependencyGraph(entries) {
   const color = /* @__PURE__ */ new Map();
   for (const id of idToEntry.keys()) color.set(id, WHITE);
   const cycles = [];
-  function dfs(id, path2) {
+  function dfs(id, path4) {
     color.set(id, GRAY);
-    path2.push(id);
+    path4.push(id);
     const entry = idToEntry.get(id);
     const deps = entry?.registryDependencies ?? [];
     for (const dep of deps) {
       if (!idToEntry.has(dep)) continue;
       const c = color.get(dep);
       if (c === GRAY) {
-        const startIdx = path2.indexOf(dep);
-        cycles.push([...path2.slice(startIdx), dep]);
+        const startIdx = path4.indexOf(dep);
+        cycles.push([...path4.slice(startIdx), dep]);
       } else if (c === WHITE) {
-        dfs(dep, path2);
+        dfs(dep, path4);
       }
     }
-    path2.pop();
+    path4.pop();
     color.set(id, BLACK);
   }
   for (const id of idToEntry.keys()) {
@@ -496,6 +693,100 @@ async function loadUiPackageManifest(packageDir) {
   return result.data;
 }
 
+// src/tokens-pack-loader.ts
+import * as fs2 from "fs/promises";
+import * as path2 from "path";
+async function loadTokensPackageManifest(packageDir) {
+  const manifestPath = path2.join(packageDir, "manifest.json");
+  let raw;
+  try {
+    raw = await fs2.readFile(manifestPath, "utf-8");
+  } catch (err) {
+    const code = err.code;
+    if (code === "ENOENT") {
+      throw new Error(`Tokens package manifest not found: ${manifestPath}`);
+    }
+    throw new Error(
+      `Failed to read tokens package manifest at ${manifestPath}: ${err.message}`
+    );
+  }
+  let parsed;
+  try {
+    parsed = JSON.parse(raw);
+  } catch {
+    throw new Error(
+      `Invalid JSON in tokens package manifest at ${manifestPath}`
+    );
+  }
+  const result = TokensPackageManifestSchema.safeParse(parsed);
+  if (!result.success) {
+    throw new Error(
+      `Invalid tokens package manifest:
+${result.error.message}
+  File: ${manifestPath}`
+    );
+  }
+  return result.data;
+}
+function getVariantEntry(catalog, variantName) {
+  return catalog.variants.find((v) => v.name === variantName);
+}
+
+// src/variant-ui-pack-loader.ts
+import * as fs3 from "fs/promises";
+import * as path3 from "path";
+async function readJson(filePath, kind) {
+  let raw;
+  try {
+    raw = await fs3.readFile(filePath, "utf-8");
+  } catch (err) {
+    const code = err.code;
+    if (code === "ENOENT") {
+      throw new Error(`${kind} not found: ${filePath}`);
+    }
+    throw new Error(
+      `Failed to read ${kind} at ${filePath}: ${err.message}`
+    );
+  }
+  try {
+    return JSON.parse(raw);
+  } catch {
+    throw new Error(`Invalid JSON in ${kind} at ${filePath}`);
+  }
+}
+async function loadVariantUiPackageCatalog(packageDir) {
+  const manifestPath = path3.join(packageDir, "manifest.json");
+  const data = await readJson(manifestPath, "variant-ui catalog");
+  const result = VariantUiPackageCatalogSchema.safeParse(data);
+  if (!result.success) {
+    throw new Error(
+      `Invalid catalog:
+${result.error.message}
+  File: ${manifestPath}`
+    );
+  }
+  return result.data;
+}
+async function loadVariantUiPackageManifest(variantDir) {
+  const manifestPath = path3.join(variantDir, "manifest.json");
+  const data = await readJson(manifestPath, "variant-ui manifest");
+  const result = VariantUiPackageManifestSchema.safeParse(data);
+  if (!result.success) {
+    throw new Error(
+      `Invalid variant manifest:
+${result.error.message}
+  File: ${manifestPath}`
+    );
+  }
+  const dirName = path3.basename(variantDir);
+  if (result.data.variant !== dirName) {
+    throw new Error(
+      `Variant manifest mismatch: variants/${dirName}/manifest.json declares variant="${result.data.variant}". Names must match.`
+    );
+  }
+  return result.data;
+}
+
 // src/managed-regions.ts
 var REGION_PATTERN = /<!-- teamix-evo:managed:start id="([^"]+)" -->([\s\S]*?)<!-- teamix-evo:managed:end id="\1" -->/g;
 var START_MARKER_PATTERN = /<!-- teamix-evo:managed:start id="([^"]+)" -->/g;
@@ -627,8 +918,14 @@ export {
   SkillEntrySchema,
   SkillIdeSchema,
   SkillScopeSchema,
+  SkillsLockEntrySchema,
+  SkillsLockSchema,
   SkillsPackageManifestSchema,
   TailwindVersionSchema,
+  TokensPackLinkedSchema,
+  TokensPackLockSchema,
+  TokensPackageManifestSchema,
+  TokensVariantEntrySchema,
   UiAliasSchema,
   UiAliasesSchema,
   UiEntryFileSchema,
@@ -637,11 +934,18 @@ export {
   UiPackageManifestSchema,
   UpdateStrategySchema,
   VariantManifestSchema,
+  VariantUiPackageCatalogSchema,
+  VariantUiPackageManifestSchema,
+  VariantUiPackageNameSchema,
   getUpdateAction,
+  getVariantEntry,
   hasManagedRegion,
   loadSkillsPackageManifest,
+  loadTokensPackageManifest,
   loadUiPackageManifest,
   loadVariantManifest,
+  loadVariantUiPackageCatalog,
+  loadVariantUiPackageManifest,
   parseManagedRegions,
   replaceManagedRegion,
   resolveUiEntryOrder,
@@ -649,6 +953,7 @@ export {
   validateConfig,
   validateInstalled,
   validateManifest,
+  validateSkillsLock,
   validateSkillsPackage,
   validateUiDependencyGraph,
   validateUiPackage