voidui-cli 0.1.0

package/dist/utils/diff-formatter.d.ts

@@ -0,0 +1,47 @@
+/**
+ * Utilities for formatting diffs and changelogs for terminal output
+ */
+import type { ChangelogEntry } from "../types/changelog.js";
+export interface DiffOptions {
+    /**
+     * Number of context lines to show around changes
+     * @default 3
+     */
+    contextLines?: number;
+}
+/**
+ * Generate and format a unified diff between two code strings
+ *
+ * @param oldContent - Original content
+ * @param newContent - New content
+ * @param oldLabel - Label for old version (e.g., "separator@1.0.0")
+ * @param newLabel - Label for new version (e.g., "separator@1.1.0")
+ * @param options - Diff options
+ * @returns Formatted diff string with syntax highlighting
+ */
+export declare function formatDiff(oldContent: string, newContent: string, oldLabel: string, newLabel: string, options?: DiffOptions): string;
+/**
+ * Apply syntax highlighting to a unified diff
+ * Uses chalk for terminal colors
+ *
+ * @param diffString - Raw unified diff string
+ * @returns Colored diff string
+ */
+export declare function highlightDiff(diffString: string): string;
+/**
+ * Format changelog entries between two versions
+ *
+ * @param entries - All changelog entries
+ * @param fromVersion - Starting version (older)
+ * @param toVersion - Ending version (newer)
+ * @returns Formatted changelog string
+ */
+export declare function formatChangelog(entries: ChangelogEntry[], fromVersion: string, toVersion: string): string;
+/**
+ * Format a single changelog entry summary (for compact display)
+ *
+ * @param entry - Changelog entry
+ * @returns Formatted summary string
+ */
+export declare function formatChangelogSummary(entry: ChangelogEntry): string;
+//# sourceMappingURL=diff-formatter.d.ts.map

package/dist/utils/diff-formatter.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"diff-formatter.d.ts","sourceRoot":"","sources":["../../src/utils/diff-formatter.ts"],"names":[],"mappings":"AAAA;;GAEG;AAIH,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,uBAAuB,CAAC;AAE5D,MAAM,WAAW,WAAW;IAC1B;;;OAGG;IACH,YAAY,CAAC,EAAE,MAAM,CAAC;CACvB;AAED;;;;;;;;;GASG;AACH,wBAAgB,UAAU,CACxB,UAAU,EAAE,MAAM,EAClB,UAAU,EAAE,MAAM,EAClB,QAAQ,EAAE,MAAM,EAChB,QAAQ,EAAE,MAAM,EAChB,OAAO,GAAE,WAAgB,GACxB,MAAM,CAeR;AAED;;;;;;GAMG;AACH,wBAAgB,aAAa,CAAC,UAAU,EAAE,MAAM,GAAG,MAAM,CAwBxD;AAED;;;;;;;GAOG;AACH,wBAAgB,eAAe,CAC7B,OAAO,EAAE,cAAc,EAAE,EACzB,WAAW,EAAE,MAAM,EACnB,SAAS,EAAE,MAAM,GAChB,MAAM,CA0CR;AAED;;;;;GAKG;AACH,wBAAgB,sBAAsB,CAAC,KAAK,EAAE,cAAc,GAAG,MAAM,CAWpE"}

package/dist/utils/diff-formatter.js

