voidui-cli 0.1.0

package/dist/commands/update.js

@@ -0,0 +1,203 @@
+/**
+ * Update command implementation
+ * Updates components with smart merge support
+ */
+import chalk from "chalk";
+import prompts from "prompts";
+import { readFile, writeFile } from "fs/promises";
+import { locateComponent } from "../utils/component-locator.js";
+import { computeChecksum, compareChecksums } from "../utils/checksum.js";
+import { fetchRegistryItem, fetchComponentVersion, extractComponentCode, } from "../utils/registry.js";
+import { readLockFile, writeLockFile, updateComponentEntry, getComponentEntry, } from "../utils/lock-file.js";
+import { threeWayMerge, formatMergeMessage } from "../utils/merge.js";
+import { formatDiff } from "../utils/diff-formatter.js";
+const DEFAULT_REGISTRY_URL = "https://voidui.dev/r";
+/**
+ * Main update command handler
+ * Updates a component to latest version with merge support
+ *
+ * @param component - Component name
+ * @param options - Command options
+ */
+export async function updateCommand(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 update <component>"));
+        console.error(chalk.gray("  voidui update <component> --force"));
+        console.error(chalk.gray("  voidui update <component> --merge"));
+        process.exit(1);
+    }
+    console.log(chalk.blue(`\n🔄 Updating ${component}...\n`));
+    // 1. Read lock file
+    const lockFile = await readLockFile(cwd);
+    if (!lockFile) {
+        console.error(chalk.red("❌ No lock file found"));
+        console.error(chalk.gray("\n   Lock file will be created when you run:"));
+        console.error(chalk.gray(`   voidui add ${component}`));
+        process.exit(1);
+    }
+    const entry = getComponentEntry(lockFile, component);
+    if (!entry) {
+        console.error(chalk.red(`❌ Component "${component}" is not tracked in lock file`));
+        console.error(chalk.gray(`\n   Add tracking with:`));
+        console.error(chalk.gray(`   voidui add ${component} --scan`));
+        process.exit(1);
+    }
+    // 2. Fetch latest version from registry
+    console.log(chalk.gray("Checking for updates..."));
+    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`));
+        process.exit(1);
+    }
+    const latestVersion = versioning.currentVersion;
+    // 3. Locate component file
+    const location = await locateComponent(component, cwd);
+    if (!location.exists) {
+        console.error(chalk.red(`❌ Component file not found at: ${location.path}`));
+        process.exit(1);
+    }
+    // 4. Check for local modifications (even if on latest version)
+    const currentChecksum = await computeChecksum(location.path);
+    const isModified = !compareChecksums(entry.checksum, currentChecksum);
+    // Check if already on latest
+    if (entry.installedVersion === latestVersion) {
+        if (isModified) {
+            console.log(chalk.green(`✓ Already on the latest version (${latestVersion})`));
+            console.log(chalk.yellow("\n⚠️  However, local modifications detected"));
+            console.log(chalk.gray("\n  Your file has been modified since installation."));
+            console.log(chalk.gray("  To reset to the original version, run:"));
+            console.log(chalk.gray(`  voidui add ${component} --force`));
+        }
+        else {
+            console.log(chalk.green(`✓ Already on the latest version (${latestVersion})`));
+        }
+        return;
+    }
+    console.log(chalk.gray(`  Current: ${entry.installedVersion} → Latest: ${latestVersion}`));
+    // Already have location, currentChecksum, isModified from above
+    if (isModified) {
+        console.log(chalk.yellow("\n⚠️  Local modifications detected"));
+    }
+    // 5. Determine update strategy
+    let updateStrategy = "overwrite";
+    if (isModified && !options.force && !options.merge) {
+        // Interactive prompt
+        const response = await prompts({
+            type: "select",
+            name: "strategy",
+            message: "How would you like to update?",
+            choices: [
+                {
+                    title: "Attempt 3-way merge (preserve your changes)",
+                    value: "merge",
+                },
+                {
+                    title: "Overwrite (lose your local changes)",
+                    value: "overwrite",
+                },
+                {
+                    title: "Show diff and abort",
+                    value: "diff",
+                },
+                {
+                    title: "Cancel",
+                    value: "abort",
+                },
+            ],
+            initial: 0,
+        });
+        if (!response.strategy || response.strategy === "abort") {
+            console.log(chalk.gray("\nUpdate cancelled"));
+            return;
+        }
+        if (response.strategy === "diff") {
+            // Show diff and exit
+            const localContent = await readFile(location.path, "utf-8");
+            const latestContent = extractComponentCode(registryItem);
+            const diff = formatDiff(localContent, latestContent, `${component}@${entry.installedVersion}.tsx`, `${component}@${latestVersion}.tsx`);
+            console.log("\n" + diff);
+            console.log(chalk.gray(`\nRun \`voidui update ${component} --merge\` to attempt merge`));
+            console.log(chalk.gray(`Run \`voidui update ${component} --force\` to overwrite`));
+            return;
+        }
+        updateStrategy = response.strategy;
+    }
+    else if (options.force) {
+        updateStrategy = "overwrite";
+    }
+    else if (options.merge) {
+        updateStrategy = "merge";
+    }
+    // 6. Perform update
+    let newContent;
+    let mergeSuccess = true;
+    if (updateStrategy === "merge" && isModified) {
+        // 3-way merge
+        console.log(chalk.gray("\n  Performing 3-way merge..."));
+        const baseContent = await fetchComponentVersion(component, entry.installedVersion, registryUrl);
+        const oursContent = await readFile(location.path, "utf-8");
+        const theirsContent = extractComponentCode(registryItem);
+        if (!baseContent) {
+            console.error(chalk.yellow(`\n⚠️  Could not fetch base version (${entry.installedVersion})`));
+            console.error(chalk.gray("   Falling back to overwrite. Use --force to confirm."));
+            const confirmResponse = await prompts({
+                type: "confirm",
+                name: "overwrite",
+                message: "Overwrite local file with latest version?",
+                initial: false,
+            });
+            if (!confirmResponse.overwrite) {
+                console.log(chalk.gray("\nUpdate cancelled"));
+                return;
+            }
+            newContent = theirsContent;
+        }
+        else {
+            const mergeResult = threeWayMerge(baseContent, oursContent, theirsContent, {
+                ours: "your changes",
+                theirs: `v${latestVersion}`,
+            });
+            newContent = mergeResult.content;
+            mergeSuccess = mergeResult.success;
+            console.log(formatMergeMessage(mergeResult, location.path));
+        }
+    }
+    else {
+        // Simple overwrite
+        newContent = extractComponentCode(registryItem);
+        if (isModified) {
+            console.log(chalk.yellow("\n⚠️  Overwriting local changes with latest version"));
+        }
+    }
+    // 7. Write updated content
+    await writeFile(location.path, newContent, "utf-8");
+    // 8. Update lock file
+    const newChecksum = await computeChecksum(location.path);
+    const updatedLockFile = updateComponentEntry(lockFile, component, {
+        ...entry,
+        installedVersion: latestVersion,
+        installedAt: new Date().toISOString(),
+        checksum: newChecksum,
+    });
+    await writeLockFile(cwd, updatedLockFile);
+    // 9. Success message
+    if (mergeSuccess) {
+        console.log(chalk.green(`\n✓ Updated ${component} from ${entry.installedVersion} to ${latestVersion}`));
+        console.log(chalk.gray(`  Location: ${location.path}`));
+    }
+    else {
+        console.log(chalk.yellow(`\n⚠️  Updated ${component} with conflicts. Please resolve manually.`));
+    }
+    console.log("");
+}

