voidui-cli 0.1.0

package/README.md

@@ -0,0 +1 @@
+# voidui CLI

package/dist/commands/add.d.ts

@@ -0,0 +1,28 @@
+/**
+ * Add command implementation
+ * Installs components with version tracking
+ */
+interface AddCommandOptions {
+    /**
+     * Add tracking to existing component without reinstalling
+     */
+    scan?: boolean;
+    /**
+     * Force reinstall even if component exists
+     */
+    force?: boolean;
+    /**
+     * Registry URL
+     */
+    registry?: string;
+}
+/**
+ * Main add command handler
+ * Installs a component and tracks it in voidui.lock.json
+ *
+ * @param component - Component name
+ * @param options - Command options
+ */
+export declare function addCommand(component: string | undefined, options: AddCommandOptions): Promise<void>;
+export {};
+//# sourceMappingURL=add.d.ts.map

package/dist/commands/add.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"add.d.ts","sourceRoot":"","sources":["../../src/commands/add.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAcH,UAAU,iBAAiB;IACzB;;OAEG;IACH,IAAI,CAAC,EAAE,OAAO,CAAC;IAEf;;OAEG;IACH,KAAK,CAAC,EAAE,OAAO,CAAC;IAEhB;;OAEG;IACH,QAAQ,CAAC,EAAE,MAAM,CAAC;CACnB;AAID;;;;;;GAMG;AACH,wBAAsB,UAAU,CAC9B,SAAS,EAAE,MAAM,GAAG,SAAS,EAC7B,OAAO,EAAE,iBAAiB,GACzB,OAAO,CAAC,IAAI,CAAC,CA8If"}

package/dist/commands/add.js

@@ -0,0 +1,104 @@
+/**
+ * Add command implementation
+ * Installs components with version tracking
+ */
+import chalk from "chalk";
+import { locateComponent } from "../utils/component-locator.js";
+import { computeChecksum } from "../utils/checksum.js";
+import { fetchRegistryItem } from "../utils/registry.js";
+import { execShadcnAdd } from "../utils/shadcn.js";
+import { readOrCreateLockFile, writeLockFile, updateComponentEntry, isComponentTracked, } from "../utils/lock-file.js";
+const DEFAULT_REGISTRY_URL = "https://voidui.dev/r";
+/**
+ * Main add command handler
+ * Installs a component and tracks it in voidui.lock.json
+ *
+ * @param component - Component name
+ * @param options - Command options
+ */
+export async function addCommand(component, options) {
+    const registryUrl = options.registry || DEFAULT_REGISTRY_URL;
+    const cwd = process.cwd();
+    // Validate component name
+    if (!component) {
+        console.error(chalk.red("❌ Component name is required"));
+        console.error(chalk.gray("\nUsage:"));
+        console.error(chalk.gray("  voidui add <component>"));
+        console.error(chalk.gray("  voidui add <component> --scan"));
+        console.error(chalk.gray("  voidui add <component> --force"));
+        process.exit(1);
+    }
+    console.log(chalk.blue(`\n📦 Adding ${component}...\n`));
+    // 1. Check if component already exists locally
+    const location = await locateComponent(component, cwd);
+    if (location.exists && !options.scan && !options.force) {
+        console.error(chalk.red(`❌ Component "${component}" already exists in your project`));
+        console.error(chalk.gray(`   Location: ${location.path}`));
+        console.error(chalk.gray("\n   Use --scan to add version tracking without reinstalling"));
+        console.error(chalk.gray("   Use --force to reinstall and update tracking"));
+        process.exit(1);
+    }
+    // 2. Fetch registry metadata to get current version
+    console.log(chalk.gray("Fetching registry metadata..."));
+    const registryItem = await fetchRegistryItem(component, registryUrl);
+    if (!registryItem) {
+        console.error(chalk.red(`❌ Component "${component}" not found in registry`));
+        console.error(chalk.gray(`   Registry: ${registryUrl}`));
+        console.error(chalk.gray(`   Available at: ${registryUrl.replace("/r", "/components")}`));
+        process.exit(1);
+    }
+    const versioning = registryItem.meta?.versioning;
+    if (!versioning) {
+        console.error(chalk.red(`❌ Component "${component}" does not have version tracking enabled`));
+        process.exit(1);
+    }
+    const currentVersion = versioning.currentVersion;
+    // 3. Install component via shadcn if needed
+    if (!options.scan) {
+        try {
+            await execShadcnAdd(component, { registryUrl });
+        }
+        catch (error) {
+            console.error(chalk.red("\n❌ Installation failed:"));
+            console.error(error instanceof Error ? error.message : String(error));
+            process.exit(1);
+        }
+    }
+    // 4. Locate the installed component
+    const componentLocation = await locateComponent(component, cwd);
+    if (!componentLocation.exists) {
+        console.error(chalk.red(`❌ Component was not installed at expected location`));
+        console.error(chalk.gray(`   Expected: ${componentLocation.path}`));
+        console.error(chalk.gray("\n   This might be a configuration issue."));
+        console.error(chalk.gray("   Check your components.json or project structure."));
+        process.exit(1);
+    }
+    // 5. Compute checksum of installed file
+    console.log(chalk.gray("Computing checksum..."));
+    const checksum = await computeChecksum(componentLocation.path);
+    // 6. Read or create lock file
+    const lockFile = await readOrCreateLockFile(cwd);
+    // Check if already tracked
+    if (isComponentTracked(lockFile, component) && !options.force) {
+        console.log(chalk.yellow(`⚠️  Component "${component}" is already tracked in lock file`));
+        console.log(chalk.gray("   Use --force to update the tracking information"));
+        return;
+    }
+    // 7. Update lock file
+    const updatedLockFile = updateComponentEntry(lockFile, component, {
+        installedVersion: currentVersion,
+        installedAt: new Date().toISOString(),
+        checksum: checksum,
+        registryUrl: registryUrl,
+    });
+    await writeLockFile(cwd, updatedLockFile);
+    // 8. Success message
+    console.log(chalk.green(`\n✓ Added ${component}@${currentVersion} with version tracking`));
+    console.log(chalk.gray(`  Checksum: ${checksum.substring(0, 20)}...`));
+    console.log(chalk.gray(`  Location: ${componentLocation.path}`));
+    if (options.scan) {
+        console.log(chalk.yellow("\n  Note: Existing component was scanned. Checksum reflects current state."));
+    }
+    console.log(chalk.gray(`\nRun \`voidui diff ${component}\` to check for updates`));
+    console.log("");
+}