@@ -0,0 +1,186 @@
+/**
+ * Utilities for formatting diffs and changelogs for terminal output
+ */
+import { createPatch } from "diff";
+import chalk from "chalk";
+/**
+ * Generate and format a unified diff between two code strings
+ *
+ * @param oldContent - Original content
+ * @param newContent - New content
+ * @param oldLabel - Label for old version (e.g., "separator@1.0.0")
+ * @param newLabel - Label for new version (e.g., "separator@1.1.0")
+ * @param options - Diff options
+ * @returns Formatted diff string with syntax highlighting
+ */
+export function formatDiff(oldContent, newContent, oldLabel, newLabel, options = {}) {
+    const contextLines = options.contextLines ?? 3;
+    // Generate unified diff
+    const patch = createPatch(oldLabel, oldContent, newContent, oldLabel, newLabel, { context: contextLines });
+    // Apply syntax highlighting
+    return highlightDiff(patch);
+}
+/**
+ * Apply syntax highlighting to a unified diff
+ * Uses chalk for terminal colors
+ *
+ * @param diffString - Raw unified diff string
+ * @returns Colored diff string
+ */
+export function highlightDiff(diffString) {
+    const lines = diffString.split("\n");
+    const coloredLines = [];
+    for (const line of lines) {
+        if (line.startsWith("---") || line.startsWith("+++")) {
+            // File headers
+            coloredLines.push(chalk.bold(line));
+        }
+        else if (line.startsWith("@@")) {
+            // Hunk headers (line numbers)
+            coloredLines.push(chalk.cyan(line));
+        }
+        else if (line.startsWith("+")) {
+            // Additions
+            coloredLines.push(chalk.green(line));
+        }
+        else if (line.startsWith("-")) {
+            // Deletions
+            coloredLines.push(chalk.red(line));
+        }
+        else {
+            // Context lines
+            coloredLines.push(chalk.gray(line));
+        }
+    }
+    return coloredLines.join("\n");
+}
+/**
+ * Format changelog entries between two versions
+ *
+ * @param entries - All changelog entries
+ * @param fromVersion - Starting version (older)
+ * @param toVersion - Ending version (newer)
+ * @returns Formatted changelog string
+ */
+export function formatChangelog(entries, fromVersion, toVersion) {
+    // Filter entries between versions
+    const relevantEntries = filterEntriesBetweenVersions(entries, fromVersion, toVersion);
+    if (relevantEntries.length === 0) {
+        return chalk.gray("No changes found between these versions.");
+    }
+    const output = [];
+    for (const entry of relevantEntries) {
+        // Version header
+        const date = new Date(entry.date).toLocaleDateString("en-US", {
+            year: "numeric",
+            month: "short",
+            day: "numeric",
+        });
+        let versionLine = chalk.bold(`Version ${entry.version}`) + chalk.gray(` (${date})`);
+        if (entry.breaking) {
+            versionLine += " " + chalk.red.bold("BREAKING");
+        }
+        output.push(versionLine);
+        // Changes
+        for (const change of entry.changes) {
+            const icon = getChangeIcon(change.type);
+            const color = getChangeColor(change.type);
+            output.push(`  ${icon} ${color(change.description)}`);
+        }
+        output.push(""); // Empty line between versions
+    }
+    return output.join("\n");
+}
+/**
+ * Format a single changelog entry summary (for compact display)
+ *
+ * @param entry - Changelog entry
+ * @returns Formatted summary string
+ */
+export function formatChangelogSummary(entry) {
+    const lines = [];
+    for (const change of entry.changes) {
+        const icon = getChangeIcon(change.type);
+        const label = getChangeLabel(change.type);
+        const color = getChangeColor(change.type);
+        lines.push(`  ${icon} ${color(`${label}: ${change.description}`)}`);
+    }
+    return lines.join("\n");
+}
+/**
+ * Filter changelog entries between two versions
+ */
+function filterEntriesBetweenVersions(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 typically sorted newest first, so we need the range between indices
+    const start = Math.min(fromIndex, toIndex);
+    const end = Math.max(fromIndex, toIndex);
+    return entries.slice(start, end + 1).reverse(); // Reverse to show oldest first
+}
+/**
+ * Get icon for change type
+ */
+function getChangeIcon(type) {
+    switch (type) {
+        case "added":
+            return "+";
+        case "changed":
+            return "~";
+        case "deprecated":
+            return "!";
+        case "removed":
+            return "-";
+        case "fixed":
+            return "*";
+        case "security":
+            return "!";
+        default:
+            return "•";
+    }
+}
+/**
+ * Get label for change type
+ */
+function getChangeLabel(type) {
+    switch (type) {
+        case "added":
+            return "Added";
+        case "changed":
+            return "Changed";
+        case "deprecated":
+            return "Deprecated";
+        case "removed":
+            return "Removed";
+        case "fixed":
+            return "Fixed";
+        case "security":
+            return "Security";
+        default:
+            return "Changed";
+    }
+}
+/**
+ * Get color function for change type
+ */
+function getChangeColor(type) {
+    switch (type) {
+        case "added":
+            return chalk.green;
+        case "changed":
+            return chalk.blue;
+        case "deprecated":
+            return chalk.yellow;
+        case "removed":
+            return chalk.red;
+        case "fixed":
+            return chalk.cyan;
+        case "security":
+            return chalk.magenta;
+        default:
+            return chalk.white;
+    }
+}

