inai-react-components 0.1.7 → 1.4.0

package/dist/utils/framework-detect.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"framework-detect.d.ts","sourceRoot":"","sources":["../../src/utils/framework-detect.ts"],"names":[],"mappings":"AAGA,MAAM,MAAM,SAAS,GACjB,UAAU,GACV,YAAY,GACZ,MAAM,GACN,OAAO,GACP,OAAO,GACP,gBAAgB,GAChB,SAAS,CAAC;AAEd;;;;GAIG;AACH,wBAAgB,eAAe,CAAC,GAAG,EAAE,MAAM,GAAG,SAAS,CAkDtD;AAED;;;;;;;;;GASG;AACH,wBAAgB,gBAAgB,CAAC,SAAS,EAAE,SAAS,EAAE,UAAU,EAAE,MAAM,GAAG,MAAM,CAmBjF;AAED,wBAAgB,cAAc,CAAC,SAAS,EAAE,SAAS,GAAG,MAAM,CAiB3D"}

package/dist/utils/framework-detect.js

@@ -0,0 +1,97 @@
+import fs from "node:fs";
+import path from "node:path";
+/**
+ * Detect the React meta-framework in use for a given project directory.
+ * Order matters: Next / Remix / Astro win over a bare vite.config because
+ * those frameworks often *also* ship a vite config under the hood.
+ */
+export function detectFramework(cwd) {
+    const has = (p) => fs.existsSync(path.join(cwd, p));
+    if (has("next.config.js") ||
+        has("next.config.ts") ||
+        has("next.config.mjs") ||
+        has("next.config.cjs")) {
+        if (has("app") || has("src/app"))
+            return "next-app";
+        if (has("pages") || has("src/pages"))
+            return "next-pages";
+        return "next-app";
+    }
+    if (has("remix.config.js") || has("remix.config.ts"))
+        return "remix";
+    if (has("astro.config.mjs") ||
+        has("astro.config.ts") ||
+        has("astro.config.js")) {
+        return "astro";
+    }
+    // TanStack Start is identified via package.json, not a config file.
+    try {
+        const pkgPath = path.join(cwd, "package.json");
+        if (fs.existsSync(pkgPath)) {
+            const pkg = JSON.parse(fs.readFileSync(pkgPath, "utf8"));
+            const allDeps = {
+                ...(pkg.dependencies ?? {}),
+                ...(pkg.devDependencies ?? {}),
+            };
+            if ("@tanstack/react-start" in allDeps)
+                return "tanstack-start";
+        }
+    }
+    catch {
+        // fall through
+    }
+    if (has("vite.config.js") ||
+        has("vite.config.ts") ||
+        has("vite.config.mjs")) {
+        return "vite";
+    }
+    return "unknown";
+}
+/**
+ * Default CSS entry point for a given framework, relative to the project
+ * root. `sourceRoot` is the project's source directory (usually "src" or
+ * "app") as detected from `tsconfig.json`. Paths are derived from it so
+ * projects that use `app/` instead of `src/` get correct defaults without
+ * manual overrides.
+ *
+ * Next.js Pages Router and Next.js App Router are special: their CSS
+ * entry point is dictated by the framework, not the user's source root.
+ */
+export function getCssEntryPoint(framework, sourceRoot) {
+    switch (framework) {
+        case "next-app":
+            // Next App Router always uses `app/globals.css` regardless of sourceRoot.
+            return "app/globals.css";
+        case "next-pages":
+            // Next Pages Router uses top-level `styles/globals.css`.
+            return "styles/globals.css";
+        case "vite":
+            return `${sourceRoot}/index.css`;
+        case "remix":
+            return `${sourceRoot}/styles/globals.css`;
+        case "astro":
+            return `${sourceRoot}/styles/globals.css`;
+        case "tanstack-start":
+            return `${sourceRoot}/styles/app.css`;
+        default:
+            return `${sourceRoot}/index.css`;
+    }
+}
+export function frameworkLabel(framework) {
+    switch (framework) {
+        case "next-app":
+            return "Next.js (App Router)";
+        case "next-pages":
+            return "Next.js (Pages Router)";
+        case "vite":
+            return "Vite";
+        case "remix":
+            return "Remix";
+        case "astro":
+            return "Astro";
+        case "tanstack-start":
+            return "TanStack Start";
+        default:
+            return "Unknown";
+    }
+}