package/dist/index.d.ts

@@ -0,0 +1,3 @@
+#!/usr/bin/env node
+export {};
+//# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":""}

package/dist/index.js

@@ -0,0 +1,89 @@
+#!/usr/bin/env node
+import { Command } from "commander";
+import { snapshotCommand } from "./commands/snapshot.js";
+import { augmentCommand } from "./commands/augment.js";
+import { diffCommand } from "./commands/diff.js";
+import { addCommand } from "./commands/add.js";
+import { updateCommand } from "./commands/update.js";
+import pkg from "../package.json" with { type: "json" };
+const program = new Command();
+program
+    .name("voidui")
+    .description("CLI tools for voidui component versioning")
+    .version(pkg.version);
+program
+    .command("snapshot")
+    .description("Create a version snapshot of a component")
+    .argument("<component>", "Component name (e.g., separator)")
+    .argument("<version>", "Version number in semver format (e.g., 1.0.0)")
+    .action(async (component, version) => {
+    try {
+        await snapshotCommand(component, version);
+    }
+    catch (error) {
+        console.error("Error:", error);
+        process.exit(1);
+    }
+});
+program
+    .command("augment")
+    .description("Augment registry output with versioning metadata")
+    .action(async () => {
+    try {
+        await augmentCommand();
+    }
+    catch (error) {
+        console.error("Error:", error);
+        process.exit(1);
+    }
+});
+program
+    .command("diff")
+    .description("Compare local components against registry versions")
+    .argument("[component]", "Component name (e.g., separator)")
+    .argument("[from-version]", "Source version (optional)")
+    .argument("[to-version]", "Target version (optional)")
+    .option("--code", "Show full code diff with syntax highlighting")
+    .option("--registry <url>", "Registry URL", "https://voidui.dev/r")
+    .action(async (component, fromVersion, toVersion, options) => {
+    try {
+        await diffCommand(component, fromVersion, toVersion, options);
+    }
+    catch (error) {
+        console.error("Error:", error);
+        process.exit(1);
+    }
+});
+program
+    .command("add")
+    .description("Install a component with version tracking")
+    .argument("[component]", "Component name (e.g., separator)")
+    .option("--scan", "Add tracking to existing component without reinstalling")
+    .option("--force", "Reinstall and update lock file")
+    .option("--registry <url>", "Registry URL", "https://voidui.dev/r")
+    .action(async (component, options) => {
+    try {
+        await addCommand(component, options);
+    }
+    catch (error) {
+        console.error("Error:", error);
+        process.exit(1);
+    }
+});
+program
+    .command("update")
+    .description("Update a component to the latest version")
+    .argument("[component]", "Component name (e.g., separator)")
+    .option("--force", "Overwrite local changes")
+    .option("--merge", "Automatically attempt 3-way merge")
+    .option("--registry <url>", "Registry URL", "https://voidui.dev/r")
+    .action(async (component, options) => {
+    try {
+        await updateCommand(component, options);
+    }
+    catch (error) {
+        console.error("Error:", error);
+        process.exit(1);
+    }
+});
+program.parse();

