@teamix-evo/registry 0.7.0 → 0.9.0

package/dist/index.js

@@ -244,6 +244,16 @@ var TokensPackLinkedSchema = z2.object({
   "biz-ui": z2.string().optional(),
   templates: z2.string().optional()
 });
+var TokenRenameEntrySchema = z2.object({
+  /** Variant version at which the rename took effect (semver). */
+  sinceVersion: z2.string().regex(SEMVER_RE, "Invalid semver version"),
+  /** Old token name (with or without leading `--`; both forms accepted). */
+  from: z2.string().min(1),
+  /** New token name. */
+  to: z2.string().min(1),
+  /** Optional one-liner rationale surfaced in the upgrade-hints file. */
+  description: z2.string().optional()
+});
 var TokensVariantEntrySchema = z2.object({
   /** Variant id — lowercase kebab-case. */
   name: z2.string().min(1).regex(
@@ -263,7 +273,12 @@ var TokensVariantEntrySchema = z2.object({
    */
   files: z2.array(z2.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: z2.array(TokenRenameEntrySchema).optional()
 });
 var TokensPackageManifestSchema = z2.object({
   $schema: z2.string().optional(),
@@ -390,7 +405,28 @@ var PackageEntrySchema = z4.object({
   /** Whether to emit React Server Components markers (`"use client"`). ui-specific. */
   rsc: z4.boolean().optional()
 });
-var ProjectConfigSchema = z4.object({
+var TokenRenameRecordSchema = z4.object({
+  /** ISO-8601 UTC timestamp at which the variant switch was performed. */
+  ts: z4.string().min(1),
+  /** Variant the project was on before the switch. */
+  fromVariant: z4.string().min(1),
+  /** Variant the project switched to. */
+  toVariant: z4.string().min(1),
+  /**
+   * Token rename mapping — old token name → new token name.
+   * Empty object is legal (e.g. switch with zero rename).
+   */
+  renames: z4.record(z4.string(), z4.string())
+});
+var LastUpdateRecordSchema = z4.object({
+  /** ISO-8601 UTC timestamp of the last successful update. */
+  ts: z4.string().min(1),
+  /** Version the package was on before this update. */
+  fromVersion: z4.string().min(1),
+  /** Version the package was on after this update. */
+  toVersion: z4.string().min(1)
+});
+var ProjectConfigV1Schema = z4.object({
   $schema: z4.string().optional(),
   schemaVersion: z4.literal(1),
   /** IDE identifier */
@@ -398,6 +434,31 @@ var ProjectConfigSchema = z4.object({
   /** Installed packages keyed by package name */
   packages: z4.record(z4.string(), PackageEntrySchema)
 });
+var ProjectConfigV2Schema = z4.object({
+  $schema: z4.string().optional(),
+  schemaVersion: z4.literal(2),
+  /** IDE identifier */
+  ide: z4.string().min(1),
+  /** Installed packages keyed by package name */
+  packages: z4.record(z4.string(), PackageEntrySchema),
+  /** Variant in effect before the most recent `variant switch`, if any. */
+  priorVariant: z4.string().min(1).optional(),
+  /** Last successful update record keyed by package name. */
+  lastUpdate: z4.record(z4.string(), LastUpdateRecordSchema).optional(),
+  /** Token rename log accumulated across variant switches (oldest → newest). */
+  tokenRenameHistory: z4.array(TokenRenameRecordSchema).optional()
+});
+var ProjectConfigSchema = z4.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
 import { z as z5 } from "zod";
@@ -413,7 +474,26 @@ var InstalledResourceSchema = z5.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: z5.enum([
+    "teamix-evo",
+    "shadcn-native",
+    "custom",
+    "custom-legacy",
+    "detected"
+  ]).optional()
 });
 var InstalledPackageSchema = z5.object({
   /** Full package name (e.g. "@teamix-evo/tokens") */
@@ -459,6 +539,152 @@ var SkillsLockSchema = z6.object({
   skills: z6.record(z6.string().min(1), SkillsLockEntrySchema)
 });
 
+// src/schema/upgrade-staging.ts
+import { z as z7 } from "zod";
+var UpgradeRiskLevelSchema = z7.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 = z7.enum([
+  "teamix-evo",
+  "shadcn-native",
+  "mixed",
+  "custom-only"
+]);
+var UpgradeStagingCategorySchema = z7.enum(["ui", "biz-ui"]);
+var UpgradeStagingTriggerSchema = z7.enum([
+  "update",
+  "ui-upgrade",
+  "biz-ui-upgrade"
+]);
+var UpgradeStagingCurrentSchema = z7.object({
+  /** Project-relative path of the component file (e.g. `src/components/ui/button.tsx`). */
+  target: z7.string().min(1),
+  /** Hash recorded in `.teamix-evo/manifest.json` at install time, or null when foreign. */
+  hash: z7.string().nullable(),
+  /** Lineage of *this specific component* (independent of project-wide lineage). */
+  sourceLineage: z7.enum(["teamix-evo", "shadcn-native", "custom", "absent"])
+});
+var UpgradeStagingIncomingSchema = z7.object({
+  /** Package-level version the incoming source comes from. */
+  sourceVersion: z7.string().min(1),
+  /** Hash of incoming source after applying the consumer's import-rewrite aliases. */
+  hash: z7.string().min(1),
+  /** Path of the incoming source file relative to the staging dir (e.g. `button/incoming.tsx`). */
+  relPath: z7.string().min(1)
+});
+var UpgradeStagingDiffSchema = z7.object({
+  riskLevel: UpgradeRiskLevelSchema,
+  /** Human-readable, machine-parsable hints (e.g. `"new prop: loading"`, `"removed cva variant: ghost"`). */
+  hints: z7.array(z7.string()),
+  /** Number of files that differ for this entry (almost always 1 today; reserved for multi-file entries). */
+  filesChangedCount: z7.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: z7.string().optional()
+});
+var PromoteFileTypeSchema = z7.enum([
+  "component",
+  "hook",
+  "util",
+  "type",
+  "provider"
+]);
+var PromoteModeSchema = z7.enum([
+  "Coexist",
+  "Preset",
+  "Wrapper",
+  "Compose",
+  "Variant",
+  "Fork",
+  "TokenOnly",
+  "ManualReview"
+]);
+var PromoteFeatureVectorSchema = z7.object({
+  apiDelta: z7.object({
+    added: z7.array(z7.string()),
+    removed: z7.array(z7.string()),
+    signatureChanged: z7.boolean()
+  }),
+  styleDelta: z7.object({
+    classNameDiff: z7.boolean(),
+    tokenUsageDiff: z7.boolean()
+  }),
+  logicDelta: z7.object({
+    hasState: z7.boolean(),
+    hasEffect: z7.boolean(),
+    hasExtraImports: z7.boolean()
+  }),
+  cvaDelta: z7.object({
+    addedVariants: z7.array(z7.string()),
+    modifiedVariants: z7.array(z7.string())
+  }),
+  structureDelta: z7.object({
+    isComposition: z7.boolean(),
+    atomicChildren: z7.array(z7.string())
+  })
+});
+var UpgradeStagingPromotionSchema = z7.object({
+  fileType: PromoteFileTypeSchema,
+  featureVector: PromoteFeatureVectorSchema,
+  recommendedModes: z7.array(PromoteModeSchema),
+  confidence: z7.number().min(0).max(1),
+  reasons: z7.array(z7.string())
+});
+var UpgradeStagingEntrySchema = z7.object({
+  /** Component identifier matching the upstream registry (e.g. `"button"`). */
+  id: z7.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 = z7.object({
+  schemaVersion: z7.literal(1),
+  /** ISO-8601 timestamp the staging dir was created (matches dir suffix). */
+  ts: z7.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: z7.string().min(1),
+  /** Installed package version (from `.teamix-evo/manifest.json`); empty string when foreign-only. */
+  fromVersion: z7.string(),
+  /** Upstream package version. */
+  toVersion: z7.string().min(1),
+  /** Project-wide lineage classification. */
+  lineage: ComponentLineageSchema,
+  /** Aggregate counts grouped by riskLevel for quick AI summarization. */
+  summary: z7.object({
+    total: z7.number().int().nonnegative(),
+    byRisk: z7.record(UpgradeRiskLevelSchema, z7.number().int().nonnegative())
+  }),
+  entries: z7.array(UpgradeStagingEntrySchema)
+});
+
 // src/loader.ts
 import * as fs from "fs/promises";
 import * as path from "path";
@@ -883,9 +1109,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) {
@@ -922,11 +1187,18 @@ function getUpdateAction(strategy, options) {
   }
 }
 export {
+  ComponentLineageSchema,
   InstalledManifestSchema,
   InstalledPackageSchema,
   InstalledResourceSchema,
+  LastUpdateRecordSchema,
   PackageEntrySchema,
   ProjectConfigSchema,
+  ProjectConfigV1Schema,
+  ProjectConfigV2Schema,
+  PromoteFeatureVectorSchema,
+  PromoteFileTypeSchema,
+  PromoteModeSchema,
   ResourceSchema,
   ResourceTypeSchema,
   SkillEntrySchema,
@@ -936,6 +1208,8 @@ export {
   SkillsLockSchema,
   SkillsPackageManifestSchema,
   TailwindVersionSchema,
+  TokenRenameEntrySchema,
+  TokenRenameRecordSchema,
   TokensPackLinkedSchema,
   TokensPackLockSchema,
   TokensPackageManifestSchema,
@@ -947,10 +1221,20 @@ export {
   UiEntryTypeSchema,
   UiPackageManifestSchema,
   UpdateStrategySchema,
+  UpgradeRiskLevelSchema,
+  UpgradeStagingCategorySchema,
+  UpgradeStagingCurrentSchema,
+  UpgradeStagingDiffSchema,
+  UpgradeStagingEntrySchema,
+  UpgradeStagingIncomingSchema,
+  UpgradeStagingManifestSchema,
+  UpgradeStagingPromotionSchema,
+  UpgradeStagingTriggerSchema,
   VariantManifestSchema,
   VariantUiPackageCatalogSchema,
   VariantUiPackageManifestSchema,
   VariantUiPackageNameSchema,
+  extractFrontmatter,
   getUpdateAction,
   getVariantEntry,
   hasManagedRegion,
@@ -961,9 +1245,11 @@ export {
   loadVariantUiPackageCatalog,
   loadVariantUiPackageManifest,
   parseManagedRegions,
+  replaceFrontmatter,
   replaceManagedRegion,
   resolveUiEntryOrder,
   shouldUpdate,
+  splitManagedRegions,
   validateConfig,
   validateInstalled,
   validateManifest,