@teamix-evo/registry 0.2.0 → 0.3.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/design/pack.lock.json` records the same variant. MUST equal
+   * the variant directory name in `@teamix-evo/design/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",
@@ -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(),
@@ -184,24 +212,148 @@ var UiPackageManifestSchema = z.object({
   entries: z.array(UiEntrySchema)
 });
 
-// src/schema/config.ts
+// src/schema/design-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 DesignPackLinkedSchema = z2.object({
+  "biz-ui": z2.string().optional(),
+  templates: z2.string().optional()
+});
+var DesignPackManifestSchema = z2.object({
+  $schema: z2.string().optional(),
+  schemaVersion: z2.literal(1),
+  /**
+   * Pack identifier.
+   * - `"default"` for the built-in baseline (only valid name when `extends` is absent)
+   * - lowercase kebab-case for variants (`opentrek`, `uni-manager`, `acme-erp`, `_template`)
+   */
+  name: z2.string().min(1).regex(
+    VARIANT_NAME_RE,
+    'Pack name must be lowercase letters/digits/hyphens (no leading hyphen). Special: "_template" allowed for the variant scaffold.'
+  ).or(z2.literal("_template")).or(z2.literal("default")),
+  /** Human-readable display name (e.g. "OpenTrek" for variant id "opentrek"). */
+  displayName: z2.string().min(1),
+  /** Semver. */
+  version: z2.string().regex(SEMVER_RE, "Invalid semver version"),
+  /**
+   * Parent pack name. Required for variants, must be omitted for `default`.
+   * Currently only `"default"` is a valid parent.
+   */
+  extends: z2.string().optional(),
+  /** Optional one-liner; useful for `design list-variants` output. */
+  description: z2.string().optional(),
+  /** Soft cross-package links (biz-ui / templates with same variant name). */
+  linked: DesignPackLinkedSchema.optional()
+});
+var DesignPackageManifestSchema = z2.object({
+  $schema: z2.string().optional(),
+  schemaVersion: z2.literal(1),
+  /** Always `"design"` for this package. */
+  package: z2.literal("design"),
+  /** Semver of the entire design package. */
+  version: z2.string().regex(SEMVER_RE, "Invalid semver version"),
+  /** Engine compatibility. */
+  engines: z2.object({ "teamix-evo": z2.string().min(1) }),
+  /** The default baseline pack — always present. */
+  default: DesignPackManifestSchema,
+  /** All shipped variants (excluding `_template/`). */
+  variants: z2.array(DesignPackManifestSchema)
+});
+var DesignPackLockSchema = z2.object({
+  $schema: z2.string().optional(),
+  schemaVersion: z2.literal(1),
+  default: z2.object({
+    version: z2.string().regex(SEMVER_RE),
+    from: z2.string().min(1)
+    // e.g. "@teamix-evo/design"
+  }),
+  variant: z2.object({
+    name: z2.string().min(1),
+    displayName: z2.string().min(1),
+    version: z2.string().regex(SEMVER_RE),
+    from: z2.string().min(1)
+  }),
+  linked: DesignPackLinkedSchema.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 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 = z2.object({
+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 +362,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({
+var InstalledPackageSchema = z5.object({
   /** Full package name (e.g. "@teamix-evo/design") */
-  package: z3.string().min(1),
+  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 +444,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 +481,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 +548,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 +685,200 @@ async function loadUiPackageManifest(packageDir) {
   return result.data;
 }
 
+// src/design-pack-loader.ts
+import * as fs2 from "fs/promises";
+import * as path2 from "path";
+var PACK_METADATA_FILES = /* @__PURE__ */ new Set(["pack.json"]);
+async function loadDesignPack(packDir) {
+  const manifestPath = path2.join(packDir, "pack.json");
+  let raw;
+  try {
+    raw = await fs2.readFile(manifestPath, "utf-8");
+  } catch (err) {
+    const code = err.code;
+    if (code === "ENOENT") {
+      throw new Error(`Design pack manifest not found: ${manifestPath}`);
+    }
+    throw new Error(
+      `Failed to read design pack manifest at ${manifestPath}: ${err.message}`
+    );
+  }
+  let parsed;
+  try {
+    parsed = JSON.parse(raw);
+  } catch {
+    throw new Error(`Invalid JSON in design pack manifest at ${manifestPath}`);
+  }
+  const result = DesignPackManifestSchema.safeParse(parsed);
+  if (!result.success) {
+    throw new Error(
+      `Invalid design pack manifest:
+${result.error.message}
+  File: ${manifestPath}`
+    );
+  }
+  if (result.data.name === "default" && result.data.extends !== void 0) {
+    throw new Error(
+      `Pack "default" must not have "extends" field: ${manifestPath}`
+    );
+  }
+  if (result.data.name !== "default" && result.data.extends !== "default") {
+    throw new Error(
+      `Variant pack "${result.data.name}" must declare extends: "default" (got ${JSON.stringify(
+        result.data.extends
+      )}): ${manifestPath}`
+    );
+  }
+  return result.data;
+}
+async function loadDesignPackageManifest(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(`Design package manifest not found: ${manifestPath}`);
+    }
+    throw new Error(
+      `Failed to read design package manifest at ${manifestPath}: ${err.message}`
+    );
+  }
+  let parsed;
+  try {
+    parsed = JSON.parse(raw);
+  } catch {
+    throw new Error(`Invalid JSON in design package manifest at ${manifestPath}`);
+  }
+  const result = DesignPackageManifestSchema.safeParse(parsed);
+  if (!result.success) {
+    throw new Error(
+      `Invalid design package manifest:
+${result.error.message}
+  File: ${manifestPath}`
+    );
+  }
+  return result.data;
+}
+async function walkPackTree(packDir) {
+  const out = [];
+  async function recurse(absDir, relDir) {
+    const entries = await fs2.readdir(absDir, { withFileTypes: true });
+    for (const entry of entries) {
+      const abs = path2.join(absDir, entry.name);
+      const rel = relDir ? path2.posix.join(relDir, entry.name) : entry.name;
+      if (entry.isDirectory()) {
+        await recurse(abs, rel);
+      } else if (entry.isFile()) {
+        if (relDir === "" && PACK_METADATA_FILES.has(entry.name)) continue;
+        out.push(rel);
+      }
+    }
+  }
+  try {
+    await recurse(packDir, "");
+  } catch (err) {
+    const code = err.code;
+    if (code === "ENOENT") {
+      throw new Error(`Pack directory not found: ${packDir}`);
+    }
+    throw err;
+  }
+  return out.sort();
+}
+async function mergeDefaultAndVariant(defaultDir, variantDir) {
+  const defaultFiles = new Set(await walkPackTree(defaultDir));
+  const variantFiles = new Set(await walkPackTree(variantDir));
+  const overrides = [];
+  const variantAdds = [];
+  const defaultPassThrough = [];
+  const files = [];
+  const allPaths = Array.from(/* @__PURE__ */ new Set([...defaultFiles, ...variantFiles])).sort();
+  for (const rel of allPaths) {
+    const inDefault = defaultFiles.has(rel);
+    const inVariant = variantFiles.has(rel);
+    if (inVariant && inDefault) {
+      overrides.push(rel);
+      files.push({
+        relPath: rel,
+        sourcePath: path2.join(variantDir, rel),
+        origin: "variant"
+      });
+    } else if (inVariant) {
+      variantAdds.push(rel);
+      files.push({
+        relPath: rel,
+        sourcePath: path2.join(variantDir, rel),
+        origin: "variant"
+      });
+    } else {
+      defaultPassThrough.push(rel);
+      files.push({
+        relPath: rel,
+        sourcePath: path2.join(defaultDir, rel),
+        origin: "default"
+      });
+    }
+  }
+  return { files, overrides, variantAdds, defaultPassThrough };
+}
+
+// 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;
@@ -617,6 +1000,10 @@ function getUpdateAction(strategy, options) {
   }
 }
 export {
+  DesignPackLinkedSchema,
+  DesignPackLockSchema,
+  DesignPackManifestSchema,
+  DesignPackageManifestSchema,
   InstalledManifestSchema,
   InstalledPackageSchema,
   InstalledResourceSchema,
@@ -627,6 +1014,8 @@ export {
   SkillEntrySchema,
   SkillIdeSchema,
   SkillScopeSchema,
+  SkillsLockEntrySchema,
+  SkillsLockSchema,
   SkillsPackageManifestSchema,
   TailwindVersionSchema,
   UiAliasSchema,
@@ -637,11 +1026,19 @@ export {
   UiPackageManifestSchema,
   UpdateStrategySchema,
   VariantManifestSchema,
+  VariantUiPackageCatalogSchema,
+  VariantUiPackageManifestSchema,
+  VariantUiPackageNameSchema,
   getUpdateAction,
   hasManagedRegion,
+  loadDesignPack,
+  loadDesignPackageManifest,
   loadSkillsPackageManifest,
   loadUiPackageManifest,
   loadVariantManifest,
+  loadVariantUiPackageCatalog,
+  loadVariantUiPackageManifest,
+  mergeDefaultAndVariant,
   parseManagedRegions,
   replaceManagedRegion,
   resolveUiEntryOrder,
@@ -649,8 +1046,10 @@ export {
   validateConfig,
   validateInstalled,
   validateManifest,
+  validateSkillsLock,
   validateSkillsPackage,
   validateUiDependencyGraph,
-  validateUiPackage
+  validateUiPackage,
+  walkPackTree
 };
 //# sourceMappingURL=index.js.map