package/dist/types/changelog.d.ts

@@ -0,0 +1,17 @@
+export type ChangeType = "added" | "changed" | "deprecated" | "removed" | "fixed" | "security";
+export interface ChangelogChange {
+    type: ChangeType;
+    description: string;
+}
+export interface ChangelogEntry {
+    version: string;
+    date: string;
+    changes: ChangelogChange[];
+    breaking?: boolean;
+}
+export interface ComponentChangelog {
+    component: string;
+    currentVersion: string;
+    entries: ChangelogEntry[];
+}
+//# sourceMappingURL=changelog.d.ts.map

package/dist/types/changelog.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"changelog.d.ts","sourceRoot":"","sources":["../../src/types/changelog.ts"],"names":[],"mappings":"AAAA,MAAM,MAAM,UAAU,GAClB,OAAO,GACP,SAAS,GACT,YAAY,GACZ,SAAS,GACT,OAAO,GACP,UAAU,CAAC;AAEf,MAAM,WAAW,eAAe;IAC9B,IAAI,EAAE,UAAU,CAAC;IACjB,WAAW,EAAE,MAAM,CAAC;CACrB;AAED,MAAM,WAAW,cAAc;IAC7B,OAAO,EAAE,MAAM,CAAC;IAChB,IAAI,EAAE,MAAM,CAAC;IACb,OAAO,EAAE,eAAe,EAAE,CAAC;IAC3B,QAAQ,CAAC,EAAE,OAAO,CAAC;CACpB;AAED,MAAM,WAAW,kBAAkB;IACjC,SAAS,EAAE,MAAM,CAAC;IAClB,cAAc,EAAE,MAAM,CAAC;IACvB,OAAO,EAAE,cAAc,EAAE,CAAC;CAC3B"}

package/dist/types/changelog.js

@@ -0,0 +1 @@
+export {};

package/dist/types/lock-file.d.ts

@@ -0,0 +1,41 @@
+/**
+ * Lock file types for tracking installed component versions
+ */
+export interface ComponentLockEntry {
+    /**
+     * The installed version of the component (semver format)
+     * @example "1.2.0"
+     */
+    installedVersion: string;
+    /**
+     * ISO 8601 timestamp of when the component was installed
+     * @example "2025-01-20T10:30:00Z"
+     */
+    installedAt: string;
+    /**
+     * SHA-256 checksum of the installed component file
+     * @example "sha256:abc123..."
+     */
+    checksum: string;
+    /**
+     * Optional custom registry URL if not using default
+     * @example "https://custom-registry.dev/r"
+     */
+    registryUrl?: string;
+}
+export interface LockFile {
+    /**
+     * Optional JSON schema reference
+     */
+    $schema?: string;
+    /**
+     * Lock file format version
+     * @example "1.0"
+     */
+    version: string;
+    /**
+     * Map of component names to their lock entries
+     */
+    components: Record<string, ComponentLockEntry>;
+}
+//# sourceMappingURL=lock-file.d.ts.map