package/dist/commands/augment.d.ts

@@ -0,0 +1,2 @@
+export declare function augmentCommand(): Promise<void>;
+//# sourceMappingURL=augment.d.ts.map

package/dist/commands/augment.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"augment.d.ts","sourceRoot":"","sources":["../../src/commands/augment.ts"],"names":[],"mappings":"AA2CA,wBAAsB,cAAc,IAAI,OAAO,CAAC,IAAI,CAAC,CA4HpD"}

package/dist/commands/augment.js

@@ -0,0 +1,97 @@
+import path from "path";
+import chalk from "chalk";
+import { glob } from "glob";
+import { fileExists, readJsonFile, writeJsonFile, readDir, } from "../utils/file-operations.js";
+export async function augmentCommand() {
+    console.log(chalk.blue("\n🔧 Augmenting registry with versioning metadata...\n"));
+    const cwd = process.cwd();
+    // Detect if running from monorepo root or www-docs
+    let registryPath;
+    let outputPath;
+    if (await fileExists(path.join(cwd, "registry/components/ui"))) {
+        // Running from www-docs
+        registryPath = path.join(cwd, "registry/components/ui");
+        outputPath = path.join(cwd, "public/r");
+    }
+    else {
+        // Running from monorepo root
+        registryPath = path.join(cwd, "apps/www-docs/registry/components/ui");
+        outputPath = path.join(cwd, "apps/www-docs/public/r");
+    }
+    // Check if output directory exists
+    if (!(await fileExists(outputPath))) {
+        console.error(chalk.red('❌ Registry output not found. Run "pnpm registry:build:raw" first.'));
+        process.exit(1);
+    }
+    let augmentedCount = 0;
+    // Find all changelog files
+    const changelogPattern = path.join(registryPath, "*.changelog.json");
+    const changelogFiles = await glob(changelogPattern.replace(/\\/g, "/"));
+    for (const changelogFilePath of changelogFiles) {
+        const componentName = path
+            .basename(changelogFilePath)
+            .replace(".changelog.json", "");
+        // Read changelog
+        const changelog = await readJsonFile(changelogFilePath);
+        if (!changelog) {
+            console.warn(chalk.yellow(`⚠️  Could not read changelog for ${componentName}`));
+            continue;
+        }
+        // Find available versions
+        const versionsDir = path.join(registryPath, `${componentName}.versions`);
+        let availableVersions = [];
+        if (await fileExists(versionsDir)) {
+            const files = await readDir(versionsDir);
+            availableVersions = files
+                .filter((f) => f.endsWith(".tsx"))
+                .map((f) => f.replace(".tsx", ""))
+                .sort((a, b) => {
+                // Semantic version sort (descending)
+                const aParts = a.split(".").map(Number);
+                const bParts = b.split(".").map(Number);
+                for (let i = 0; i < 3; i++) {
+                    const aVal = aParts[i] ?? 0;
+                    const bVal = bParts[i] ?? 0;
+                    if (bVal !== aVal) {
+                        return bVal - aVal;
+                    }
+                }
+                return 0;
+            });
+        }
+        // Read generated registry item
+        const registryItemPath = path.join(outputPath, `${componentName}.json`);
+        const registryItem = await readJsonFile(registryItemPath);
+        if (!registryItem) {
+            console.warn(chalk.yellow(`⚠️  No registry output found for ${componentName}`));
+            continue;
+        }
+        // Augment with meta field
+        registryItem.meta = {
+            versioning: {
+                currentVersion: changelog.currentVersion,
+                changelog,
+                availableVersions,
+            },
+        };
+        // Write back
+        await writeJsonFile(registryItemPath, registryItem);
+        console.log(chalk.green(`✓ Augmented: ${componentName}.json`));
+        augmentedCount++;
+    }
+    // Update main registry.json
+    const mainRegistryPath = path.join(outputPath, "registry.json");
+    const mainRegistry = await readJsonFile(mainRegistryPath);
+    if (mainRegistry && mainRegistry.items) {
+        for (const item of mainRegistry.items) {
+            const itemPath = path.join(outputPath, `${item.name}.json`);
+            const itemData = await readJsonFile(itemPath);
+            if (itemData?.meta) {
+                item.meta = itemData.meta;
+            }
+        }
+        await writeJsonFile(mainRegistryPath, mainRegistry);
+        console.log(chalk.green("✓ Augmented: registry.json"));
+    }
+    console.log(chalk.blue(`\n✨ Augmentation complete! ${augmentedCount} component(s) updated.\n`));
+}