package/dist/utils/fuzzy-search.d.ts

@@ -0,0 +1,16 @@
+/**
+ * Lightweight fuzzy search for CLI component name suggestions.
+ *
+ * Standalone implementation — cannot import from @company/ui since
+ * the CLI is a separately published npm package.
+ */
+export interface FuzzyMatch {
+    name: string;
+    score: number;
+}
+/**
+ * Search a list of names for fuzzy matches against the given query.
+ * Returns matches sorted by score (descending), filtered to score > minScore.
+ */
+export declare function fuzzySearchNames(query: string, names: string[], minScore?: number): FuzzyMatch[];
+//# sourceMappingURL=fuzzy-search.d.ts.map

package/dist/utils/fuzzy-search.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"fuzzy-search.d.ts","sourceRoot":"","sources":["../../src/utils/fuzzy-search.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AA6BH,MAAM,WAAW,UAAU;IACzB,IAAI,EAAE,MAAM,CAAC;IACb,KAAK,EAAE,MAAM,CAAC;CACf;AAiCD;;;GAGG;AACH,wBAAgB,gBAAgB,CAC9B,KAAK,EAAE,MAAM,EACb,KAAK,EAAE,MAAM,EAAE,EACf,QAAQ,SAAM,GACb,UAAU,EAAE,CAWd"}

package/dist/utils/fuzzy-search.js

@@ -0,0 +1,67 @@
+/**
+ * Lightweight fuzzy search for CLI component name suggestions.
+ *
+ * Standalone implementation — cannot import from @company/ui since
+ * the CLI is a separately published npm package.
+ */
+/**
+ * Compute Levenshtein distance between two strings.
+ */
+function levenshtein(a, b) {
+    const m = a.length;
+    const n = b.length;
+    const dp = Array.from({ length: m + 1 }, () => Array.from({ length: n + 1 }, () => 0));
+    for (let i = 0; i <= m; i++)
+        dp[i][0] = i;
+    for (let j = 0; j <= n; j++)
+        dp[0][j] = j;
+    for (let i = 1; i <= m; i++) {
+        for (let j = 1; j <= n; j++) {
+            const cost = a[i - 1] === b[j - 1] ? 0 : 1;
+            dp[i][j] = Math.min(dp[i - 1][j] + 1, dp[i][j - 1] + 1, dp[i - 1][j - 1] + cost);
+        }
+    }
+    return dp[m][n];
+}
+/**
+ * Score a query against a target name. Returns a value between 0 and 1,
+ * where 1 is a perfect match.
+ *
+ * Combines Levenshtein distance with substring bonus so that both typos
+ * ("buton" -> "button") and partial names ("btn" substring of "button")
+ * are surfaced.
+ */
+function scoreMatch(query, target) {
+    const q = query.toLowerCase();
+    const t = target.toLowerCase();
+    // Exact match
+    if (q === t)
+        return 1;
+    // Levenshtein-based score (normalized by the longer string)
+    const maxLen = Math.max(q.length, t.length);
+    const dist = levenshtein(q, t);
+    const levScore = 1 - dist / maxLen;
+    // Substring bonus: if the query is contained in the target (or vice versa)
+    let substringScore = 0;
+    if (t.includes(q)) {
+        substringScore = q.length / t.length;
+    }
+    else if (q.includes(t)) {
+        substringScore = t.length / q.length * 0.8;
+    }
+    return Math.max(levScore, substringScore);
+}
+/**
+ * Search a list of names for fuzzy matches against the given query.
+ * Returns matches sorted by score (descending), filtered to score > minScore.
+ */
+export function fuzzySearchNames(query, names, minScore = 0.4) {
+    const results = [];
+    for (const name of names) {
+        const score = scoreMatch(query, name);
+        if (score > minScore) {
+            results.push({ name, score: Math.round(score * 100) / 100 });
+        }
+    }
+    return results.sort((a, b) => b.score - a.score);
+}

package/dist/utils/paths.d.ts