package/dist/types/lock-file.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"lock-file.d.ts","sourceRoot":"","sources":["../../src/types/lock-file.ts"],"names":[],"mappings":"AAAA;;GAEG;AAEH,MAAM,WAAW,kBAAkB;IACjC;;;OAGG;IACH,gBAAgB,EAAE,MAAM,CAAC;IAEzB;;;OAGG;IACH,WAAW,EAAE,MAAM,CAAC;IAEpB;;;OAGG;IACH,QAAQ,EAAE,MAAM,CAAC;IAEjB;;;OAGG;IACH,WAAW,CAAC,EAAE,MAAM,CAAC;CACtB;AAED,MAAM,WAAW,QAAQ;IACvB;;OAEG;IACH,OAAO,CAAC,EAAE,MAAM,CAAC;IAEjB;;;OAGG;IACH,OAAO,EAAE,MAAM,CAAC;IAEhB;;OAEG;IACH,UAAU,EAAE,MAAM,CAAC,MAAM,EAAE,kBAAkB,CAAC,CAAC;CAChD"}

package/dist/types/lock-file.js

@@ -0,0 +1,4 @@
+/**
+ * Lock file types for tracking installed component versions
+ */
+export {};

package/dist/types/registry.d.ts

@@ -0,0 +1,84 @@
+/**
+ * Registry API types for fetching component metadata
+ */
+import type { ComponentChangelog } from "./changelog.js";
+export interface RegistryItemVersioning {
+    /**
+     * Current/latest version of the component
+     * @example "1.2.0"
+     */
+    currentVersion: string;
+    /**
+     * Complete changelog with all version entries
+     */
+    changelog: ComponentChangelog;
+    /**
+     * List of all available versions (sorted descending)
+     * @example ["1.2.0", "1.1.0", "1.0.0"]
+     */
+    availableVersions: string[];
+}
+export interface RegistryFile {
+    /**
+     * Relative path of the file in the component
+     * @example "registry/components/ui/separator.tsx"
+     */
+    path: string;
+    /**
+     * File content (source code)
+     */
+    content: string;
+    /**
+     * File type
+     * @example "registry:ui"
+     */
+    type: string;
+    /**
+     * Target path where the file should be copied
+     * @example "components/ui/separator.tsx"
+     */
+    target?: string;
+}
+export interface RegistryItem {
+    /**
+     * Component name
+     * @example "separator"
+     */
+    name: string;
+    /**
+     * Component type
+     * @example "registry:ui"
+     */
+    type: string;
+    /**
+     * Display title
+     * @example "Separator"
+     */
+    title?: string;
+    /**
+     * Component description
+     */
+    description?: string;
+    /**
+     * List of files included in this component
+     */
+    files: RegistryFile[];
+    /**
+     * Optional metadata including versioning info
+     */
+    meta?: {
+        /**
+         * Versioning metadata (voidui extension)
+         */
+        versioning?: RegistryItemVersioning;
+    };
+    /**
+     * Dependencies required by this component
+     */
+    dependencies?: string[];
+    /**
+     * Dev dependencies
+     */
+    devDependencies?: string[];
+}
+//# sourceMappingURL=registry.d.ts.map