package/dist/commands/diff.d.ts

@@ -0,0 +1,19 @@
+/**
+ * Diff command implementation
+ * Compares local components against registry versions
+ */
+interface DiffCommandOptions {
+    code?: boolean;
+    registry?: string;
+}
+/**
+ * Main diff command handler
+ *
+ * Supports three modes:
+ * 1. `voidui diff separator` - Check local vs latest
+ * 2. `voidui diff separator --code` - Show code diff
+ * 3. `voidui diff separator 1.0.0 1.2.0` - Compare registry versions
+ */
+export declare function diffCommand(component: string | undefined, fromVersion: string | undefined, toVersion: string | undefined, options: DiffCommandOptions): Promise<void>;
+export {};
+//# sourceMappingURL=diff.d.ts.map

package/dist/commands/diff.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"diff.d.ts","sourceRoot":"","sources":["../../src/commands/diff.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAsBH,UAAU,kBAAkB;IAC1B,IAAI,CAAC,EAAE,OAAO,CAAC;IACf,QAAQ,CAAC,EAAE,MAAM,CAAC;CACnB;AAID;;;;;;;GAOG;AACH,wBAAsB,WAAW,CAC/B,SAAS,EAAE,MAAM,GAAG,SAAS,EAC7B,WAAW,EAAE,MAAM,GAAG,SAAS,EAC/B,SAAS,EAAE,MAAM,GAAG,SAAS,EAC7B,OAAO,EAAE,kBAAkB,GAC1B,OAAO,CAAC,IAAI,CAAC,CAsCf"}

package/dist/commands/diff.js

