@nikala-ui/cli 0.0.0-nightly.bb5956a

package/README.md

@@ -0,0 +1,39 @@
+# @nikala-ui/cli
+
+Command Line Interface (CLI) for **Nikala UI** — a copy-paste component system for **SolidJS** built natively for **Tailwind CSS v4**.
+
+Honoring the iconic Georgian painter **Niko Pirosmani (Nikala)**.
+
+Official Documentation & Interactive Demos: [nikala.magradze.dev](https://nikala.magradze.dev)
+
+---
+
+## Installation & Usage
+
+Execute directly using your preferred package manager:
+
+```bash
+bunx @nikala-ui/cli init
+# or
+npx @nikala-ui/cli init
+```
+
+---
+
+## Available Commands
+
+- `nikala init` — Initializes configuration, `@` path aliases, and Tailwind CSS v4 variables.
+- `nikala add` — Interactive searchable multiselect menu for component installation.
+- `nikala validate` (or `nikala doctor`) — Runs health diagnostics on workspace configuration, packages, and CSS design tokens.
+- `nikala diff` — Inspects line-by-line code differences between local components and upstream registry manifests.
+- `nikala theme set [primary] [base]` — Customizes primary brand accent colors and base gray palettes directly from the terminal.
+
+---
+
+## Documentation
+
+For full documentation, component lists, and theming guides, visit the official repository at [github.com/nikala-ui/ui](https://github.com/nikala-ui/ui).
+
+## License
+
+[MIT](https://github.com/nikala-ui/ui/blob/main/LICENSE)

package/dist/commands/add.d.ts

@@ -0,0 +1,9 @@
+interface AddOptions {
+    overwrite?: boolean;
+    all?: boolean;
+}
+/**
+ * Command handler to fetch and install Nikala UI components from GitHub remote registry or custom URLs.
+ */
+export declare function add(components?: string[], options?: AddOptions): Promise<void>;
+export {};

package/dist/commands/add.js

@@ -0,0 +1,89 @@
+import fs from "fs-extra";
+import path from "node:path";
+import prompts from "prompts";
+import pc from "picocolors";
+import { readConfig } from "../utils/file.js";
+import { installDependencies } from "../utils/pkg.js";
+import { getRegistryIndex, getRegistryItem, resolveRegistryDependencies, } from "../utils/registry.js";
+import { writeComponentFiles } from "../utils/add/write-component-files.js";
+/**
+ * Command handler to fetch and install Nikala UI components from GitHub remote registry or custom URLs.
+ */
+export async function add(components = [], options = {}) {
+    const cwd = process.cwd();
+    const config = await readConfig(cwd);
+    if (!config) {
+        console.log(pc.red("❌ nikala.config.json not found! Run `nikala init` first."));
+        process.exit(1);
+    }
+    const registryIndex = await getRegistryIndex();
+    if (!registryIndex) {
+        console.log(pc.red("❌ Failed to load registry index. Ensure network connection or build registry."));
+        process.exit(1);
+    }
+    const isAllRequested = options.all || components.includes("all");
+    let requestedComponents = components.filter((c) => c !== "all");
+    if (isAllRequested) {
+        requestedComponents = registryIndex.map((item) => item.name);
+    }
+    else if (requestedComponents.length === 0) {
+        const response = await prompts({
+            type: "autocompleteMultiselect",
+            name: "selectedComponents",
+            message: "Select components to install (Space to toggle, Enter to confirm)",
+            choices: registryIndex.map((item) => ({
+                title: item.title,
+                description: item.description,
+                value: item.name,
+            })),
+            hint: "- Space to select. Return to submit",
+        });
+        if (!response.selectedComponents || response.selectedComponents.length === 0) {
+            console.log(pc.yellow("\n❌ Installation cancelled. No components selected."));
+            return;
+        }
+        requestedComponents = response.selectedComponents;
+    }
+    const resolvedTargets = await resolveRegistryDependencies(requestedComponents);
+    const componentsDir = path.resolve(cwd, config.alias.components);
+    console.log(pc.cyan(`\n🎨 Adding components to project...\n`));
+    const requiredNpmDeps = new Set();
+    for (const target of resolvedTargets) {
+        const item = await getRegistryItem(target);
+        if (!item) {
+            const availableStr = registryIndex ? registryIndex.map((i) => i.name).join(", ") : "none";
+            console.log(pc.red(`❌ "${target}" not found in registry. Available: ${availableStr}`));
+            continue;
+        }
+        if (item.dependencies && item.dependencies.length > 0) {
+            for (const dep of item.dependencies) {
+                requiredNpmDeps.add(dep);
+            }
+        }
+        await writeComponentFiles(cwd, item, componentsDir, options.overwrite);
+    }
+    // Inspect user package.json and install missing NPM packages
+    const userPkgPath = path.join(cwd, "package.json");
+    const missingNpmDeps = [];
+    if (await fs.pathExists(userPkgPath)) {
+        try {
+            const userPkg = await fs.readJson(userPkgPath);
+            const installedDeps = { ...userPkg.dependencies, ...userPkg.devDependencies };
+            for (const dep of requiredNpmDeps) {
+                if (!installedDeps[dep]) {
+                    missingNpmDeps.push(dep);
+                }
+            }
+        }
+        catch {
+            missingNpmDeps.push(...Array.from(requiredNpmDeps));
+        }
+    }
+    else {
+        missingNpmDeps.push(...Array.from(requiredNpmDeps));
+    }
+    if (missingNpmDeps.length > 0) {
+        await installDependencies(missingNpmDeps, cwd);
+    }
+    console.log(pc.cyan("\n✅ Components successfully added!"));
+}

package/dist/commands/diff.d.ts

@@ -0,0 +1,7 @@
+/**
+ * Command handler for `nikala diff [component]`.
+ * Compares local installed component files against latest registry manifests and displays line differences.
+ *
+ * @param componentName - Optional specific component name to diff (e.g., "button")
+ */
+export declare function diffCommand(componentName?: string): Promise<void>;

package/dist/commands/diff.js

@@ -0,0 +1,87 @@
+import fs from "fs-extra";
+import path from "node:path";
+import prompts from "prompts";
+import pc from "picocolors";
+import { readConfig } from "../utils/file.js";
+import { getRegistryItem } from "../utils/registry.js";
+import { compareLines } from "../utils/diff/compare-lines.js";
+import { printFormattedDiff } from "../utils/diff/format-diff.js";
+/**
+ * Command handler for `nikala diff [component]`.
+ * Compares local installed component files against latest registry manifests and displays line differences.
+ *
+ * @param componentName - Optional specific component name to diff (e.g., "button")
+ */
+export async function diffCommand(componentName) {
+    const cwd = process.cwd();
+    const config = await readConfig(cwd);
+    if (!config) {
+        console.log(pc.red("❌ nikala.config.json not found! Run `nikala init` first."));
+        process.exit(1);
+    }
+    const componentsDir = path.resolve(cwd, config.alias.components);
+    if (!(await fs.pathExists(componentsDir))) {
+        console.log(pc.yellow(`⚠️ Components directory not found: ${config.alias.components}`));
+        return;
+    }
+    let targets = [];
+    if (componentName) {
+        targets = [componentName];
+    }
+    else {
+        // Scan all installed component .tsx files in local components directory
+        const files = await fs.readdir(componentsDir);
+        targets = files
+            .filter((f) => f.endsWith(".tsx"))
+            .map((f) => path.basename(f, ".tsx"));
+    }
+    if (targets.length === 0) {
+        console.log(pc.yellow("No local components found to compare."));
+        return;
+    }
+    console.log(pc.cyan("\nComparing local components with latest registry manifests...\n"));
+    let totalDiffsFound = 0;
+    for (const name of targets) {
+        const registryItem = await getRegistryItem(name);
+        if (!registryItem) {
+            continue;
+        }
+        const targetFile = registryItem.files.find((f) => path.basename(f.path, ".tsx") === name);
+        if (!targetFile)
+            continue;
+        const localFilePath = path.join(componentsDir, `${name}.tsx`);
+        if (!(await fs.pathExists(localFilePath)))
+            continue;
+        const localContent = await fs.readFile(localFilePath, "utf-8");
+        const diffs = compareLines(localContent, targetFile.content);
+        const hasChanges = diffs.some((d) => d.type !== "same");
+        if (hasChanges) {
+            totalDiffsFound++;
+            console.log(pc.bold(pc.yellow(`Differences found in ${name}.tsx:`)));
+            printFormattedDiff(diffs);
+            const response = await prompts({
+                type: "select",
+                name: "action",
+                message: `Action for ${name}.tsx:`,
+                choices: [
+                    { title: "Keep local version (skip)", value: "skip" },
+                    { title: "Overwrite with latest registry version", value: "overwrite" },
+                ],
+                initial: 0,
+            });
+            if (response.action === "overwrite") {
+                await fs.writeFile(localFilePath, targetFile.content, "utf-8");
+                console.log(pc.green(`  ✓ Overwrote ${name}.tsx with latest registry version.\n`));
+            }
+            else {
+                console.log(pc.dim(`  Kept local version of ${name}.tsx.\n`));
+            }
+        }
+        else {
+            console.log(`  ✓ ${pc.bold(name)}.tsx is up-to-date with registry`);
+        }
+    }
+    if (totalDiffsFound === 0) {
+        console.log(pc.green("\nAll local components are up-to-date with the latest registry manifests!"));
+    }
+}

package/dist/commands/init.d.ts

@@ -0,0 +1,8 @@
+interface InitOptions {
+    defaults?: boolean;
+}
+/**
+ * Initializes Nikala UI workspace configuration and sets up design tokens.
+ */
+export declare function init(options: InitOptions): Promise<void>;
+export {};

package/dist/commands/init.js

@@ -0,0 +1,116 @@
+import fs from "fs-extra";
+import path from "node:path";
+import prompts from "prompts";
+import pc from "picocolors";
+import { cnTemplate } from "../utils/cn.js";
+import { writeConfig } from "../utils/file.js";
+import { installDependencies } from "../utils/pkg.js";
+import { configureAliases } from "../utils/init/configure-alias.js";
+import { setupCssTheme } from "../utils/init/setup-css.js";
+/**
+ * Initializes Nikala UI workspace configuration and sets up design tokens.
+ */
+export async function init(options) {
+    const cwd = process.cwd();
+    console.log(pc.cyan("🎨 Initializing Nikala UI...\n"));
+    const config = options.defaults
+        ? {
+            componentsDir: "src/components/ui",
+            utilsDir: "src/lib",
+            baseColor: "zinc",
+            primaryColor: "wine",
+        }
+        : await prompts([
+            {
+                type: "text",
+                name: "componentsDir",
+                message: "Components directory path",
+                initial: "src/components/ui",
+            },
+            {
+                type: "text",
+                name: "utilsDir",
+                message: "Utility functions directory path",
+                initial: "src/lib",
+            },
+            {
+                type: "select",
+                name: "baseColor",
+                message: "Select base gray palette",
+                choices: [
+                    { title: "Zinc (Modern cool gray)", value: "zinc" },
+                    { title: "Slate (Slightly blue gray)", value: "slate" },
+                    { title: "Gray (Neutral gray)", value: "gray" },
+                    { title: "Neutral (Warm gray)", value: "neutral" },
+                    { title: "Stone (Earth gray)", value: "stone" },
+                ],
+                initial: 0,
+            },
+            {
+                type: "select",
+                name: "primaryColor",
+                message: "Select primary brand accent color",
+                choices: [
+                    { title: "Wine (Pirosmani Red)", value: "wine" },
+                    { title: "Violet (Deep Purple)", value: "violet" },
+                    { title: "Sky (Vibrant Blue)", value: "sky" },
+                    { title: "Emerald (Rich Green)", value: "emerald" },
+                    { title: "Rose (Vivid Pink)", value: "rose" },
+                    { title: "Amber (Warm Gold)", value: "amber" },
+                    { title: "Zinc (Monochrome)", value: "zinc" },
+                ],
+                initial: 0,
+            },
+        ]);
+    if (!config.componentsDir || !config.utilsDir) {
+        console.log(pc.yellow("\n❌ Initialization cancelled."));
+        process.exit(0);
+    }
+    const componentsPath = path.resolve(cwd, config.componentsDir);
+    const utilsPath = path.resolve(cwd, config.utilsDir);
+    await fs.ensureDir(componentsPath);
+    await fs.ensureDir(utilsPath);
+    // 1. Install required packages
+    const userPkgPath = path.join(cwd, "package.json");
+    const requiredDeps = ["clsx", "tailwind-merge", "class-variance-authority"];
+    if (await fs.pathExists(userPkgPath)) {
+        try {
+            const userPkg = await fs.readJson(userPkgPath);
+            const installed = { ...userPkg.dependencies, ...userPkg.devDependencies };
+            if (!installed["tailwindcss"])
+                requiredDeps.push("tailwindcss");
+            if (!installed["@tailwindcss/vite"])
+                requiredDeps.push("@tailwindcss/vite");
+        }
+        catch {
+            requiredDeps.push("tailwindcss", "@tailwindcss/vite");
+        }
+    }
+    else {
+        requiredDeps.push("tailwindcss", "@tailwindcss/vite");
+    }
+    console.log(pc.yellow("\n📦 Installing required runtime & Tailwind CSS dependencies..."));
+    await installDependencies(requiredDeps, cwd);
+    // 2. Configure path aliases
+    await configureAliases(cwd);
+    // 3. Generate cn.ts helper
+    const cnFilePath = path.join(utilsPath, "cn.ts");
+    await fs.writeFile(cnFilePath, cnTemplate, "utf-8");
+    console.log(pc.green(`✓ Created ${config.utilsDir}/cn.ts`));
+    // 4. Setup CSS theme and entry imports
+    const cssPathRelative = await setupCssTheme(cwd, config.baseColor, config.primaryColor);
+    // 5. Generate nikala.config.json
+    await writeConfig(cwd, {
+        $schema: "https://nikala.dev/schema.json",
+        style: "default",
+        baseColor: config.baseColor || "zinc",
+        primaryColor: config.primaryColor || "wine",
+        css: cssPathRelative,
+        alias: {
+            components: config.componentsDir,
+            utils: config.utilsDir,
+        },
+    });
+    console.log(pc.green("✓ Created nikala.config.json"));
+    console.log(pc.green("\n✅ Nikala UI initialized successfully with custom theme!"));
+}

package/dist/commands/theme.d.ts

@@ -0,0 +1,5 @@
+/**
+ * Command handler for `nikala theme` and `nikala theme set`.
+ * Supports both interactive prompts and positional arguments (e.g. `nikala theme set sky slate`).
+ */
+export declare function themeCommand(primaryArg?: string, baseArg?: string): Promise<void>;

package/dist/commands/theme.js

@@ -0,0 +1,64 @@
+import fs from "fs-extra";
+import path from "node:path";
+import prompts from "prompts";
+import pc from "picocolors";
+import { readConfig, writeConfig } from "../utils/file.js";
+import { generateThemeCss, BASE_PALETTES, PRIMARY_COLORS } from "../utils/theme.js";
+/**
+ * Command handler for `nikala theme` and `nikala theme set`.
+ * Supports both interactive prompts and positional arguments (e.g. `nikala theme set sky slate`).
+ */
+export async function themeCommand(primaryArg, baseArg) {
+    const cwd = process.cwd();
+    const config = await readConfig(cwd);
+    if (!config) {
+        console.log(pc.red("❌ nikala.config.json not found! Run `nikala init` first."));
+        process.exit(1);
+    }
+    let selectedPrimary = primaryArg || config.primaryColor || "wine";
+    let selectedBase = baseArg || config.baseColor || "zinc";
+    // If no arguments provided, launch interactive prompts
+    if (!primaryArg) {
+        console.log(pc.cyan("🎨 Customize Nikala UI Theme\n"));
+        const response = await prompts([
+            {
+                type: "select",
+                name: "primaryColor",
+                message: "Select primary brand accent color",
+                choices: Object.keys(PRIMARY_COLORS).map((key) => ({
+                    title: key.charAt(0).toUpperCase() + key.slice(1),
+                    value: key,
+                })),
+                initial: Object.keys(PRIMARY_COLORS).indexOf(selectedPrimary),
+            },
+            {
+                type: "select",
+                name: "baseColor",
+                message: "Select base gray palette",
+                choices: Object.keys(BASE_PALETTES).map((key) => ({
+                    title: key.charAt(0).toUpperCase() + key.slice(1),
+                    value: key,
+                })),
+                initial: Object.keys(BASE_PALETTES).indexOf(selectedBase),
+            },
+        ]);
+        if (!response.primaryColor || !response.baseColor) {
+            console.log(pc.yellow("\n❌ Theme update cancelled."));
+            return;
+        }
+        selectedPrimary = response.primaryColor;
+        selectedBase = response.baseColor;
+    }
+    const cssPathRelative = config.css || "src/index.css";
+    const cssPath = path.resolve(cwd, cssPathRelative);
+    const generatedCss = generateThemeCss(selectedBase, selectedPrimary);
+    await fs.ensureDir(path.dirname(cssPath));
+    await fs.writeFile(cssPath, generatedCss, "utf-8");
+    await writeConfig(cwd, {
+        ...config,
+        baseColor: selectedBase,
+        primaryColor: selectedPrimary,
+    });
+    console.log(pc.green(`\n✅ Theme updated successfully! Primary: ${pc.bold(selectedPrimary)}, Base: ${pc.bold(selectedBase)}`));
+    console.log(pc.white(`Updated ${cssPathRelative}`));
+}

package/dist/commands/validate.d.ts

@@ -0,0 +1,5 @@
+/**
+ * Command handler for `nikala validate` (or `nikala doctor`).
+ * Executes diagnostic checks verifying configuration, installed dependencies, and CSS theme tokens.
+ */
+export declare function validateCommand(): Promise<void>;

package/dist/commands/validate.js

@@ -0,0 +1,38 @@
+import pc from "picocolors";
+import { checkConfig } from "../utils/validate/check-config.js";
+import { checkDeps } from "../utils/validate/check-deps.js";
+import { checkCss } from "../utils/validate/check-css.js";
+/**
+ * Command handler for `nikala validate` (or `nikala doctor`).
+ * Executes diagnostic checks verifying configuration, installed dependencies, and CSS theme tokens.
+ */
+export async function validateCommand() {
+    const cwd = process.cwd();
+    console.log(pc.cyan("\nDiagnostic Health Check — Nikala UI Workspace\n"));
+    const checks = [
+        { name: "Project Configuration", fn: () => checkConfig(cwd) },
+        { name: "Dependencies & Packages", fn: () => checkDeps(cwd) },
+        { name: "CSS Setup & Theme Tokens", fn: () => checkCss(cwd) },
+    ];
+    let totalPassed = 0;
+    for (const check of checks) {
+        const result = await check.fn();
+        if (result.passed) {
+            totalPassed++;
+            console.log(`  ✓ ${pc.bold(check.name)}: ${result.message}`);
+        }
+        else {
+            console.log(`  ✗ ${pc.bold(check.name)}: ${result.message}`);
+            if (result.details) {
+                console.log(`    ↳ ${pc.yellow(result.details)}`);
+            }
+        }
+    }
+    console.log("");
+    if (totalPassed === checks.length) {
+        console.log(pc.green(`Workspace health check passed (${totalPassed}/${checks.length} checks valid).\n`));
+    }
+    else {
+        console.log(pc.yellow(`Workspace health check finished with warnings (${totalPassed}/${checks.length} passed).\n`));
+    }
+}

package/dist/index.d.ts

@@ -0,0 +1,2 @@
+#!/usr/bin/env node
+export {};

package/dist/index.js

@@ -0,0 +1,49 @@
+#!/usr/bin/env node
+import { Command } from "commander";
+import pc from "picocolors";
+import { init } from "./commands/init.js";
+import { add } from "./commands/add.js";
+import { themeCommand } from "./commands/theme.js";
+import { validateCommand } from "./commands/validate.js";
+import { diffCommand } from "./commands/diff.js";
+console.log(`\n🎨 ${pc.bold(pc.red("Nikala UI"))} ${pc.dim("v0.8.0")} — SolidJS + Tailwind v4 components`);
+console.log(`   ${pc.italic(pc.dim("Honoring Niko Pirosmani (Nikala)"))}\n`);
+console.log(`   ${pc.dim("Docs:")} ${pc.underline(pc.cyan("https://nikala.magradze.dev"))}\n`);
+const program = new Command();
+program
+    .name("nikala")
+    .description("Nikala UI — SolidJS + Tailwind v4 components")
+    .version("0.8.0");
+program
+    .command("init")
+    .description("Initialize Nikala UI in your project")
+    .option("-d, --defaults", "Skip prompts and use defaults")
+    .action(init);
+program
+    .command("add [components...]")
+    .description("Add components to your project")
+    .option("-o, --overwrite", "Overwrite existing files")
+    .option("--all", "Add all available components")
+    .action(add);
+// Parent theme command
+const themeProg = program
+    .command("theme")
+    .description("Customize project theme colors and design tokens")
+    .action(() => themeCommand());
+// Sub-command: nikala theme set [primary] [base]
+themeProg
+    .command("set [primary] [base]")
+    .description("Set project primary accent color and base palette")
+    .action((primary, base) => themeCommand(primary, base));
+// Diagnostic command
+program
+    .command("validate")
+    .alias("doctor")
+    .description("Run health diagnostics on Nikala UI configuration, packages, and CSS tokens")
+    .action(validateCommand);
+// Diff command
+program
+    .command("diff [component]")
+    .description("Compare local component files against latest registry manifests and view differences")
+    .action((component) => diffCommand(component));
+program.parse();

package/dist/types/registry.d.ts

@@ -0,0 +1,23 @@
+export interface RegistryFile {
+    path: string;
+    content: string;
+    type: "registry:ui" | "registry:util" | "registry:hook";
+}
+export interface RegistryItem {
+    name: string;
+    title: string;
+    description: string;
+    type: "registry:ui";
+    dependencies?: string[];
+    registryDependencies?: string[];
+    files: RegistryFile[];
+}
+export interface RegistryIndexItem {
+    name: string;
+    title: string;
+    description: string;
+    type: "registry:ui";
+    dependencies?: string[];
+    registryDependencies?: string[];
+}
+export type RegistryIndex = RegistryIndexItem[];

package/dist/types/registry.js

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

package/dist/utils/add/write-component-files.d.ts

@@ -0,0 +1,10 @@
+import type { RegistryItem } from "../../types/registry.js";
+/**
+ * Writes registry component files to target workspace directories (ui vs providers).
+ *
+ * @param cwd - Working directory path of the target project
+ * @param item - Registry item manifest containing files
+ * @param componentsDir - Target components directory path (src/components/ui)
+ * @param overwrite - Whether to overwrite existing files
+ */
+export declare function writeComponentFiles(cwd: string, item: RegistryItem, componentsDir: string, overwrite?: boolean): Promise<void>;

package/dist/utils/add/write-component-files.js

@@ -0,0 +1,31 @@
+import fs from "fs-extra";
+import path from "node:path";
+import pc from "picocolors";
+/**
+ * Writes registry component files to target workspace directories (ui vs providers).
+ *
+ * @param cwd - Working directory path of the target project
+ * @param item - Registry item manifest containing files
+ * @param componentsDir - Target components directory path (src/components/ui)
+ * @param overwrite - Whether to overwrite existing files
+ */
+export async function writeComponentFiles(cwd, item, componentsDir, overwrite = false) {
+    for (const file of item.files) {
+        let targetFilePath;
+        if (file.path.startsWith("ui/")) {
+            const relativePath = file.path.replace(/^ui\//, "");
+            targetFilePath = path.join(componentsDir, relativePath);
+        }
+        else {
+            targetFilePath = path.resolve(cwd, "src", file.path);
+        }
+        const displayPath = path.relative(cwd, targetFilePath);
+        if ((await fs.pathExists(targetFilePath)) && !overwrite) {
+            console.log(pc.yellow(`  ⚠️  ${displayPath} already exists. Use --overwrite to replace.`));
+            continue;
+        }
+        await fs.ensureDir(path.dirname(targetFilePath));
+        await fs.writeFile(targetFilePath, file.content, "utf-8");
+        console.log(pc.green(`  ✓ Added ${displayPath}`));
+    }
+}

package/dist/utils/cn.d.ts

@@ -0,0 +1,5 @@
+/**
+ * Raw string template used by `nikala init` to generate the `cn.ts` helper utility
+ * in the user's project (`src/lib/cn.ts`).
+ */
+export declare const cnTemplate = "import { clsx, type ClassValue } from \"clsx\";\nimport { twMerge } from \"tailwind-merge\";\n\n/**\n * Utility function to merge Tailwind CSS class names without conflicts.\n * Combines clsx for conditional classes and tailwind-merge to resolve Tailwind class collisions.\n *\n * @param inputs - Class names, objects, or arrays\n * @returns Merged class string\n */\nexport function cn(...inputs: ClassValue[]) {\n  return twMerge(clsx(inputs));\n}\n";

package/dist/utils/cn.js

@@ -0,0 +1,18 @@
+/**
+ * Raw string template used by `nikala init` to generate the `cn.ts` helper utility
+ * in the user's project (`src/lib/cn.ts`).
+ */
+export const cnTemplate = `import { clsx, type ClassValue } from "clsx";
+import { twMerge } from "tailwind-merge";
+
+/**
+ * Utility function to merge Tailwind CSS class names without conflicts.
+ * Combines clsx for conditional classes and tailwind-merge to resolve Tailwind class collisions.
+ *
+ * @param inputs - Class names, objects, or arrays
+ * @returns Merged class string
+ */
+export function cn(...inputs: ClassValue[]) {
+  return twMerge(clsx(inputs));
+}
+`;

package/dist/utils/diff/compare-lines.d.ts

@@ -0,0 +1,12 @@
+export interface DiffLine {
+    type: "add" | "delete" | "same";
+    value: string;
+}
+/**
+ * Compares two text contents line-by-line and returns an array of structured diff entries.
+ * Uses a lightweight matching algorithm to identify added, removed, and identical lines.
+ *
+ * @param oldText - Original local component file content
+ * @param newText - Latest registry component file content
+ */
+export declare function compareLines(oldText: string, newText: string): DiffLine[];