package/dist/utils/file-operations.d.ts

@@ -0,0 +1,7 @@
+export declare function fileExists(filePath: string): Promise<boolean>;
+export declare function readJsonFile<T>(filePath: string): Promise<T | null>;
+export declare function writeJsonFile(filePath: string, data: unknown): Promise<void>;
+export declare function copyFile(source: string, destination: string): Promise<void>;
+export declare function ensureDir(dirPath: string): Promise<void>;
+export declare function readDir(dirPath: string): Promise<string[]>;
+//# sourceMappingURL=file-operations.d.ts.map

package/dist/utils/file-operations.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"file-operations.d.ts","sourceRoot":"","sources":["../../src/utils/file-operations.ts"],"names":[],"mappings":"AAEA,wBAAsB,UAAU,CAAC,QAAQ,EAAE,MAAM,GAAG,OAAO,CAAC,OAAO,CAAC,CAOnE;AAED,wBAAsB,YAAY,CAAC,CAAC,EAAE,QAAQ,EAAE,MAAM,GAAG,OAAO,CAAC,CAAC,GAAG,IAAI,CAAC,CAOzE;AAED,wBAAsB,aAAa,CACjC,QAAQ,EAAE,MAAM,EAChB,IAAI,EAAE,OAAO,GACZ,OAAO,CAAC,IAAI,CAAC,CAGf;AAED,wBAAsB,QAAQ,CAC5B,MAAM,EAAE,MAAM,EACd,WAAW,EAAE,MAAM,GAClB,OAAO,CAAC,IAAI,CAAC,CAEf;AAED,wBAAsB,SAAS,CAAC,OAAO,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC,CAE9D;AAED,wBAAsB,OAAO,CAAC,OAAO,EAAE,MAAM,GAAG,OAAO,CAAC,MAAM,EAAE,CAAC,CAMhE"}

package/dist/utils/file-operations.js