@@ -0,0 +1,233 @@
+/**
+ * Diff command implementation
+ * Compares local components against registry versions
+ */
+import path from "path";
+import chalk from "chalk";
+import { readFile } from "fs/promises";
+import { fileExists, readJsonFile } from "../utils/file-operations.js";
+import { locateComponent } from "../utils/component-locator.js";
+import { computeChecksum, compareChecksums } from "../utils/checksum.js";
+import { fetchRegistryItem, extractComponentCode, fetchComponentVersion, } from "../utils/registry.js";
+import { formatDiff, formatChangelog, formatChangelogSummary, } from "../utils/diff-formatter.js";
+import { lockFileSchema } from "../validators/lock-file.js";
+const DEFAULT_REGISTRY_URL = "https://voidui.dev/r";
+/**
+ * Main diff command handler
+ *
+ * Supports three modes:
+ * 1. `voidui diff separator` - Check local vs latest
+ * 2. `voidui diff separator --code` - Show code diff
+ * 3. `voidui diff separator 1.0.0 1.2.0` - Compare registry versions
+ */
+export async function diffCommand(component, fromVersion, toVersion, options) {
+    const registryUrl = options.registry || DEFAULT_REGISTRY_URL;
+    // Validate component name is provided
+    if (!component) {
+        console.error(chalk.red("❌ Component name is required"));
+        console.error(chalk.gray("\nUsage:"));
+        console.error(chalk.gray("  voidui diff <component>"));
+        console.error(chalk.gray("  voidui diff <component> --code"));
+        console.error(chalk.gray("  voidui diff <component> <from-version> <to-version>"));
+        process.exit(1);
+    }
+    // Determine which mode to run
+    if (fromVersion && toVersion) {
+        // Mode 3: Compare two registry versions
+        await compareRegistryVersions(component, fromVersion, toVersion, registryUrl);
+    }
+    else if (fromVersion && !toVersion) {
+        // Invalid: only one version specified
+        console.error(chalk.red("❌ Both from-version and to-version must be specified"));
+        console.error(chalk.gray("\nUsage:"));
+        console.error(chalk.gray("  voidui diff <component> <from-version> <to-version>"));
+        process.exit(1);
+    }
+    else {
+        // Mode 1 or 2: Check local vs registry
+        await compareLocalVsRegistry(component, registryUrl, options);
+    }
+}
+/**
+ * Mode 1 & 2: Compare local component against registry
+ */
+async function compareLocalVsRegistry(component, registryUrl, options) {
+    const cwd = process.cwd();
+    console.log(chalk.blue(`\n📊 Checking ${component}...\n`));
+    // 1. Locate component in user's project
+    const location = await locateComponent(component, cwd);
+    if (!location.exists) {
+        console.error(chalk.red(`❌ Component "${component}" not found in your project`));
+        console.error(chalk.gray(`   Expected at: ${location.path}`));
+        process.exit(1);
+    }
+    // 2. Read lock file if exists
+    const lockFilePath = path.join(cwd, "voidui.lock.json");
+    const lockFileExists = await fileExists(lockFilePath);
+    let lockFile = null;
+    let installedVersion = null;
+    let expectedChecksum = null;
+    if (lockFileExists) {
+        const rawLockFile = await readJsonFile(lockFilePath);
+        if (rawLockFile) {
+            try {
+                const parsedLockFile = lockFileSchema.parse(rawLockFile);
+                lockFile = parsedLockFile;
+                const entry = parsedLockFile.components[component];
+                if (entry) {
+                    installedVersion = entry.installedVersion;
+                    expectedChecksum = entry.checksum;
+                }
+            }
+            catch (error) {
+                console.error(chalk.yellow("⚠️  Lock file is corrupted. Continuing without version tracking."));
+            }
+        }
+    }
+    // 3. Compute local file checksum
+    const actualChecksum = await computeChecksum(location.path);
+    const isModified = expectedChecksum && !compareChecksums(expectedChecksum, actualChecksum);
+    // 4. Fetch registry metadata
+    const registryItem = await fetchRegistryItem(component, registryUrl);
+    if (!registryItem) {
+        console.error(chalk.red(`❌ Component "${component}" not found in registry`));
+        console.error(chalk.gray(`   Registry: ${registryUrl}`));
+        console.error(chalk.gray(`   Available at: ${registryUrl.replace("/r", "/components")}`));
+        process.exit(1);
+    }
+    const versioning = registryItem.meta?.versioning;
+    if (!versioning) {
+        console.error(chalk.red(`❌ Component "${component}" does not have version tracking enabled`));
+        process.exit(1);
+    }
+    const latestVersion = versioning.currentVersion;
+    // 5. Display version information
+    if (installedVersion) {
+        const modifiedText = isModified ? chalk.yellow(" (modified ⚠️ )") : "";
+        console.log(`Your version:  ${chalk.bold(installedVersion)}${modifiedText}`);
+    }
+    else {
+        if (!lockFileExists) {
+            console.log(chalk.yellow("⚠️  No lock file found. Lock file will be created when you run:"));
+            console.log(chalk.gray(`   voidui add ${component}\n`));
+        }
+        else {
+            console.log(chalk.yellow(`⚠️  Component "${component}" not found in lock file. Install with:`));
+            console.log(chalk.gray(`   voidui add ${component}\n`));
+        }
+    }
+    console.log(`Latest:        ${chalk.bold(latestVersion)}`);
+    // 6. Show code diff if requested
+    if (options.code) {
+        console.log(chalk.blue(`\n📝 Comparing ${installedVersion || "local"} → ${latestVersion}\n`));
+        // Read local file content
+        const localContent = await readFile(location.path, "utf-8");
+        // Get latest version content from registry
+        const latestContent = extractComponentCode(registryItem);
+        // Generate and display diff
+        const diff = formatDiff(localContent, latestContent, `${component}@${installedVersion || "local"}.tsx`, `${component}@${latestVersion}.tsx`);
+        console.log(diff);
+        console.log(""); // Empty line
+        return;
+    }
+    // 7. Show changelog summary if versions differ
+    if (installedVersion && installedVersion !== latestVersion) {
+        console.log(chalk.blue(`\nChanges from ${installedVersion} to ${latestVersion}:\n`));
+        const relevantEntries = getEntriesBetweenVersions(versioning.changelog.entries, installedVersion, latestVersion);
+        if (relevantEntries.length > 0) {
+            for (const entry of relevantEntries) {
+                console.log(formatChangelogSummary(entry));
+            }
+        }
+        else {
+            console.log(chalk.gray("No changelog entries found."));
+        }
+        console.log(chalk.gray(`\nRun \`voidui diff ${component} --code\` to see code changes`));
+        console.log(chalk.gray(`Run \`voidui update ${component}\` to update to latest`));
+    }
+    else if (!installedVersion) {
+        // Show latest version info
+        console.log(chalk.blue("\nLatest changes:\n"));
+        const latestEntry = versioning.changelog.entries[0];
+        if (latestEntry) {
+            console.log(formatChangelogSummary(latestEntry));
+        }
+        console.log(chalk.gray(`\nRun \`voidui diff ${component} --code\` to see code`));
+    }
+    else {
+        // Versions are the same
+        console.log(chalk.green("\n✓ You're on the latest version!"));
+        if (isModified) {
+            console.log(chalk.yellow("\nNote: Your local file has been modified from the installed version."));
+        }
+    }
+    console.log(""); // Empty line
+}
+/**
+ * Mode 3: Compare two registry versions
+ */
+async function compareRegistryVersions(component, fromVersion, toVersion, registryUrl) {
+    console.log(chalk.blue(`\n📊 Comparing ${component} ${fromVersion} → ${toVersion}\n`));
+    // Fetch registry metadata
+    const registryItem = await fetchRegistryItem(component, registryUrl);
+    if (!registryItem) {
+        console.error(chalk.red(`❌ Component "${component}" not found in registry`));
+        console.error(chalk.gray(`   Registry: ${registryUrl}`));
+        process.exit(1);
+    }
+    const versioning = registryItem.meta?.versioning;
+    if (!versioning) {
+        console.error(chalk.red(`❌ Component "${component}" does not have version tracking enabled`));
+        process.exit(1);
+    }
+    // Validate versions exist
+    const availableVersions = versioning.availableVersions;
+    if (!availableVersions.includes(fromVersion)) {
+        console.error(chalk.red(`❌ Version "${fromVersion}" not found for ${component}`));
+        console.error(chalk.gray(`   Available: ${availableVersions.join(", ")}`));
+        process.exit(1);
+    }
+    if (!availableVersions.includes(toVersion)) {
+        console.error(chalk.red(`❌ Version "${toVersion}" not found for ${component}`));
+        console.error(chalk.gray(`   Available: ${availableVersions.join(", ")}`));
+        process.exit(1);
+    }
+    // Show changelog between versions
+    console.log(chalk.blue(`Changes from ${fromVersion} to ${toVersion}:\n`));
+    const changelog = formatChangelog(versioning.changelog.entries, fromVersion, toVersion);
+    console.log(changelog);
+    // Try to fetch code for both versions and show diff
+    const fromContent = await fetchComponentVersion(component, fromVersion, registryUrl);
+    const toContent = await fetchComponentVersion(component, toVersion, registryUrl);
+    if (fromContent && toContent) {
+        console.log(chalk.blue("\n📝 Code changes:\n"));
+        const diff = formatDiff(fromContent, toContent, `${component}@${fromVersion}.tsx`, `${component}@${toVersion}.tsx`);
+        console.log(diff);
+    }
+    else {
+        // Show note about why we can't show code diff
+        console.log(chalk.gray("\nNote: Code diff for historical versions is not yet supported in production."));
+        console.log(chalk.gray("      This feature requires registry infrastructure for version endpoints."));
+        if (registryUrl.includes("localhost")) {
+            console.log(chalk.yellow("\n      For local testing, make sure version files exist at:"));
+            console.log(chalk.gray(`      registry/components/ui/${component}.versions/${fromVersion}.tsx`));
+            console.log(chalk.gray(`      registry/components/ui/${component}.versions/${toVersion}.tsx`));
+        }
+    }
+    console.log(""); // Empty line
+}
+/**
+ * Get changelog entries between two versions
+ */
+function getEntriesBetweenVersions(entries, fromVersion, toVersion) {
+    const fromIndex = entries.findIndex((e) => e.version === fromVersion);
+    const toIndex = entries.findIndex((e) => e.version === toVersion);
+    if (fromIndex === -1 || toIndex === -1) {
+        return [];
+    }
+    // Entries are sorted newest first, extract range between versions
+    const start = Math.min(fromIndex, toIndex);
+    const end = Math.max(fromIndex, toIndex);
+    // Return entries in chronological order (oldest first)
+    return entries.slice(start, end + 1).reverse();
+}