package/dist/types/registry.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"registry.d.ts","sourceRoot":"","sources":["../../src/types/registry.ts"],"names":[],"mappings":"AAAA;;GAEG;AAEH,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,gBAAgB,CAAC;AAEzD,MAAM,WAAW,sBAAsB;IACrC;;;OAGG;IACH,cAAc,EAAE,MAAM,CAAC;IAEvB;;OAEG;IACH,SAAS,EAAE,kBAAkB,CAAC;IAE9B;;;OAGG;IACH,iBAAiB,EAAE,MAAM,EAAE,CAAC;CAC7B;AAED,MAAM,WAAW,YAAY;IAC3B;;;OAGG;IACH,IAAI,EAAE,MAAM,CAAC;IAEb;;OAEG;IACH,OAAO,EAAE,MAAM,CAAC;IAEhB;;;OAGG;IACH,IAAI,EAAE,MAAM,CAAC;IAEb;;;OAGG;IACH,MAAM,CAAC,EAAE,MAAM,CAAC;CACjB;AAED,MAAM,WAAW,YAAY;IAC3B;;;OAGG;IACH,IAAI,EAAE,MAAM,CAAC;IAEb;;;OAGG;IACH,IAAI,EAAE,MAAM,CAAC;IAEb;;;OAGG;IACH,KAAK,CAAC,EAAE,MAAM,CAAC;IAEf;;OAEG;IACH,WAAW,CAAC,EAAE,MAAM,CAAC;IAErB;;OAEG;IACH,KAAK,EAAE,YAAY,EAAE,CAAC;IAEtB;;OAEG;IACH,IAAI,CAAC,EAAE;QACL;;WAEG;QACH,UAAU,CAAC,EAAE,sBAAsB,CAAC;KACrC,CAAC;IAEF;;OAEG;IACH,YAAY,CAAC,EAAE,MAAM,EAAE,CAAC;IAExB;;OAEG;IACH,eAAe,CAAC,EAAE,MAAM,EAAE,CAAC;CAC5B"}

package/dist/types/registry.js

@@ -0,0 +1,4 @@
+/**
+ * Registry API types for fetching component metadata
+ */
+export {};

package/dist/utils/checksum.d.ts

@@ -0,0 +1,27 @@
+/**
+ * Utilities for computing and comparing SHA-256 checksums
+ */
+/**
+ * Compute SHA-256 checksum of a file
+ * Normalizes line endings (CRLF -> LF) for cross-platform consistency
+ *
+ * @param filePath - Absolute path to the file
+ * @returns Checksum in format: "sha256:abc123..."
+ */
+export declare function computeChecksum(filePath: string): Promise<string>;
+/**
+ * Compare two checksums for equality
+ *
+ * @param expected - Expected checksum
+ * @param actual - Actual checksum
+ * @returns True if checksums match
+ */
+export declare function compareChecksums(expected: string, actual: string): boolean;
+/**
+ * Format a checksum for display (truncated)
+ *
+ * @param checksum - Full checksum string
+ * @returns Truncated checksum for display (e.g., "sha256:abc123...def789")
+ */
+export declare function formatChecksum(checksum: string): string;
+//# sourceMappingURL=checksum.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"checksum.d.ts","sourceRoot":"","sources":["../../src/utils/checksum.ts"],"names":[],"mappings":"AAAA;;GAEG;AAKH;;;;;;GAMG;AACH,wBAAsB,eAAe,CAAC,QAAQ,EAAE,MAAM,GAAG,OAAO,CAAC,MAAM,CAAC,CAWvE;AAED;;;;;;GAMG;AACH,wBAAgB,gBAAgB,CAAC,QAAQ,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,GAAG,OAAO,CAE1E;AAED;;;;;GAKG;AACH,wBAAgB,cAAc,CAAC,QAAQ,EAAE,MAAM,GAAG,MAAM,CAcvD"}

package/dist/utils/checksum.js

@@ -0,0 +1,50 @@
+/**
+ * Utilities for computing and comparing SHA-256 checksums
+ */
+import { createHash } from "crypto";
+import { readFile } from "fs/promises";
+/**
+ * Compute SHA-256 checksum of a file
+ * Normalizes line endings (CRLF -> LF) for cross-platform consistency
+ *
+ * @param filePath - Absolute path to the file
+ * @returns Checksum in format: "sha256:abc123..."
+ */
+export async function computeChecksum(filePath) {
+    const content = await readFile(filePath, "utf-8");
+    // Normalize line endings (CRLF -> LF) for cross-platform consistency
+    const normalizedContent = content.replace(/\r\n/g, "\n");
+    const hash = createHash("sha256");
+    hash.update(normalizedContent, "utf-8");
+    const digest = hash.digest("hex");
+    return `sha256:${digest}`;
+}
+/**
+ * Compare two checksums for equality
+ *
+ * @param expected - Expected checksum
+ * @param actual - Actual checksum
+ * @returns True if checksums match
+ */
+export function compareChecksums(expected, actual) {
+    return expected === actual;
+}
+/**
+ * Format a checksum for display (truncated)
+ *
+ * @param checksum - Full checksum string
+ * @returns Truncated checksum for display (e.g., "sha256:abc123...def789")
+ */
+export function formatChecksum(checksum) {
+    if (!checksum.startsWith("sha256:")) {
+        return checksum;
+    }
+    const hash = checksum.substring(7); // Remove "sha256:" prefix
+    if (hash.length <= 16) {
+        return checksum;
+    }
+    // Show first 6 and last 6 characters
+    const start = hash.substring(0, 6);
+    const end = hash.substring(hash.length - 6);
+    return `sha256:${start}...${end}`;
+}