@@ -0,0 +1,26 @@
+import type { ComponentsJsonFile } from "../commands/status.js";
+/**
+ * Resolve an alias stored in `components.json` (e.g. "@/components/ui" or
+ * "app/components/ui") to an actual directory relative to the project root.
+ *
+ * Rules:
+ * 1. If the value starts with a known alias prefix (`@/`, `~/`, `$/`),
+ *    substitute it with `layout.sourceRoot` from `components.json`.
+ *    This preserves backwards compatibility with legacy configs that
+ *    stored `@/...` aliases and assumed `src/` as the source root.
+ * 2. If the value does not start with a known prefix, it's already a
+ *    filesystem-relative path and is returned unchanged. This is the
+ *    preferred format going forward — `init` now writes raw paths.
+ *
+ * When `layout` is missing (pre-1.3.0 `components.json` files), the
+ * fallback is `sourceRoot = "src"`, which matches the hardcoded behaviour
+ * the CLI shipped with before this refactor.
+ */
+export declare function resolveLocalDir(alias: string, componentsJson: Pick<ComponentsJsonFile, "layout">): string;
+/**
+ * Get the source root directory to use for project-level files like
+ * `lib/cn.ts` and `styles/tokens/`. Falls back to `"src"` for legacy
+ * `components.json` files without a `layout` field.
+ */
+export declare function getSourceRoot(componentsJson: Pick<ComponentsJsonFile, "layout">): string;
+//# sourceMappingURL=paths.d.ts.map

package/dist/utils/paths.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"paths.d.ts","sourceRoot":"","sources":["../../src/utils/paths.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,uBAAuB,CAAC;AAIhE;;;;;;;;;;;;;;;;GAgBG;AACH,wBAAgB,eAAe,CAC7B,KAAK,EAAE,MAAM,EACb,cAAc,EAAE,IAAI,CAAC,kBAAkB,EAAE,QAAQ,CAAC,GACjD,MAAM,CAQR;AAED;;;;GAIG;AACH,wBAAgB,aAAa,CAC3B,cAAc,EAAE,IAAI,CAAC,kBAAkB,EAAE,QAAQ,CAAC,GACjD,MAAM,CAER"}

package/dist/utils/paths.js

@@ -0,0 +1,35 @@
+const KNOWN_PREFIXES = ["@/", "~/", "$/"];
+/**
+ * Resolve an alias stored in `components.json` (e.g. "@/components/ui" or
+ * "app/components/ui") to an actual directory relative to the project root.
+ *
+ * Rules:
+ * 1. If the value starts with a known alias prefix (`@/`, `~/`, `$/`),
+ *    substitute it with `layout.sourceRoot` from `components.json`.
+ *    This preserves backwards compatibility with legacy configs that
+ *    stored `@/...` aliases and assumed `src/` as the source root.
+ * 2. If the value does not start with a known prefix, it's already a
+ *    filesystem-relative path and is returned unchanged. This is the
+ *    preferred format going forward — `init` now writes raw paths.
+ *
+ * When `layout` is missing (pre-1.3.0 `components.json` files), the
+ * fallback is `sourceRoot = "src"`, which matches the hardcoded behaviour
+ * the CLI shipped with before this refactor.
+ */
+export function resolveLocalDir(alias, componentsJson) {
+    for (const prefix of KNOWN_PREFIXES) {
+        if (alias.startsWith(prefix)) {
+            const sourceRoot = componentsJson.layout?.sourceRoot ?? "src";
+            return `${sourceRoot}/${alias.slice(prefix.length)}`;
+        }
+    }
+    return alias;
+}
+/**
+ * Get the source root directory to use for project-level files like
+ * `lib/cn.ts` and `styles/tokens/`. Falls back to `"src"` for legacy
+ * `components.json` files without a `layout` field.
+ */
+export function getSourceRoot(componentsJson) {
+    return componentsJson.layout?.sourceRoot ?? "src";
+}

package/dist/utils/registry-config.d.ts