package/dist/commands/index.d.ts

@@ -0,0 +1,3 @@
+export { snapshotCommand } from "./snapshot.js";
+export { augmentCommand } from "./augment.js";
+//# sourceMappingURL=index.d.ts.map

package/dist/commands/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/commands/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,eAAe,EAAE,MAAM,eAAe,CAAC;AAChD,OAAO,EAAE,cAAc,EAAE,MAAM,cAAc,CAAC"}

package/dist/commands/index.js

@@ -0,0 +1,2 @@
+export { snapshotCommand } from "./snapshot.js";
+export { augmentCommand } from "./augment.js";

package/dist/commands/snapshot.d.ts

@@ -0,0 +1,2 @@
+export declare function snapshotCommand(component: string, version: string): Promise<void>;
+//# sourceMappingURL=snapshot.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"snapshot.d.ts","sourceRoot":"","sources":["../../src/commands/snapshot.ts"],"names":[],"mappings":"AAqBA,wBAAsB,eAAe,CACnC,SAAS,EAAE,MAAM,EACjB,OAAO,EAAE,MAAM,GACd,OAAO,CAAC,IAAI,CAAC,CAqHf"}

package/dist/commands/snapshot.js

@@ -0,0 +1,99 @@
+import path from "path";
+import chalk from "chalk";
+import { componentChangelogSchema } from "../validators/changelog.js";
+import { fileExists, readJsonFile, writeJsonFile, copyFile, ensureDir, } from "../utils/file-operations.js";
+import { promptForChange, promptForMore, promptForBreaking, } from "../utils/prompts.js";
+export async function snapshotCommand(component, version) {
+    console.log(chalk.blue(`\n📸 Creating snapshot for ${component}@${version}\n`));
+    // 1. Validate paths
+    const cwd = process.cwd();
+    // Detect if running from monorepo root or www-docs
+    let registryPath;
+    if (await fileExists(path.join(cwd, "registry/components/ui"))) {
+        // Running from www-docs
+        registryPath = path.join(cwd, "registry/components/ui");
+    }
+    else {
+        // Running from monorepo root
+        registryPath = path.join(cwd, "apps/www-docs/registry/components/ui");
+    }
+    const componentFile = path.join(registryPath, `${component}.tsx`);
+    const changelogFile = path.join(registryPath, `${component}.changelog.json`);
+    const versionsDir = path.join(registryPath, `${component}.versions`);
+    // 2. Check component exists
+    if (!(await fileExists(componentFile))) {
+        console.error(chalk.red(`❌ Component "${component}" not found`));
+        console.error(chalk.gray(`   Expected: ${componentFile}`));
+        process.exit(1);
+    }
+    // 3. Validate version format
+    if (!/^\d+\.\d+\.\d+$/.test(version)) {
+        console.error(chalk.red("❌ Version must be in semver format (e.g., 1.0.0)"));
+        process.exit(1);
+    }
+    // 4. Create versions directory if needed
+    await ensureDir(versionsDir);
+    // 5. Check if version already exists
+    const versionFile = path.join(versionsDir, `${version}.tsx`);
+    if (await fileExists(versionFile)) {
+        console.error(chalk.red(`❌ Version ${version} already exists`));
+        console.error(chalk.gray(`   File: ${versionFile}`));
+        process.exit(1);
+    }
+    // 6. Copy component file to versions folder
+    await copyFile(componentFile, versionFile);
+    console.log(chalk.green(`✓ Created snapshot: ${versionFile}`));
+    // 7. Interactive changelog entry
+    console.log(chalk.blue("\n📝 Creating changelog entry...\n"));
+    const changeEntries = [];
+    let addMore = true;
+    while (addMore) {
+        const change = await promptForChange();
+        if (!change) {
+            console.error(chalk.red("\n❌ Cancelled"));
+            process.exit(1);
+        }
+        changeEntries.push(change);
+        if (changeEntries.length > 0) {
+            addMore = await promptForMore("Add another change?");
+        }
+    }
+    const breaking = await promptForBreaking();
+    // 8. Update or create changelog file
+    let changelog = await readJsonFile(changelogFile);
+    if (!changelog) {
+        // Create new changelog
+        changelog = {
+            component,
+            currentVersion: version,
+            entries: [],
+        };
+    }
+    // 9. Add new entry to the beginning
+    const newEntry = {
+        version,
+        date: new Date().toISOString(),
+        changes: changeEntries,
+        ...(breaking && { breaking }),
+    };
+    changelog.entries.unshift(newEntry);
+    changelog.currentVersion = version;
+    // 10. Validate with Zod schema
+    try {
+        componentChangelogSchema.parse(changelog);
+    }
+    catch (error) {
+        console.error(chalk.red("\n❌ Changelog validation failed:"));
+        console.error(error);
+        process.exit(1);
+    }
+    // 11. Write changelog
+    await writeJsonFile(changelogFile, changelog);
+    console.log(chalk.green(`\n✓ Updated changelog: ${changelogFile}`));
+    // 12. Success message with next steps
+    console.log(chalk.blue("\n✨ Snapshot created successfully!\n"));
+    console.log(chalk.gray("Next steps:"));
+    console.log(chalk.gray("  1. Review the changes"));
+    console.log(chalk.gray("  2. Run: pnpm registry:build"));
+    console.log(chalk.gray("  3. Commit the changes\n"));
+}

