@teamix-evo/registry 0.7.0 → 0.9.0

package/dist/index.cjs

@@ -30,11 +30,18 @@ var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: tru
 // src/index.ts
 var index_exports = {};
 __export(index_exports, {
+  ComponentLineageSchema: () => ComponentLineageSchema,
   InstalledManifestSchema: () => InstalledManifestSchema,
   InstalledPackageSchema: () => InstalledPackageSchema,
   InstalledResourceSchema: () => InstalledResourceSchema,
+  LastUpdateRecordSchema: () => LastUpdateRecordSchema,
   PackageEntrySchema: () => PackageEntrySchema,
   ProjectConfigSchema: () => ProjectConfigSchema,
+  ProjectConfigV1Schema: () => ProjectConfigV1Schema,
+  ProjectConfigV2Schema: () => ProjectConfigV2Schema,
+  PromoteFeatureVectorSchema: () => PromoteFeatureVectorSchema,
+  PromoteFileTypeSchema: () => PromoteFileTypeSchema,
+  PromoteModeSchema: () => PromoteModeSchema,
   ResourceSchema: () => ResourceSchema,
   ResourceTypeSchema: () => ResourceTypeSchema,
   SkillEntrySchema: () => SkillEntrySchema,
@@ -44,6 +51,8 @@ __export(index_exports, {
   SkillsLockSchema: () => SkillsLockSchema,
   SkillsPackageManifestSchema: () => SkillsPackageManifestSchema,
   TailwindVersionSchema: () => TailwindVersionSchema,
+  TokenRenameEntrySchema: () => TokenRenameEntrySchema,
+  TokenRenameRecordSchema: () => TokenRenameRecordSchema,
   TokensPackLinkedSchema: () => TokensPackLinkedSchema,
   TokensPackLockSchema: () => TokensPackLockSchema,
   TokensPackageManifestSchema: () => TokensPackageManifestSchema,
@@ -55,10 +64,20 @@ __export(index_exports, {
   UiEntryTypeSchema: () => UiEntryTypeSchema,
   UiPackageManifestSchema: () => UiPackageManifestSchema,
   UpdateStrategySchema: () => UpdateStrategySchema,
+  UpgradeRiskLevelSchema: () => UpgradeRiskLevelSchema,
+  UpgradeStagingCategorySchema: () => UpgradeStagingCategorySchema,
+  UpgradeStagingCurrentSchema: () => UpgradeStagingCurrentSchema,
+  UpgradeStagingDiffSchema: () => UpgradeStagingDiffSchema,
+  UpgradeStagingEntrySchema: () => UpgradeStagingEntrySchema,
+  UpgradeStagingIncomingSchema: () => UpgradeStagingIncomingSchema,
+  UpgradeStagingManifestSchema: () => UpgradeStagingManifestSchema,
+  UpgradeStagingPromotionSchema: () => UpgradeStagingPromotionSchema,
+  UpgradeStagingTriggerSchema: () => UpgradeStagingTriggerSchema,
   VariantManifestSchema: () => VariantManifestSchema,
   VariantUiPackageCatalogSchema: () => VariantUiPackageCatalogSchema,
   VariantUiPackageManifestSchema: () => VariantUiPackageManifestSchema,
   VariantUiPackageNameSchema: () => VariantUiPackageNameSchema,
+  extractFrontmatter: () => extractFrontmatter,
   getUpdateAction: () => getUpdateAction,
   getVariantEntry: () => getVariantEntry,
   hasManagedRegion: () => hasManagedRegion,
@@ -69,9 +88,11 @@ __export(index_exports, {
   loadVariantUiPackageCatalog: () => loadVariantUiPackageCatalog,
   loadVariantUiPackageManifest: () => loadVariantUiPackageManifest,
   parseManagedRegions: () => parseManagedRegions,
+  replaceFrontmatter: () => replaceFrontmatter,
   replaceManagedRegion: () => replaceManagedRegion,
   resolveUiEntryOrder: () => resolveUiEntryOrder,
   shouldUpdate: () => shouldUpdate,
+  splitManagedRegions: () => splitManagedRegions,
   validateConfig: () => validateConfig,
   validateInstalled: () => validateInstalled,
   validateManifest: () => validateManifest,
@@ -328,6 +349,16 @@ var TokensPackLinkedSchema = import_zod2.z.object({
   "biz-ui": import_zod2.z.string().optional(),
   templates: import_zod2.z.string().optional()
 });
+var TokenRenameEntrySchema = import_zod2.z.object({
+  /** Variant version at which the rename took effect (semver). */
+  sinceVersion: import_zod2.z.string().regex(SEMVER_RE, "Invalid semver version"),
+  /** Old token name (with or without leading `--`; both forms accepted). */
+  from: import_zod2.z.string().min(1),
+  /** New token name. */
+  to: import_zod2.z.string().min(1),
+  /** Optional one-liner rationale surfaced in the upgrade-hints file. */
+  description: import_zod2.z.string().optional()
+});
 var TokensVariantEntrySchema = import_zod2.z.object({
   /** Variant id — lowercase kebab-case. */
   name: import_zod2.z.string().min(1).regex(
@@ -347,7 +378,12 @@ var TokensVariantEntrySchema = import_zod2.z.object({
    */
   files: import_zod2.z.array(import_zod2.z.string().min(1)).min(1),
   /** Soft cross-package links (biz-ui / templates with the same variant name). */
-  linked: TokensPackLinkedSchema.optional()
+  linked: TokensPackLinkedSchema.optional(),
+  /**
+   * Token rename log accumulated across this variant's version history.
+   * Empty / absent when the variant has never renamed a token.
+   */
+  renames: import_zod2.z.array(TokenRenameEntrySchema).optional()
 });
 var TokensPackageManifestSchema = import_zod2.z.object({
   $schema: import_zod2.z.string().optional(),
@@ -474,7 +510,28 @@ var PackageEntrySchema = import_zod4.z.object({
   /** Whether to emit React Server Components markers (`"use client"`). ui-specific. */
   rsc: import_zod4.z.boolean().optional()
 });
-var ProjectConfigSchema = import_zod4.z.object({
+var TokenRenameRecordSchema = import_zod4.z.object({
+  /** ISO-8601 UTC timestamp at which the variant switch was performed. */
+  ts: import_zod4.z.string().min(1),
+  /** Variant the project was on before the switch. */
+  fromVariant: import_zod4.z.string().min(1),
+  /** Variant the project switched to. */
+  toVariant: import_zod4.z.string().min(1),
+  /**
+   * Token rename mapping — old token name → new token name.
+   * Empty object is legal (e.g. switch with zero rename).
+   */
+  renames: import_zod4.z.record(import_zod4.z.string(), import_zod4.z.string())
+});
+var LastUpdateRecordSchema = import_zod4.z.object({
+  /** ISO-8601 UTC timestamp of the last successful update. */
+  ts: import_zod4.z.string().min(1),
+  /** Version the package was on before this update. */
+  fromVersion: import_zod4.z.string().min(1),
+  /** Version the package was on after this update. */
+  toVersion: import_zod4.z.string().min(1)
+});
+var ProjectConfigV1Schema = import_zod4.z.object({
   $schema: import_zod4.z.string().optional(),
   schemaVersion: import_zod4.z.literal(1),
   /** IDE identifier */
@@ -482,6 +539,31 @@ var ProjectConfigSchema = import_zod4.z.object({
   /** Installed packages keyed by package name */
   packages: import_zod4.z.record(import_zod4.z.string(), PackageEntrySchema)
 });
+var ProjectConfigV2Schema = import_zod4.z.object({
+  $schema: import_zod4.z.string().optional(),
+  schemaVersion: import_zod4.z.literal(2),
+  /** IDE identifier */
+  ide: import_zod4.z.string().min(1),
+  /** Installed packages keyed by package name */
+  packages: import_zod4.z.record(import_zod4.z.string(), PackageEntrySchema),
+  /** Variant in effect before the most recent `variant switch`, if any. */
+  priorVariant: import_zod4.z.string().min(1).optional(),
+  /** Last successful update record keyed by package name. */
+  lastUpdate: import_zod4.z.record(import_zod4.z.string(), LastUpdateRecordSchema).optional(),
+  /** Token rename log accumulated across variant switches (oldest → newest). */
+  tokenRenameHistory: import_zod4.z.array(TokenRenameRecordSchema).optional()
+});
+var ProjectConfigSchema = import_zod4.z.discriminatedUnion("schemaVersion", [
+  ProjectConfigV1Schema,
+  ProjectConfigV2Schema
+]).transform((cfg) => {
+  if (cfg.schemaVersion === 2) return cfg;
+  const { schemaVersion: _v1, ...rest } = cfg;
+  return {
+    ...rest,
+    schemaVersion: 2
+  };
+});
 
 // src/schema/installed.ts
 var import_zod5 = require("zod");
@@ -497,7 +579,26 @@ var InstalledResourceSchema = import_zod5.z.object({
   /** IDE this resource was installed for (skill resources only) */
   ide: SkillIdeSchema.optional(),
   /** Install scope (skill resources only) */
-  scope: SkillScopeSchema.optional()
+  scope: SkillScopeSchema.optional(),
+  /**
+   * Origin of the file content. Optional for backwards compatibility — older
+   * manifests without this field still validate.
+   *
+   * - `teamix-evo`     : installed from `@teamix-evo/ui` (or biz-ui)
+   * - `shadcn-native`  : matches an upstream registry entry verbatim
+   * - `custom`         : user-modified or hand-authored, no upstream match
+   * - `custom-legacy`  : user version preserved during a Coexist promotion
+   *                     (see ADR / promote-to-biz)
+   * - `detected`       : adopted via `ui add --adopt`, registry id matched but
+   *                     content has not been verified against upstream hash
+   */
+  sourceLineage: import_zod5.z.enum([
+    "teamix-evo",
+    "shadcn-native",
+    "custom",
+    "custom-legacy",
+    "detected"
+  ]).optional()
 });
 var InstalledPackageSchema = import_zod5.z.object({
   /** Full package name (e.g. "@teamix-evo/tokens") */
@@ -543,6 +644,152 @@ var SkillsLockSchema = import_zod6.z.object({
   skills: import_zod6.z.record(import_zod6.z.string().min(1), SkillsLockEntrySchema)
 });
 
+// src/schema/upgrade-staging.ts
+var import_zod7 = require("zod");
+var UpgradeRiskLevelSchema = import_zod7.z.enum([
+  /** Hash matches — nothing to do. */
+  "unchanged",
+  /** Single-file change, no exported API surface delta. */
+  "upgradable-low",
+  /** Multi-file change or new exports / new cva variants (additive). */
+  "upgradable-medium",
+  /** Removed cva variants / renamed exports / props type narrowing. */
+  "risky",
+  /** Entry no longer exists upstream / file removed. */
+  "breaking",
+  /** Present in `src/components/{ui,biz-ui}/` but absent from installed manifest. */
+  "foreign"
+]);
+var ComponentLineageSchema = import_zod7.z.enum([
+  "teamix-evo",
+  "shadcn-native",
+  "mixed",
+  "custom-only"
+]);
+var UpgradeStagingCategorySchema = import_zod7.z.enum(["ui", "biz-ui"]);
+var UpgradeStagingTriggerSchema = import_zod7.z.enum([
+  "update",
+  "ui-upgrade",
+  "biz-ui-upgrade"
+]);
+var UpgradeStagingCurrentSchema = import_zod7.z.object({
+  /** Project-relative path of the component file (e.g. `src/components/ui/button.tsx`). */
+  target: import_zod7.z.string().min(1),
+  /** Hash recorded in `.teamix-evo/manifest.json` at install time, or null when foreign. */
+  hash: import_zod7.z.string().nullable(),
+  /** Lineage of *this specific component* (independent of project-wide lineage). */
+  sourceLineage: import_zod7.z.enum(["teamix-evo", "shadcn-native", "custom", "absent"])
+});
+var UpgradeStagingIncomingSchema = import_zod7.z.object({
+  /** Package-level version the incoming source comes from. */
+  sourceVersion: import_zod7.z.string().min(1),
+  /** Hash of incoming source after applying the consumer's import-rewrite aliases. */
+  hash: import_zod7.z.string().min(1),
+  /** Path of the incoming source file relative to the staging dir (e.g. `button/incoming.tsx`). */
+  relPath: import_zod7.z.string().min(1)
+});
+var UpgradeStagingDiffSchema = import_zod7.z.object({
+  riskLevel: UpgradeRiskLevelSchema,
+  /** Human-readable, machine-parsable hints (e.g. `"new prop: loading"`, `"removed cva variant: ghost"`). */
+  hints: import_zod7.z.array(import_zod7.z.string()),
+  /** Number of files that differ for this entry (almost always 1 today; reserved for multi-file entries). */
+  filesChangedCount: import_zod7.z.number().int().nonnegative(),
+  /**
+   * Path of the unified diff relative to the staging dir, when CLI emitted one.
+   * Reserved for a future emitter — in schema v1 the CLI does **not** pre-render
+   * `diff.unified.patch`; the consumer of the staging (the `teamix-evo-upgrade`
+   * skill) computes the diff on the fly from `current.tsx` vs `incoming.tsx`.
+   */
+  diffRelPath: import_zod7.z.string().optional()
+});
+var PromoteFileTypeSchema = import_zod7.z.enum([
+  "component",
+  "hook",
+  "util",
+  "type",
+  "provider"
+]);
+var PromoteModeSchema = import_zod7.z.enum([
+  "Coexist",
+  "Preset",
+  "Wrapper",
+  "Compose",
+  "Variant",
+  "Fork",
+  "TokenOnly",
+  "ManualReview"
+]);
+var PromoteFeatureVectorSchema = import_zod7.z.object({
+  apiDelta: import_zod7.z.object({
+    added: import_zod7.z.array(import_zod7.z.string()),
+    removed: import_zod7.z.array(import_zod7.z.string()),
+    signatureChanged: import_zod7.z.boolean()
+  }),
+  styleDelta: import_zod7.z.object({
+    classNameDiff: import_zod7.z.boolean(),
+    tokenUsageDiff: import_zod7.z.boolean()
+  }),
+  logicDelta: import_zod7.z.object({
+    hasState: import_zod7.z.boolean(),
+    hasEffect: import_zod7.z.boolean(),
+    hasExtraImports: import_zod7.z.boolean()
+  }),
+  cvaDelta: import_zod7.z.object({
+    addedVariants: import_zod7.z.array(import_zod7.z.string()),
+    modifiedVariants: import_zod7.z.array(import_zod7.z.string())
+  }),
+  structureDelta: import_zod7.z.object({
+    isComposition: import_zod7.z.boolean(),
+    atomicChildren: import_zod7.z.array(import_zod7.z.string())
+  })
+});
+var UpgradeStagingPromotionSchema = import_zod7.z.object({
+  fileType: PromoteFileTypeSchema,
+  featureVector: PromoteFeatureVectorSchema,
+  recommendedModes: import_zod7.z.array(PromoteModeSchema),
+  confidence: import_zod7.z.number().min(0).max(1),
+  reasons: import_zod7.z.array(import_zod7.z.string())
+});
+var UpgradeStagingEntrySchema = import_zod7.z.object({
+  /** Component identifier matching the upstream registry (e.g. `"button"`). */
+  id: import_zod7.z.string().min(1),
+  /** Which package category this entry belongs to. */
+  category: UpgradeStagingCategorySchema,
+  current: UpgradeStagingCurrentSchema,
+  /** Absent when the entry is `breaking` (no incoming) or `foreign` (no upstream). */
+  incoming: UpgradeStagingIncomingSchema.optional(),
+  diff: UpgradeStagingDiffSchema,
+  /**
+   * Optional promotion-planning payload (Init landing plan Phase 2.C.2). Only
+   * emitted when the CLI was able to compare current/incoming sources —
+   * `breaking` / `foreign` entries leave it undefined.
+   */
+  promotion: UpgradeStagingPromotionSchema.optional()
+});
+var UpgradeStagingManifestSchema = import_zod7.z.object({
+  schemaVersion: import_zod7.z.literal(1),
+  /** ISO-8601 timestamp the staging dir was created (matches dir suffix). */
+  ts: import_zod7.z.string().min(1),
+  /** Which package category this staging covers. */
+  package: UpgradeStagingCategorySchema,
+  /** Which command produced this staging. */
+  trigger: UpgradeStagingTriggerSchema,
+  /** Variant applicable to the staging (always `_flat` for ui; concrete variant for biz-ui). */
+  variant: import_zod7.z.string().min(1),
+  /** Installed package version (from `.teamix-evo/manifest.json`); empty string when foreign-only. */
+  fromVersion: import_zod7.z.string(),
+  /** Upstream package version. */
+  toVersion: import_zod7.z.string().min(1),
+  /** Project-wide lineage classification. */
+  lineage: ComponentLineageSchema,
+  /** Aggregate counts grouped by riskLevel for quick AI summarization. */
+  summary: import_zod7.z.object({
+    total: import_zod7.z.number().int().nonnegative(),
+    byRisk: import_zod7.z.record(UpgradeRiskLevelSchema, import_zod7.z.number().int().nonnegative())
+  }),
+  entries: import_zod7.z.array(UpgradeStagingEntrySchema)
+});
+
 // src/loader.ts
 var fs = __toESM(require("fs/promises"), 1);
 var path = __toESM(require("path"), 1);
@@ -967,9 +1214,48 @@ function hasManagedRegion(content, id) {
   );
   return pattern.test(content);
 }
+function splitManagedRegions(content) {
+  parseManagedRegions(content);
+  const regionRe = new RegExp(REGION_PATTERN.source, "g");
+  const segments = [];
+  let cursor = 0;
+  let match;
+  while ((match = regionRe.exec(content)) !== null) {
+    const id = match[1];
+    const regionContent = match[2];
+    const start = match.index;
+    const end = start + match[0].length;
+    segments.push({ kind: "unmanaged", content: content.slice(cursor, start) });
+    segments.push({
+      kind: "managed",
+      region: {
+        id,
+        startMarker: `<!-- teamix-evo:managed:start id="${id}" -->`,
+        endMarker: `<!-- teamix-evo:managed:end id="${id}" -->`,
+        content: regionContent
+      }
+    });
+    cursor = end;
+  }
+  segments.push({ kind: "unmanaged", content: content.slice(cursor) });
+  return segments;
+}
 function escapeRegExp(str) {
   return str.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
 }
+var FRONTMATTER_PATTERN = /^---\r?\n[\s\S]*?\r?\n---(?:\r?\n|$)/;
+function extractFrontmatter(content) {
+  const m = content.match(FRONTMATTER_PATTERN);
+  return m ? m[0] : null;
+}
+function replaceFrontmatter(content, newFrontmatter) {
+  const m = content.match(FRONTMATTER_PATTERN);
+  if (!m) {
+    return newFrontmatter.endsWith("\n") ? newFrontmatter + content : `${newFrontmatter}
+${content}`;
+  }
+  return newFrontmatter + content.slice(m[0].length);
+}
 
 // src/strategy.ts
 function shouldUpdate(strategy, resourceExists) {
@@ -1007,11 +1293,18 @@ function getUpdateAction(strategy, options) {
 }
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
+  ComponentLineageSchema,
   InstalledManifestSchema,
   InstalledPackageSchema,
   InstalledResourceSchema,
+  LastUpdateRecordSchema,
   PackageEntrySchema,
   ProjectConfigSchema,
+  ProjectConfigV1Schema,
+  ProjectConfigV2Schema,
+  PromoteFeatureVectorSchema,
+  PromoteFileTypeSchema,
+  PromoteModeSchema,
   ResourceSchema,
   ResourceTypeSchema,
   SkillEntrySchema,
@@ -1021,6 +1314,8 @@ function getUpdateAction(strategy, options) {
   SkillsLockSchema,
   SkillsPackageManifestSchema,
   TailwindVersionSchema,
+  TokenRenameEntrySchema,
+  TokenRenameRecordSchema,
   TokensPackLinkedSchema,
   TokensPackLockSchema,
   TokensPackageManifestSchema,
@@ -1032,10 +1327,20 @@ function getUpdateAction(strategy, options) {
   UiEntryTypeSchema,
   UiPackageManifestSchema,
   UpdateStrategySchema,
+  UpgradeRiskLevelSchema,
+  UpgradeStagingCategorySchema,
+  UpgradeStagingCurrentSchema,
+  UpgradeStagingDiffSchema,
+  UpgradeStagingEntrySchema,
+  UpgradeStagingIncomingSchema,
+  UpgradeStagingManifestSchema,
+  UpgradeStagingPromotionSchema,
+  UpgradeStagingTriggerSchema,
   VariantManifestSchema,
   VariantUiPackageCatalogSchema,
   VariantUiPackageManifestSchema,
   VariantUiPackageNameSchema,
+  extractFrontmatter,
   getUpdateAction,
   getVariantEntry,
   hasManagedRegion,
@@ -1046,9 +1351,11 @@ function getUpdateAction(strategy, options) {
   loadVariantUiPackageCatalog,
   loadVariantUiPackageManifest,
   parseManagedRegions,
+  replaceFrontmatter,
   replaceManagedRegion,
   resolveUiEntryOrder,
   shouldUpdate,
+  splitManagedRegions,
   validateConfig,
   validateInstalled,
   validateManifest,