@@ -0,0 +1,27 @@
+import type { Registry, RegistryAuth } from "../types/registry.js";
+/**
+ * Load the list of configured registries from `components.json`.
+ *
+ * Backward compatible: if only the legacy `registrySource` field is
+ * present, it is transparently upgraded in-memory to a single-entry
+ * `registries` array (without rewriting the file).
+ */
+export declare function loadRegistries(cwd: string): Promise<Registry[]>;
+/** Pick the registry to use when a component name has no namespace. */
+export declare function getDefaultRegistry(registries: Registry[]): Registry | undefined;
+/** Look up a registry by its alias. */
+export declare function getRegistryByName(registries: Registry[], name: string): Registry | undefined;
+/**
+ * Resolve a bearer token from auth config. Checks env var first, then
+ * token file. Returns null (never the literal string "null") when no
+ * token is configured or reachable — callers decide whether that is
+ * fatal for their source type.
+ */
+export declare function resolveToken(auth: RegistryAuth | undefined): string | null;
+/**
+ * Persist a new `registries` array to `components.json`. If the file
+ * previously only had a legacy `registrySource`, that field is removed
+ * (it has been migrated into the array).
+ */
+export declare function saveRegistries(cwd: string, registries: Registry[]): void;
+//# sourceMappingURL=registry-config.d.ts.map

package/dist/utils/registry-config.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"registry-config.d.ts","sourceRoot":"","sources":["../../src/utils/registry-config.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,QAAQ,EAAE,YAAY,EAAE,MAAM,sBAAsB,CAAC;AAmBnE;;;;;;GAMG;AACH,wBAAsB,cAAc,CAAC,GAAG,EAAE,MAAM,GAAG,OAAO,CAAC,QAAQ,EAAE,CAAC,CAwBrE;AAED,uEAAuE;AACvE,wBAAgB,kBAAkB,CAChC,UAAU,EAAE,QAAQ,EAAE,GACrB,QAAQ,GAAG,SAAS,CAGtB;AAED,uCAAuC;AACvC,wBAAgB,iBAAiB,CAC/B,UAAU,EAAE,QAAQ,EAAE,EACtB,IAAI,EAAE,MAAM,GACX,QAAQ,GAAG,SAAS,CAEtB;AAED;;;;;GAKG;AACH,wBAAgB,YAAY,CAAC,IAAI,EAAE,YAAY,GAAG,SAAS,GAAG,MAAM,GAAG,IAAI,CAc1E;AAED;;;;GAIG;AACH,wBAAgB,cAAc,CAAC,GAAG,EAAE,MAAM,EAAE,UAAU,EAAE,QAAQ,EAAE,GAAG,IAAI,CAkBxE"}

package/dist/utils/registry-config.js

@@ -0,0 +1,94 @@
+import { existsSync, readFileSync, writeFileSync } from "node:fs";
+import { join } from "node:path";
+function readRaw(cwd) {
+    const path = join(cwd, "components.json");
+    if (!existsSync(path))
+        return null;
+    const raw = readFileSync(path, "utf8");
+    return { path, data: JSON.parse(raw) };
+}
+/**
+ * Load the list of configured registries from `components.json`.
+ *
+ * Backward compatible: if only the legacy `registrySource` field is
+ * present, it is transparently upgraded in-memory to a single-entry
+ * `registries` array (without rewriting the file).
+ */
+export async function loadRegistries(cwd) {
+    const raw = readRaw(cwd);
+    if (!raw)
+        return [];
+    const { data } = raw;
+    if (Array.isArray(data.registries) && data.registries.length > 0) {
+        return data.registries;
+    }
+    if (typeof data.registrySource === "string" && data.registrySource.length > 0) {
+        const legacy = data.registrySource === "local"
+            ? { name: "default", source: "local", default: true, path: "packages/ui" }
+            : {
+                name: "default",
+                source: "git",
+                default: true,
+                url: data.registrySource,
+                branch: "main",
+            };
+        return [legacy];
+    }
+    return [];
+}
+/** Pick the registry to use when a component name has no namespace. */
+export function getDefaultRegistry(registries) {
+    if (registries.length === 0)
+        return undefined;
+    return registries.find((r) => r.default) ?? registries[0];
+}
+/** Look up a registry by its alias. */
+export function getRegistryByName(registries, name) {
+    return registries.find((r) => r.name === name);
+}
+/**
+ * Resolve a bearer token from auth config. Checks env var first, then
+ * token file. Returns null (never the literal string "null") when no
+ * token is configured or reachable — callers decide whether that is
+ * fatal for their source type.
+ */
+export function resolveToken(auth) {
+    if (!auth || auth.type !== "bearer")
+        return null;
+    if (auth.tokenEnv) {
+        const v = process.env[auth.tokenEnv];
+        if (v && v.length > 0)
+            return v;
+    }
+    if (auth.tokenFile) {
+        try {
+            return readFileSync(auth.tokenFile, "utf8").trim();
+        }
+        catch {
+            return null;
+        }
+    }
+    return null;
+}
+/**
+ * Persist a new `registries` array to `components.json`. If the file
+ * previously only had a legacy `registrySource`, that field is removed
+ * (it has been migrated into the array).
+ */
+export function saveRegistries(cwd, registries) {
+    const raw = readRaw(cwd);
+    if (!raw) {
+        throw new Error("No components.json found. Run `inai-ui init` first before managing registries.");
+    }
+    const { path, data } = raw;
+    data.registries = registries;
+    // Keep legacy field only if it still matches the first registry's url;
+    // otherwise drop it so it doesn't confuse future migrations.
+    if (data.registrySource && registries.length > 0) {
+        const first = registries[0];
+        if (first.url !== data.registrySource && first.path !== data.registrySource) {
+            delete data.registrySource;
+        }
+    }
+    writeFileSync(path, JSON.stringify(data, null, 2) + "\n", "utf8");
+}