package/dist/commands/update.d.ts

@@ -0,0 +1,28 @@
+/**
+ * Update command implementation
+ * Updates components with smart merge support
+ */
+interface UpdateCommandOptions {
+    /**
+     * Force overwrite (lose local changes)
+     */
+    force?: boolean;
+    /**
+     * Automatically attempt 3-way merge
+     */
+    merge?: boolean;
+    /**
+     * Registry URL
+     */
+    registry?: string;
+}
+/**
+ * Main update command handler
+ * Updates a component to latest version with merge support
+ *
+ * @param component - Component name
+ * @param options - Command options
+ */
+export declare function updateCommand(component: string | undefined, options: UpdateCommandOptions): Promise<void>;
+export {};
+//# sourceMappingURL=update.d.ts.map

package/dist/commands/update.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"update.d.ts","sourceRoot":"","sources":["../../src/commands/update.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAsBH,UAAU,oBAAoB;IAC5B;;OAEG;IACH,KAAK,CAAC,EAAE,OAAO,CAAC;IAEhB;;OAEG;IACH,KAAK,CAAC,EAAE,OAAO,CAAC;IAEhB;;OAEG;IACH,QAAQ,CAAC,EAAE,MAAM,CAAC;CACnB;AAID;;;;;;GAMG;AACH,wBAAsB,aAAa,CACjC,SAAS,EAAE,MAAM,GAAG,SAAS,EAC7B,OAAO,EAAE,oBAAoB,GAC5B,OAAO,CAAC,IAAI,CAAC,CA2Qf"}