@@ -0,0 +1,37 @@
+import fs from "fs/promises";
+export async function fileExists(filePath) {
+    try {
+        await fs.access(filePath);
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+export async function readJsonFile(filePath) {
+    try {
+        const content = await fs.readFile(filePath, "utf-8");
+        return JSON.parse(content);
+    }
+    catch {
+        return null;
+    }
+}
+export async function writeJsonFile(filePath, data) {
+    const content = JSON.stringify(data, null, 2);
+    await fs.writeFile(filePath, content, "utf-8");
+}
+export async function copyFile(source, destination) {
+    await fs.copyFile(source, destination);
+}
+export async function ensureDir(dirPath) {
+    await fs.mkdir(dirPath, { recursive: true });
+}
+export async function readDir(dirPath) {
+    try {
+        return await fs.readdir(dirPath);
+    }
+    catch {
+        return [];
+    }
+}

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

@@ -0,0 +1,60 @@
+/**
+ * Lock file management utilities
+ * Handles reading, writing, and updating voidui.lock.json
+ */
+import type { LockFile, ComponentLockEntry } from "../types/lock-file.js";
+/**
+ * Read existing lock file or return null if not found
+ *
+ * @param cwd - Current working directory
+ * @returns Lock file or null
+ */
+export declare function readLockFile(cwd: string): Promise<LockFile | null>;
+/**
+ * Read lock file or create a new empty one if it doesn't exist
+ *
+ * @param cwd - Current working directory
+ * @returns Lock file
+ */
+export declare function readOrCreateLockFile(cwd: string): Promise<LockFile>;
+/**
+ * Write lock file to disk
+ *
+ * @param cwd - Current working directory
+ * @param lockFile - Lock file to write
+ */
+export declare function writeLockFile(cwd: string, lockFile: LockFile): Promise<void>;
+/**
+ * Update a component entry in the lock file
+ *
+ * @param lockFile - Lock file to update
+ * @param componentName - Component name
+ * @param entry - Component entry data
+ * @returns Updated lock file
+ */
+export declare function updateComponentEntry(lockFile: LockFile, componentName: string, entry: ComponentLockEntry): LockFile;
+/**
+ * Remove a component entry from the lock file
+ *
+ * @param lockFile - Lock file to update
+ * @param componentName - Component name to remove
+ * @returns Updated lock file
+ */
+export declare function removeComponentEntry(lockFile: LockFile, componentName: string): LockFile;
+/**
+ * Check if a component is tracked in the lock file
+ *
+ * @param lockFile - Lock file
+ * @param componentName - Component name
+ * @returns True if component is tracked
+ */
+export declare function isComponentTracked(lockFile: LockFile, componentName: string): boolean;
+/**
+ * Get component entry from lock file
+ *
+ * @param lockFile - Lock file
+ * @param componentName - Component name
+ * @returns Component entry or null
+ */
+export declare function getComponentEntry(lockFile: LockFile, componentName: string): ComponentLockEntry | null;
+//# sourceMappingURL=lock-file.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"lock-file.d.ts","sourceRoot":"","sources":["../../src/utils/lock-file.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAIH,OAAO,KAAK,EAAE,QAAQ,EAAE,kBAAkB,EAAE,MAAM,uBAAuB,CAAC;AAM1E;;;;;GAKG;AACH,wBAAsB,YAAY,CAAC,GAAG,EAAE,MAAM,GAAG,OAAO,CAAC,QAAQ,GAAG,IAAI,CAAC,CAqBxE;AAED;;;;;GAKG;AACH,wBAAsB,oBAAoB,CAAC,GAAG,EAAE,MAAM,GAAG,OAAO,CAAC,QAAQ,CAAC,CAYzE;AAED;;;;;GAKG;AACH,wBAAsB,aAAa,CACjC,GAAG,EAAE,MAAM,EACX,QAAQ,EAAE,QAAQ,GACjB,OAAO,CAAC,IAAI,CAAC,CAGf;AAED;;;;;;;GAOG;AACH,wBAAgB,oBAAoB,CAClC,QAAQ,EAAE,QAAQ,EAClB,aAAa,EAAE,MAAM,EACrB,KAAK,EAAE,kBAAkB,GACxB,QAAQ,CAQV;AAED;;;;;;GAMG;AACH,wBAAgB,oBAAoB,CAClC,QAAQ,EAAE,QAAQ,EAClB,aAAa,EAAE,MAAM,GACpB,QAAQ,CAOV;AAED;;;;;;GAMG;AACH,wBAAgB,kBAAkB,CAChC,QAAQ,EAAE,QAAQ,EAClB,aAAa,EAAE,MAAM,GACpB,OAAO,CAET;AAED;;;;;;GAMG;AACH,wBAAgB,iBAAiB,CAC/B,QAAQ,EAAE,QAAQ,EAClB,aAAa,EAAE,MAAM,GACpB,kBAAkB,GAAG,IAAI,CAE3B"}

package/dist/utils/lock-file.js

@@ -0,0 +1,110 @@
+/**
+ * Lock file management utilities
+ * Handles reading, writing, and updating voidui.lock.json
+ */
+import path from "path";
+import { lockFileSchema } from "../validators/lock-file.js";
+import { fileExists, readJsonFile, writeJsonFile } from "./file-operations.js";
+const LOCK_FILE_NAME = "voidui.lock.json";
+const LOCK_FILE_VERSION = "1.0";
+/**
+ * Read existing lock file or return null if not found
+ *
+ * @param cwd - Current working directory
+ * @returns Lock file or null
+ */
+export async function readLockFile(cwd) {
+    const lockFilePath = path.join(cwd, LOCK_FILE_NAME);
+    if (!(await fileExists(lockFilePath))) {
+        return null;
+    }
+    const rawLockFile = await readJsonFile(lockFilePath);
+    if (!rawLockFile) {
+        return null;
+    }
+    try {
+        const lockFile = lockFileSchema.parse(rawLockFile);
+        return lockFile;
+    }
+    catch (error) {
+        throw new Error(`Lock file is corrupted. Please delete ${LOCK_FILE_NAME} and re-install components.`);
+    }
+}
+/**
+ * Read lock file or create a new empty one if it doesn't exist
+ *
+ * @param cwd - Current working directory
+ * @returns Lock file
+ */
+export async function readOrCreateLockFile(cwd) {
+    const existing = await readLockFile(cwd);
+    if (existing) {
+        return existing;
+    }
+    // Create new lock file structure
+    return {
+        version: LOCK_FILE_VERSION,
+        components: {},
+    };
+}
+/**
+ * Write lock file to disk
+ *
+ * @param cwd - Current working directory
+ * @param lockFile - Lock file to write
+ */
+export async function writeLockFile(cwd, lockFile) {
+    const lockFilePath = path.join(cwd, LOCK_FILE_NAME);
+    await writeJsonFile(lockFilePath, lockFile);
+}
+/**
+ * Update a component entry in the lock file
+ *
+ * @param lockFile - Lock file to update
+ * @param componentName - Component name
+ * @param entry - Component entry data
+ * @returns Updated lock file
+ */
+export function updateComponentEntry(lockFile, componentName, entry) {
+    return {
+        ...lockFile,
+        components: {
+            ...lockFile.components,
+            [componentName]: entry,
+        },
+    };
+}
+/**
+ * Remove a component entry from the lock file
+ *
+ * @param lockFile - Lock file to update
+ * @param componentName - Component name to remove
+ * @returns Updated lock file
+ */
+export function removeComponentEntry(lockFile, componentName) {
+    const { [componentName]: _, ...remainingComponents } = lockFile.components;
+    return {
+        ...lockFile,
+        components: remainingComponents,
+    };
+}
+/**
+ * Check if a component is tracked in the lock file
+ *
+ * @param lockFile - Lock file
+ * @param componentName - Component name
+ * @returns True if component is tracked
+ */
+export function isComponentTracked(lockFile, componentName) {
+    return componentName in lockFile.components;
+}
+/**
+ * Get component entry from lock file
+ *
+ * @param lockFile - Lock file
+ * @param componentName - Component name
+ * @returns Component entry or null
+ */
+export function getComponentEntry(lockFile, componentName) {
+    return lockFile.components[componentName] || null;
+}

package/dist/utils/merge.d.ts

@@ -0,0 +1,54 @@
+/**
+ * 3-way merge utilities for component updates
+ * Handles merging local changes with upstream updates
+ */
+export interface MergeResult {
+    /**
+     * Whether the merge was successful (no conflicts)
+     */
+    success: boolean;
+    /**
+     * Merged content (may contain conflict markers if !success)
+     */
+    content: string;
+    /**
+     * Number of conflicts found
+     */
+    conflictCount: number;
+}
+/**
+ * Perform a 3-way merge of component files
+ *
+ * @param base - Original version (what was installed)
+ * @param ours - Current local version (potentially modified)
+ * @param theirs - New version from registry
+ * @param labels - Optional labels for conflict markers
+ * @returns Merge result
+ */
+export declare function threeWayMerge(base: string, ours: string, theirs: string, labels?: {
+    ours?: string;
+    theirs?: string;
+}): MergeResult;
+/**
+ * Check if content contains merge conflict markers
+ *
+ * @param content - File content to check
+ * @returns True if conflict markers are present
+ */
+export declare function hasConflictMarkers(content: string): boolean;
+/**
+ * Count the number of conflict regions in content
+ *
+ * @param content - File content
+ * @returns Number of conflict regions
+ */
+export declare function countConflicts(content: string): number;
+/**
+ * Generate a user-friendly message for merge results
+ *
+ * @param result - Merge result
+ * @param componentPath - Path to component file
+ * @returns Formatted message
+ */
+export declare function formatMergeMessage(result: MergeResult, componentPath: string): string;
+//# sourceMappingURL=merge.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"merge.d.ts","sourceRoot":"","sources":["../../src/utils/merge.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAIH,MAAM,WAAW,WAAW;IAC1B;;OAEG;IACH,OAAO,EAAE,OAAO,CAAC;IAEjB;;OAEG;IACH,OAAO,EAAE,MAAM,CAAC;IAEhB;;OAEG;IACH,aAAa,EAAE,MAAM,CAAC;CACvB;AAED;;;;;;;;GAQG;AACH,wBAAgB,aAAa,CAC3B,IAAI,EAAE,MAAM,EACZ,IAAI,EAAE,MAAM,EACZ,MAAM,EAAE,MAAM,EACd,MAAM,CAAC,EAAE;IACP,IAAI,CAAC,EAAE,MAAM,CAAC;IACd,MAAM,CAAC,EAAE,MAAM,CAAC;CACjB,GACA,WAAW,CAoCb;AAED;;;;;GAKG;AACH,wBAAgB,kBAAkB,CAAC,OAAO,EAAE,MAAM,GAAG,OAAO,CAM3D;AAED;;;;;GAKG;AACH,wBAAgB,cAAc,CAAC,OAAO,EAAE,MAAM,GAAG,MAAM,CAGtD;AAED;;;;;;GAMG;AACH,wBAAgB,kBAAkB,CAChC,MAAM,EAAE,WAAW,EACnB,aAAa,EAAE,MAAM,GACpB,MAAM,CAeR"}

package/dist/utils/merge.js

@@ -0,0 +1,84 @@
+/**
+ * 3-way merge utilities for component updates
+ * Handles merging local changes with upstream updates
+ */
+import { diff3Merge } from "node-diff3";
+/**
+ * Perform a 3-way merge of component files
+ *
+ * @param base - Original version (what was installed)
+ * @param ours - Current local version (potentially modified)
+ * @param theirs - New version from registry
+ * @param labels - Optional labels for conflict markers
+ * @returns Merge result
+ */
+export function threeWayMerge(base, ours, theirs, labels) {
+    // Split content into lines for diff3
+    const baseLines = base.split("\n");
+    const oursLines = ours.split("\n");
+    const theirsLines = theirs.split("\n");
+    // Perform 3-way merge
+    const mergeResults = diff3Merge(oursLines, baseLines, theirsLines);
+    let conflictCount = 0;
+    const mergedLines = [];
+    for (const result of mergeResults) {
+        if (result.ok) {
+            // No conflict, use the merged result
+            mergedLines.push(...result.ok);
+        }
+        else if (result.conflict) {
+            // Conflict detected
+            conflictCount++;
+            // Add conflict markers
+            mergedLines.push(`<<<<<<< ${labels?.ours || "ours (your changes)"}`, ...result.conflict.a, "=======", ...result.conflict.b, `>>>>>>> ${labels?.theirs || "theirs (upstream)"}`);
+        }
+    }
+    return {
+        success: conflictCount === 0,
+        content: mergedLines.join("\n"),
+        conflictCount,
+    };
+}
+/**
+ * Check if content contains merge conflict markers
+ *
+ * @param content - File content to check
+ * @returns True if conflict markers are present
+ */
+export function hasConflictMarkers(content) {
+    return (content.includes("<<<<<<<") &&
+        content.includes("=======") &&
+        content.includes(">>>>>>>"));
+}
+/**
+ * Count the number of conflict regions in content
+ *
+ * @param content - File content
+ * @returns Number of conflict regions
+ */
+export function countConflicts(content) {
+    const matches = content.match(/<<<<<<</g);
+    return matches ? matches.length : 0;
+}
+/**
+ * Generate a user-friendly message for merge results
+ *
+ * @param result - Merge result
+ * @param componentPath - Path to component file
+ * @returns Formatted message
+ */
+export function formatMergeMessage(result, componentPath) {
+    if (result.success) {
+        return `✓ Successfully merged your changes with the latest version`;
+    }
+    return `⚠️  Merge completed with ${result.conflictCount} conflict${result.conflictCount > 1 ? "s" : ""}
+
+Conflict markers have been added to: ${componentPath}
+
+To resolve:
+1. Open the file and search for "<<<<<<<"
+2. Edit each conflict region to keep the code you want
+3. Remove the conflict markers (<<<<<<<, =======, >>>>>>>)
+4. Save the file
+5. Run: voidui add ${componentPath.split("/").pop()?.replace(".tsx", "")} --force`;
+}

package/dist/utils/prompts.d.ts

@@ -0,0 +1,8 @@
+import type { ChangeType } from "../types/changelog.js";
+export declare function promptForChange(): Promise<{
+    type: ChangeType;
+    description: string;
+} | null>;
+export declare function promptForMore(message: string): Promise<boolean>;
+export declare function promptForBreaking(): Promise<boolean>;
+//# sourceMappingURL=prompts.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"prompts.d.ts","sourceRoot":"","sources":["../../src/utils/prompts.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,uBAAuB,CAAC;AAExD,wBAAsB,eAAe,IAAI,OAAO,CAAC;IAC/C,IAAI,EAAE,UAAU,CAAC;IACjB,WAAW,EAAE,MAAM,CAAC;CACrB,GAAG,IAAI,CAAC,CAgCR;AAED,wBAAsB,aAAa,CAAC,OAAO,EAAE,MAAM,GAAG,OAAO,CAAC,OAAO,CAAC,CASrE;AAED,wBAAsB,iBAAiB,IAAI,OAAO,CAAC,OAAO,CAAC,CAS1D"}

package/dist/utils/prompts.js

@@ -0,0 +1,49 @@
+import prompts from "prompts";
+export async function promptForChange() {
+    const response = await prompts([
+        {
+            type: "select",
+            name: "type",
+            message: "Change type:",
+            choices: [
+                { title: "✨ Added", value: "added" },
+                { title: "🔄 Changed", value: "changed" },
+                { title: "⚠️  Deprecated", value: "deprecated" },
+                { title: "🗑️  Removed", value: "removed" },
+                { title: "🐛 Fixed", value: "fixed" },
+                { title: "🔒 Security", value: "security" },
+            ],
+        },
+        {
+            type: "text",
+            name: "description",
+            message: "Change description:",
+            validate: (value) => value.length > 0 ? true : "Description cannot be empty",
+        },
+    ]);
+    if (!response.type || !response.description) {
+        return null;
+    }
+    return {
+        type: response.type,
+        description: response.description,
+    };
+}
+export async function promptForMore(message) {
+    const response = await prompts({
+        type: "confirm",
+        name: "more",
+        message,
+        initial: false,
+    });
+    return response.more ?? false;
+}
+export async function promptForBreaking() {
+    const response = await prompts({
+        type: "confirm",
+        name: "breaking",
+        message: "Is this a breaking change?",
+        initial: false,
+    });
+    return response.breaking ?? false;
+}