package/dist/utils/registry-resolver.d.ts

@@ -1,4 +1,30 @@
+import type { Registry, ResolveRegistryOptions } from "../types/registry.js";
 export declare function getCacheDir(): string;
+export declare function getRegistryCacheDir(name: string): string;
+/**
+ * Clone (or fast-forward) a git registry into the legacy single-cache
+ * directory. Preserved for backward compatibility with the v0.5.0
+ * code path that called this directly.
+ */
 export declare function cloneRegistry(repoUrl: string): string;
+/**
+ * Resolve a single named registry to a local directory. This is the
+ * M3 multi-registry entry point — callers pass a `Registry` record
+ * from `components.json` and get back a filesystem path where the
+ * `registry.json` and any component source files live.
+ *
+ * - `local`: returns the absolute path to the project-local registry.
+ * - `git`:   clones/pulls into `~/.inai-ui/registries/<name>/`.
+ * - `https`: downloads `registry.json` into the same cache directory.
+ *
+ * When `options.offline` is true, never touches the network; throws a
+ * clear error if the cache does not exist.
+ */
+export declare function resolveRegistry(registry: Registry, projectDir: string, options?: ResolveRegistryOptions): Promise<string>;
+/**
+ * Legacy single-registry resolver kept for backward compatibility with
+ * v0.5.0 callers (status, list, diff, theme). New code paths that
+ * need multi-registry support should call `resolveRegistry` directly.
+ */
 export declare function resolveRegistryDir(projectDir: string): string;
 //# sourceMappingURL=registry-resolver.d.ts.map

package/dist/utils/registry-resolver.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"registry-resolver.d.ts","sourceRoot":"","sources":["../../src/utils/registry-resolver.ts"],"names":[],"mappings":"AASA,wBAAgB,WAAW,IAAI,MAAM,CAEpC;AAED,wBAAgB,aAAa,CAAC,OAAO,EAAE,MAAM,GAAG,MAAM,CAWrD;AAED,wBAAgB,kBAAkB,CAAC,UAAU,EAAE,MAAM,GAAG,MAAM,CAS7D"}
+{"version":3,"file":"registry-resolver.d.ts","sourceRoot":"","sources":["../../src/utils/registry-resolver.ts"],"names":[],"mappings":"AAKA,OAAO,KAAK,EAAE,QAAQ,EAAE,sBAAsB,EAAE,MAAM,sBAAsB,CAAC;AAS7E,wBAAgB,WAAW,IAAI,MAAM,CAEpC;AAED,wBAAgB,mBAAmB,CAAC,IAAI,EAAE,MAAM,GAAG,MAAM,CAExD;AAED;;;;GAIG;AACH,wBAAgB,aAAa,CAAC,OAAO,EAAE,MAAM,GAAG,MAAM,CAWrD;AAmBD;;;;;;;;;;;;GAYG;AACH,wBAAsB,eAAe,CACnC,QAAQ,EAAE,QAAQ,EAClB,UAAU,EAAE,MAAM,EAClB,OAAO,GAAE,sBAA2B,GACnC,OAAO,CAAC,MAAM,CAAC,CAkGjB;AAED;;;;GAIG;AACH,wBAAgB,kBAAkB,CAAC,UAAU,EAAE,MAAM,GAAG,MAAM,CAS7D"}