package/dist/utils/component-locator.d.ts

@@ -0,0 +1,23 @@
+/**
+ * Utilities for locating components in user projects
+ */
+export interface ComponentLocation {
+    /**
+     * Absolute path to the component file
+     */
+    path: string;
+    /**
+     * Whether the component file exists
+     */
+    exists: boolean;
+}
+/**
+ * Locate a component file in the user's project
+ * Tries common paths and reads components.json for path aliases
+ *
+ * @param componentName - Name of the component (e.g., "separator")
+ * @param cwd - Current working directory
+ * @returns Component location with path and existence flag
+ */
+export declare function locateComponent(componentName: string, cwd: string): Promise<ComponentLocation>;
+//# sourceMappingURL=component-locator.d.ts.map

package/dist/utils/component-locator.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"component-locator.d.ts","sourceRoot":"","sources":["../../src/utils/component-locator.ts"],"names":[],"mappings":"AAAA;;GAEG;AAKH,MAAM,WAAW,iBAAiB;IAChC;;OAEG;IACH,IAAI,EAAE,MAAM,CAAC;IAEb;;OAEG;IACH,MAAM,EAAE,OAAO,CAAC;CACjB;AAUD;;;;;;;GAOG;AACH,wBAAsB,eAAe,CACnC,aAAa,EAAE,MAAM,EACrB,GAAG,EAAE,MAAM,GACV,OAAO,CAAC,iBAAiB,CAAC,CA0D5B"}

package/dist/utils/component-locator.js

@@ -0,0 +1,59 @@
+/**
+ * Utilities for locating components in user projects
+ */
+import path from "path";
+import { fileExists, readJsonFile } from "./file-operations.js";
+/**
+ * Locate a component file in the user's project
+ * Tries common paths and reads components.json for path aliases
+ *
+ * @param componentName - Name of the component (e.g., "separator")
+ * @param cwd - Current working directory
+ * @returns Component location with path and existence flag
+ */
+export async function locateComponent(componentName, cwd) {
+    const fileName = `${componentName}.tsx`;
+    // Try to read components.json for aliases
+    let componentAlias;
+    const configPath = path.join(cwd, "components.json");
+    if (await fileExists(configPath)) {
+        const config = await readJsonFile(configPath);
+        if (config?.aliases?.ui) {
+            componentAlias = config.aliases.ui;
+        }
+        else if (config?.aliases?.components) {
+            componentAlias = config.aliases.components;
+        }
+    }
+    // Build list of paths to try
+    const pathsToTry = [];
+    // If we have an alias from config, try that first
+    if (componentAlias) {
+        // Handle path aliases like "@/components/ui"
+        const cleanAlias = componentAlias.replace(/^@\//, "");
+        pathsToTry.push(path.join(cwd, cleanAlias, fileName));
+        // Also try with "src/" prefix if alias doesn't start with it
+        if (!cleanAlias.startsWith("src/")) {
+            pathsToTry.push(path.join(cwd, "src", cleanAlias, fileName));
+        }
+    }
+    // Common fallback paths
+    pathsToTry.push(path.join(cwd, "components", "ui", fileName), path.join(cwd, "src", "components", "ui", fileName), path.join(cwd, "app", "components", "ui", fileName), path.join(cwd, "lib", "components", "ui", fileName));
+    // Try each path in order
+    for (const tryPath of pathsToTry) {
+        if (await fileExists(tryPath)) {
+            return {
+                path: tryPath,
+                exists: true,
+            };
+        }
+    }
+    // Component not found, return the most common default path
+    const defaultPath = componentAlias
+        ? path.join(cwd, componentAlias.replace(/^@\//, ""), fileName)
+        : path.join(cwd, "components", "ui", fileName);
+    return {
+        path: defaultPath,
+        exists: false,
+    };
+}