package/dist/utils/registry-resolver.js

@@ -3,31 +3,155 @@ import fs from "node:fs";
 import path from "node:path";
 import os from "node:os";
 import { readComponentsJson } from "../commands/status.js";
+import { resolveToken } from "./registry-config.js";
 const CACHE_BASE = path.join(os.homedir(), ".inai-ui");
-const CACHE_DIR = path.join(CACHE_BASE, "registry");
+/** Legacy single-registry cache (v0.5.0 and earlier). */
+const LEGACY_CACHE_DIR = path.join(CACHE_BASE, "registry");
+/** New multi-registry cache root — one subdir per named registry. */
+const REGISTRIES_CACHE_DIR = path.join(CACHE_BASE, "registries");
 export function getCacheDir() {
-    return CACHE_DIR;
+    return LEGACY_CACHE_DIR;
 }
+export function getRegistryCacheDir(name) {
+    return path.join(REGISTRIES_CACHE_DIR, name);
+}
+/**
+ * Clone (or fast-forward) a git registry into the legacy single-cache
+ * directory. Preserved for backward compatibility with the v0.5.0
+ * code path that called this directly.
+ */
 export function cloneRegistry(repoUrl) {
-    if (fs.existsSync(path.join(CACHE_DIR, ".git"))) {
-        execSync("git pull --ff-only", { cwd: CACHE_DIR, stdio: "pipe" });
+    if (fs.existsSync(path.join(LEGACY_CACHE_DIR, ".git"))) {
+        execSync("git pull --ff-only", { cwd: LEGACY_CACHE_DIR, stdio: "pipe" });
     }
     else {
         fs.mkdirSync(CACHE_BASE, { recursive: true });
-        if (fs.existsSync(CACHE_DIR)) {
-            fs.rmSync(CACHE_DIR, { recursive: true });
+        if (fs.existsSync(LEGACY_CACHE_DIR)) {
+            fs.rmSync(LEGACY_CACHE_DIR, { recursive: true });
+        }
+        execSync(`git clone "${repoUrl}" "${LEGACY_CACHE_DIR}"`, { stdio: "pipe" });
+    }
+    return LEGACY_CACHE_DIR;
+}
+/**
+ * Embed a bearer token into an HTTPS git URL so `git clone` picks it
+ * up via the in-URL credential form. We never log the resulting URL
+ * (it contains the token) and only use this in-process.
+ */
+function embedTokenInGitUrl(url, token) {
+    try {
+        const u = new URL(url);
+        if (u.protocol !== "https:")
+            return url;
+        u.username = "oauth2";
+        u.password = token;
+        return u.toString();
+    }
+    catch {
+        return url;
+    }
+}
+/**
+ * Resolve a single named registry to a local directory. This is the
+ * M3 multi-registry entry point — callers pass a `Registry` record
+ * from `components.json` and get back a filesystem path where the
+ * `registry.json` and any component source files live.
+ *
+ * - `local`: returns the absolute path to the project-local registry.
+ * - `git`:   clones/pulls into `~/.inai-ui/registries/<name>/`.
+ * - `https`: downloads `registry.json` into the same cache directory.
+ *
+ * When `options.offline` is true, never touches the network; throws a
+ * clear error if the cache does not exist.
+ */
+export async function resolveRegistry(registry, projectDir, options = {}) {
+    const { offline = false } = options;
+    if (registry.source === "local") {
+        const localPath = registry.path
+            ? path.isAbsolute(registry.path)
+                ? registry.path
+                : path.join(projectDir, registry.path)
+            : projectDir;
+        return localPath;
+    }
+    const cacheDir = getRegistryCacheDir(registry.name);
+    if (registry.source === "git") {
+        if (!registry.url) {
+            throw new Error(`Registry "${registry.name}" has source "git" but no url.`);
+        }
+        if (offline) {
+            if (!fs.existsSync(path.join(cacheDir, ".git"))) {
+                throw new Error(`Offline mode: no cached copy of registry "${registry.name}" at ${cacheDir}. Run without --offline first to populate the cache.`);
+            }
+            return cacheDir;
+        }
+        const token = resolveToken(registry.auth);
+        const cloneUrl = token ? embedTokenInGitUrl(registry.url, token) : registry.url;
+        const branch = registry.branch ?? "main";
+        if (fs.existsSync(path.join(cacheDir, ".git"))) {
+            try {
+                execSync("git pull --ff-only", { cwd: cacheDir, stdio: "pipe" });
+            }
+            catch {
+                // If pull fails (network hiccup, diverged), fall back to cached copy.
+            }
+        }
+        else {
+            fs.mkdirSync(REGISTRIES_CACHE_DIR, { recursive: true });
+            if (fs.existsSync(cacheDir)) {
+                fs.rmSync(cacheDir, { recursive: true });
+            }
+            execSync(`git clone --branch "${branch}" "${cloneUrl}" "${cacheDir}"`, { stdio: "pipe" });
+        }
+        return cacheDir;
+    }
+    if (registry.source === "https") {
+        if (!registry.url) {
+            throw new Error(`Registry "${registry.name}" has source "https" but no url.`);
+        }
+        const cachedJson = path.join(cacheDir, "registry.json");
+        if (offline) {
+            if (!fs.existsSync(cachedJson)) {
+                throw new Error(`Offline mode: no cached copy of registry "${registry.name}" at ${cachedJson}.`);
+            }
+            return cacheDir;
+        }
+        const token = resolveToken(registry.auth);
+        const headers = { Accept: "application/json" };
+        if (token)
+            headers.Authorization = `Bearer ${token}`;
+        try {
+            const res = await fetch(registry.url, { headers });
+            if (!res.ok) {
+                throw new Error(`HTTP ${res.status} ${res.statusText}`);
+            }
+            const body = await res.text();
+            fs.mkdirSync(cacheDir, { recursive: true });
+            fs.writeFileSync(cachedJson, body, "utf8");
+        }
+        catch (err) {
+            if (!fs.existsSync(cachedJson)) {
+                const reason = err instanceof Error ? err.message : String(err);
+                throw new Error(`Failed to fetch registry "${registry.name}" from ${registry.url}: ${reason}`);
+            }
+            // Fall through to cached copy if fetch failed but we have one.
         }
-        execSync(`git clone "${repoUrl}" "${CACHE_DIR}"`, { stdio: "pipe" });
+        return cacheDir;
     }
-    return CACHE_DIR;
+    throw new Error(`Unknown registry source "${registry.source}" for "${registry.name}".`);
 }
+/**
+ * Legacy single-registry resolver kept for backward compatibility with
+ * v0.5.0 callers (status, list, diff, theme). New code paths that
+ * need multi-registry support should call `resolveRegistry` directly.
+ */
 export function resolveRegistryDir(projectDir) {
     const componentsJson = readComponentsJson(projectDir);
     if (componentsJson?.registrySource) {
-        if (!fs.existsSync(path.join(CACHE_DIR, ".git"))) {
+        if (!fs.existsSync(path.join(LEGACY_CACHE_DIR, ".git"))) {
             cloneRegistry(componentsJson.registrySource);
         }
-        return CACHE_DIR;
+        return LEGACY_CACHE_DIR;
     }
     return projectDir;
 }

package/dist/utils/snapshot.d.ts

@@ -0,0 +1,20 @@
+export declare const SNAPSHOT_DIR = ".inai-ui/snapshots";
+export interface SnapshotFile {
+    /** Path relative to the project root of the local copy at capture time. */
+    localPath: string;
+    /** SHA256 hash of the captured content. */
+    hash: string;
+    /** Full original content captured at install time. */
+    content: string;
+}
+export interface ComponentSnapshot {
+    name: string;
+    version: string;
+    files: Record<string, SnapshotFile>;
+    capturedAt: string;
+}
+export declare function sha256(content: string): string;
+export declare function saveSnapshot(cwd: string, snapshot: ComponentSnapshot): void;
+export declare function loadSnapshot(cwd: string, name: string): ComponentSnapshot | null;
+export declare function deleteSnapshot(cwd: string, name: string): void;
+//# sourceMappingURL=snapshot.d.ts.map

package/dist/utils/snapshot.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"snapshot.d.ts","sourceRoot":"","sources":["../../src/utils/snapshot.ts"],"names":[],"mappings":"AAIA,eAAO,MAAM,YAAY,uBAAuB,CAAC;AAEjD,MAAM,WAAW,YAAY;IAC3B,2EAA2E;IAC3E,SAAS,EAAE,MAAM,CAAC;IAClB,2CAA2C;IAC3C,IAAI,EAAE,MAAM,CAAC;IACb,sDAAsD;IACtD,OAAO,EAAE,MAAM,CAAC;CACjB;AAED,MAAM,WAAW,iBAAiB;IAChC,IAAI,EAAE,MAAM,CAAC;IACb,OAAO,EAAE,MAAM,CAAC;IAChB,KAAK,EAAE,MAAM,CAAC,MAAM,EAAE,YAAY,CAAC,CAAC;IACpC,UAAU,EAAE,MAAM,CAAC;CACpB;AAED,wBAAgB,MAAM,CAAC,OAAO,EAAE,MAAM,GAAG,MAAM,CAE9C;AAMD,wBAAgB,YAAY,CAAC,GAAG,EAAE,MAAM,EAAE,QAAQ,EAAE,iBAAiB,GAAG,IAAI,CAQ3E;AAED,wBAAgB,YAAY,CAC1B,GAAG,EAAE,MAAM,EACX,IAAI,EAAE,MAAM,GACX,iBAAiB,GAAG,IAAI,CAQ1B;AAED,wBAAgB,cAAc,CAAC,GAAG,EAAE,MAAM,EAAE,IAAI,EAAE,MAAM,GAAG,IAAI,CAK9D"}

package/dist/utils/snapshot.js

@@ -0,0 +1,32 @@
+import { createHash } from "node:crypto";
+import fs from "node:fs";
+import path from "node:path";
+export const SNAPSHOT_DIR = ".inai-ui/snapshots";
+export function sha256(content) {
+    return createHash("sha256").update(content).digest("hex");
+}
+function snapshotPath(cwd, name) {
+    return path.join(cwd, SNAPSHOT_DIR, `${name}.json`);
+}
+export function saveSnapshot(cwd, snapshot) {
+    const dir = path.join(cwd, SNAPSHOT_DIR);
+    fs.mkdirSync(dir, { recursive: true });
+    fs.writeFileSync(snapshotPath(cwd, snapshot.name), JSON.stringify(snapshot, null, 2) + "\n", "utf8");
+}
+export function loadSnapshot(cwd, name) {
+    const p = snapshotPath(cwd, name);
+    if (!fs.existsSync(p))
+        return null;
+    try {
+        return JSON.parse(fs.readFileSync(p, "utf8"));
+    }
+    catch {
+        return null;
+    }
+}
+export function deleteSnapshot(cwd, name) {
+    const p = snapshotPath(cwd, name);
+    if (fs.existsSync(p)) {
+        fs.unlinkSync(p);
+    }
+}

package/dist/utils/themes.d.ts

@@ -0,0 +1,17 @@
+/**
+ * Single source of truth for the built-in theme list used by the CLI
+ * (init, theme create, add). The registry on disk may expose more themes
+ * (discovered from packages/tokens/src/themes/*.css), but this list is the
+ * canonical fallback used when no registry is available and for validation.
+ */
+export type ThemeCategory = "brand" | "shadcn" | "creative";
+export interface ThemeInfo {
+    name: string;
+    label: string;
+    category: ThemeCategory;
+    description: string;
+}
+export declare const THEMES: ThemeInfo[];
+export declare const THEME_NAMES: string[];
+export declare function isKnownTheme(name: string): boolean;
+//# sourceMappingURL=themes.d.ts.map

package/dist/utils/themes.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"themes.d.ts","sourceRoot":"","sources":["../../src/utils/themes.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAEH,MAAM,MAAM,aAAa,GAAG,OAAO,GAAG,QAAQ,GAAG,UAAU,CAAC;AAE5D,MAAM,WAAW,SAAS;IACxB,IAAI,EAAE,MAAM,CAAC;IACb,KAAK,EAAE,MAAM,CAAC;IACd,QAAQ,EAAE,aAAa,CAAC;IACxB,WAAW,EAAE,MAAM,CAAC;CACrB;AAED,eAAO,MAAM,MAAM,EAAE,SAAS,EAwC7B,CAAC;AAEF,eAAO,MAAM,WAAW,EAAE,MAAM,EAA8B,CAAC;AAE/D,wBAAgB,YAAY,CAAC,IAAI,EAAE,MAAM,GAAG,OAAO,CAElD"}