@nikala-ui/cli 0.10.1 → 0.11.0-nightly.63085f3

package/dist/commands/add.d.ts

@@ -2,6 +2,7 @@ interface AddOptions {
     overwrite?: boolean;
     all?: boolean;
     hook?: boolean;
+    block?: boolean;
 }
 /**
  * Command handler to fetch and install Nikala UI components from GitHub remote registry or custom URLs.

package/dist/commands/add.js

@@ -22,14 +22,24 @@ export async function add(components = [], options = {}) {
         process.exit(1);
     }
     const isHookMode = Boolean(options.hook);
-    const filteredRegistry = registryIndex.filter((item) => isHookMode ? item.type === "registry:hook" : item.type !== "registry:hook");
+    const isBlockMode = Boolean(options.block);
+    let filteredRegistry = registryIndex;
+    if (isHookMode) {
+        filteredRegistry = registryIndex.filter((item) => item.type === "registry:hook");
+    }
+    else if (isBlockMode) {
+        filteredRegistry = registryIndex.filter((item) => item.type === "registry:block");
+    }
+    else {
+        filteredRegistry = registryIndex.filter((item) => item.type !== "registry:hook");
+    }
     const isAllRequested = options.all || components.includes("all");
     let requestedComponents = components.filter((c) => c !== "all");
     if (isAllRequested) {
         requestedComponents = filteredRegistry.map((item) => item.name);
     }
     else if (requestedComponents.length === 0) {
-        const itemLabel = isHookMode ? "hooks" : "components";
+        const itemLabel = isHookMode ? "hooks" : isBlockMode ? "blocks" : "components";
         const response = await prompts({
             type: "autocompleteMultiselect",
             name: "selectedComponents",
@@ -47,15 +57,12 @@ export async function add(components = [], options = {}) {
         }
         requestedComponents = response.selectedComponents;
     }
-    const resolvedTargets = await resolveRegistryDependencies(requestedComponents);
+    const resolvedTargets = await resolveRegistryDependencies(requestedComponents, config.registries);
     const componentsDir = path.resolve(cwd, config.alias.components);
-    console.log(pc.cyan(`\n🎨 Adding components to project...\n`));
+    console.log(pc.cyan(`\n🎨 Adding items to project...\n`));
     const requiredNpmDeps = new Set();
-    if (isHookMode) {
-        requiredNpmDeps.add("@nikala-ui/hooks");
-    }
     for (const target of resolvedTargets) {
-        const item = await getRegistryItem(target);
+        const item = await getRegistryItem(target, config.registries);
         if (!item) {
             const availableStr = registryIndex ? registryIndex.map((i) => i.name).join(", ") : "none";
             console.log(pc.red(`❌ "${target}" not found in registry. Available: ${availableStr}`));
@@ -70,26 +77,22 @@ export async function add(components = [], options = {}) {
     }
     // 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);
-                }
+            const installedDeps = {
+                ...userPkg.dependencies,
+                ...userPkg.devDependencies,
+            };
+            const missingDeps = Array.from(requiredNpmDeps).filter((dep) => !installedDeps[dep]);
+            if (missingDeps.length > 0) {
+                console.log(pc.cyan(`\n📦 Installing missing dependencies: ${missingDeps.join(", ")}...\n`));
+                await installDependencies(missingDeps, cwd);
             }
         }
         catch {
-            missingNpmDeps.push(...Array.from(requiredNpmDeps));
+            // Gracefully continue
         }
     }
-    else {
-        missingNpmDeps.push(...Array.from(requiredNpmDeps));
-    }
-    if (missingNpmDeps.length > 0) {
-        await installDependencies(missingNpmDeps, cwd);
-    }
-    console.log(pc.cyan("\n✅ Components successfully added!"));
+    console.log(pc.green(`\n✨ Successfully added ${resolvedTargets.length} item(s)!`));
 }

package/dist/commands/init.d.ts

@@ -1,5 +1,6 @@
 interface InitOptions {
     defaults?: boolean;
+    ai?: boolean;
 }
 /**
  * Initializes Nikala UI workspace configuration and sets up design tokens.

package/dist/commands/init.js

@@ -7,6 +7,7 @@ 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";
+import { setupAiRules } from "../utils/init/setup-ai-rules.js";
 /**
  * Initializes Nikala UI workspace configuration and sets up design tokens.
  */
@@ -124,5 +125,9 @@ export async function init(options) {
         },
     });
     console.log(pc.green("✓ Created nikala.config.json"));
+    // 6. Setup AI assistant rules if --ai flag is passed
+    if (options.ai) {
+        await setupAiRules(cwd);
+    }
     console.log(pc.green("\n✅ Nikala UI initialized successfully with custom theme!"));
 }

package/dist/commands/list.d.ts

@@ -0,0 +1,12 @@
+interface ListOptions {
+    installed?: boolean;
+    hook?: boolean;
+    component?: boolean;
+    block?: boolean;
+    json?: boolean;
+}
+/**
+ * Command handler to list all available and locally installed Nikala UI components, blocks, and hooks.
+ */
+export declare function listCommand(options?: ListOptions): Promise<void>;
+export {};

package/dist/commands/list.js

@@ -0,0 +1,106 @@
+import fs from "fs-extra";
+import path from "node:path";
+import pc from "picocolors";
+import { readConfig } from "../utils/file.js";
+import { getRegistryIndex } from "../utils/registry.js";
+/**
+ * Command handler to list all available and locally installed Nikala UI components, blocks, and hooks.
+ */
+export async function listCommand(options = {}) {
+    const cwd = process.cwd();
+    const config = await readConfig(cwd);
+    const registryIndex = await getRegistryIndex();
+    if (!registryIndex) {
+        console.log(pc.red("❌ Failed to fetch registry index. Ensure network connection."));
+        process.exit(1);
+    }
+    const componentsDir = config ? path.resolve(cwd, config.alias.components) : path.join(cwd, "src/components/ui");
+    const blocksDir = path.resolve(path.dirname(componentsDir), "blocks");
+    const hooksDir = config && config.alias.hooks ? path.resolve(cwd, config.alias.hooks) : path.join(cwd, "src/hooks");
+    // Inspect status for all items
+    const items = await Promise.all(registryIndex.map(async (item) => {
+        const isHook = item.type === "registry:hook";
+        const isBlock = item.type === "registry:block";
+        const targetDir = isHook ? hooksDir : isBlock ? blocksDir : componentsDir;
+        const tsxPath = path.join(targetDir, `${item.name}.tsx`);
+        const tsPath = path.join(targetDir, `${item.name}.ts`);
+        const isInstalled = (await fs.pathExists(tsxPath)) || (await fs.pathExists(tsPath));
+        return {
+            ...item,
+            isInstalled,
+            installedPath: isInstalled ? (await fs.pathExists(tsxPath) ? tsxPath : tsPath) : null,
+        };
+    }));
+    // Apply filters
+    let filtered = items;
+    if (options.installed) {
+        filtered = filtered.filter((i) => i.isInstalled);
+    }
+    if (options.hook) {
+        filtered = filtered.filter((i) => i.type === "registry:hook");
+    }
+    if (options.block) {
+        filtered = filtered.filter((i) => i.type === "registry:block");
+    }
+    if (options.component) {
+        filtered = filtered.filter((i) => i.type === "registry:ui");
+    }
+    // JSON Output mode
+    if (options.json) {
+        console.log(JSON.stringify(filtered, null, 2));
+        return;
+    }
+    const uiComponents = filtered.filter((i) => i.type === "registry:ui");
+    const blocks = filtered.filter((i) => i.type === "registry:block");
+    const hooks = filtered.filter((i) => i.type === "registry:hook");
+    const installedCount = items.filter((i) => i.isInstalled).length;
+    const installedCompCount = items.filter((i) => i.isInstalled && i.type === "registry:ui").length;
+    const installedBlockCount = items.filter((i) => i.isInstalled && i.type === "registry:block").length;
+    const installedHookCount = items.filter((i) => i.isInstalled && i.type === "registry:hook").length;
+    console.log(`\n📋 ${pc.bold("Nikala UI Registry Catalog")}\n`);
+    // 1. UI Components section
+    if (!options.hook && !options.block && uiComponents.length > 0) {
+        console.log(pc.bold(pc.cyan(`📦 UI Components (${uiComponents.length}):`)));
+        for (const comp of uiComponents) {
+            const status = comp.isInstalled
+                ? pc.green("✓ Installed")
+                : pc.dim("+ Available");
+            const name = comp.isInstalled ? pc.bold(pc.white(comp.name)) : pc.white(comp.name);
+            const desc = comp.description ? pc.dim(` — ${comp.description}`) : "";
+            console.log(`  ${status}  ${name.padEnd(20)} ${desc}`);
+        }
+        console.log("");
+    }
+    // 2. Marketing & App Blocks section
+    if (!options.hook && !options.component && blocks.length > 0) {
+        console.log(pc.bold(pc.yellow(`🧱 Blocks (${blocks.length}):`)));
+        for (const block of blocks) {
+            const status = block.isInstalled
+                ? pc.green("✓ Installed")
+                : pc.dim("+ Available");
+            const name = block.isInstalled ? pc.bold(pc.white(block.name)) : pc.white(block.name);
+            const desc = block.description ? pc.dim(` — ${block.description}`) : "";
+            console.log(`  ${status}  ${name.padEnd(20)} ${desc}`);
+        }
+        console.log("");
+    }
+    // 3. Hooks section
+    if (!options.component && !options.block && hooks.length > 0) {
+        console.log(pc.bold(pc.magenta(`⚡ Reactive Primitives / Hooks (${hooks.length}):`)));
+        for (const hook of hooks) {
+            const status = hook.isInstalled
+                ? pc.green("✓ Installed")
+                : pc.dim("+ Available");
+            const name = hook.isInstalled ? pc.bold(pc.white(hook.name)) : pc.white(hook.name);
+            const desc = hook.description ? pc.dim(` — ${hook.description}`) : "";
+            console.log(`  ${status}  ${name.padEnd(28)} ${desc}`);
+        }
+        console.log("");
+    }
+    // Footer summary
+    console.log(pc.dim(`────────────────────────────────────────────────────────────────────────────`));
+    console.log(`Summary: ${pc.green(`${installedCount} installed`)} (${installedCompCount} UI, ${installedBlockCount} blocks, ${installedHookCount} hooks) · ${pc.cyan(`${registryIndex.length} total in registry`)}`);
+    if (!config) {
+        console.log(pc.yellow(`\n💡 Tip: Run \`nikala init\` in this directory to initialize Nikala UI configuration.`));
+    }
+}

package/dist/index.js

@@ -8,24 +8,33 @@ import { validateCommand } from "./commands/validate.js";
 import { diffCommand } from "./commands/diff.js";
 import { upgradeCommand } from "./commands/upgrade.js";
 import { removeCommand } from "./commands/remove.js";
-console.log(`\n🎨 ${pc.bold(pc.red("Nikala UI"))} ${pc.dim("v0.10.1")} — SolidJS + Tailwind v4 components`);
+import { listCommand } from "./commands/list.js";
+import { setupAiRules } from "./utils/init/setup-ai-rules.js";
+console.log(`\n🎨 ${pc.bold(pc.red("Nikala UI"))} ${pc.dim("v0.11.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.dev"))}\n`);
 const program = new Command();
 program
     .name("nikala")
     .description("Nikala UI — SolidJS + Tailwind v4 components")
-    .version("0.10.1");
+    .version("0.11.0");
 program
     .command("init")
     .description("Initialize Nikala UI in your project")
     .option("-d, --defaults", "Skip prompts and use defaults")
+    .option("--ai", "Generate AI assistant rules (.cursor/rules/nikala.mdc, .cursorrules, AGENTS.md)")
     .action(init);
+program
+    .command("rules")
+    .alias("ai")
+    .description("Generate or update AI assistant rules (.cursor/rules/nikala.mdc, .cursorrules, AGENTS.md)")
+    .action(() => setupAiRules(process.cwd()));
 program
     .command("add [components...]")
-    .description("Add components or reactive hooks to your project")
+    .description("Add components, blocks, or reactive hooks to your project")
     .option("-o, --overwrite", "Overwrite existing files")
     .option("--all", "Add all available items")
+    .option("-b, --block", "Add marketing or app block section(s)")
     .option("-h, --hook", "Add reactive hook primitive(s) instead of UI components")
     .action(add);
 // Upgrade / Update command
@@ -65,4 +74,15 @@ program
     .command("diff [component]")
     .description("Compare local component files against latest registry manifests and view differences")
     .action((component) => diffCommand(component));
+// List / Catalog command
+program
+    .command("list")
+    .alias("ls")
+    .description("List available and locally installed Nikala UI components, blocks, and reactive hooks")
+    .option("-i, --installed", "Show only locally installed items")
+    .option("-c, --component", "Show only UI components")
+    .option("-b, --block", "Show only blocks")
+    .option("-h, --hook", "Show only reactive hooks")
+    .option("--json", "Output results in JSON format")
+    .action((options) => listCommand(options));
 program.parse();

package/dist/types/registry.d.ts

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

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

@@ -1,6 +1,6 @@
 import type { RegistryItem } from "../../types/registry.js";
 /**
- * Writes registry component files to target workspace directories (ui vs providers).
+ * Writes registry component files to target workspace directories (ui vs blocks vs hooks).
  *
  * @param cwd - Working directory path of the target project
  * @param item - Registry item manifest containing files

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

@@ -2,7 +2,7 @@ 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).
+ * Writes registry component files to target workspace directories (ui vs blocks vs hooks).
  *
  * @param cwd - Working directory path of the target project
  * @param item - Registry item manifest containing files
@@ -16,6 +16,14 @@ export async function writeComponentFiles(cwd, item, componentsDir, overwrite =
             const relativePath = file.path.replace(/^ui\//, "");
             targetFilePath = path.join(componentsDir, relativePath);
         }
+        else if (file.path.startsWith("blocks/") || file.type === "registry:block") {
+            const relativePath = file.path.startsWith("blocks/")
+                ? file.path.replace(/^blocks\//, "")
+                : file.path;
+            // Default blocks destination is src/components/blocks
+            const blocksDir = path.resolve(path.dirname(componentsDir), "blocks");
+            targetFilePath = path.join(blocksDir, relativePath);
+        }
         else if (file.path.startsWith("hooks/")) {
             const relativePath = file.path.replace(/^hooks\//, "");
             const hooksDir = path.resolve(cwd, "src/hooks");

package/dist/utils/init/configure-alias.js

@@ -12,36 +12,43 @@ export async function configureAliases(cwd) {
     if (await fs.pathExists(targetConfigPath)) {
         let configContent = await fs.readFile(targetConfigPath, "utf-8");
         let modified = false;
+        // 1. Inject Tailwind CSS v4 Vite plugin if missing
         if (!configContent.includes("@tailwindcss/vite")) {
             configContent = `import tailwindcss from "@tailwindcss/vite";\n${configContent}`;
             if (configContent.includes("plugins: [")) {
                 configContent = configContent.replace("plugins: [", "plugins: [\n    tailwindcss(), ");
+                modified = true;
             }
-            else if (configContent.includes("defineConfig({")) {
-                configContent = configContent.replace("defineConfig({", "defineConfig({\n  plugins: [tailwindcss()],");
+            else {
+                const defineConfigRegex = /(defineConfig\s*\(\s*(?:async\s*)?(?:\([^)]*\)\s*=>\s*)?\{)/;
+                if (defineConfigRegex.test(configContent)) {
+                    configContent = configContent.replace(defineConfigRegex, "$1\n  plugins: [tailwindcss()],");
+                    modified = true;
+                }
             }
-            modified = true;
         }
+        // 2. Inject path alias (@ -> ./src)
         if (!configContent.includes('"@"') && !configContent.includes("'@'")) {
             if (!configContent.includes('import path from "node:path"') && !configContent.includes('import path from "path"')) {
                 configContent = `import path from "node:path";\n${configContent}`;
             }
-            if (configContent.includes("defineConfig({")) {
-                configContent = configContent.replace("defineConfig({", `defineConfig({\n  resolve: {\n    alias: {\n      "@": path.resolve(__dirname, "./src"),\n    },\n  },`);
+            const defineConfigRegex = /(defineConfig\s*\(\s*(?:async\s*)?(?:\([^)]*\)\s*=>\s*)?\{)/;
+            if (defineConfigRegex.test(configContent)) {
+                configContent = configContent.replace(defineConfigRegex, `$1\n  resolve: {\n    alias: {\n      "@": path.resolve(process.cwd(), "./src"),\n    },\n  },`);
+                modified = true;
             }
-            modified = true;
         }
         if (modified) {
             await fs.writeFile(targetConfigPath, configContent, "utf-8");
             console.log(pc.green(`✓ Configured Tailwind CSS v4 plugin and path alias in ${path.basename(targetConfigPath)}`));
         }
     }
+    // 3. Configure tsconfig.json path mappings (@/* -> ./src/*)
     const tsconfigPath = path.join(cwd, "tsconfig.json");
     if (await fs.pathExists(tsconfigPath)) {
         const tsconfig = await readTsConfig(cwd);
         if (tsconfig) {
             tsconfig.compilerOptions = tsconfig.compilerOptions || {};
-            tsconfig.compilerOptions.baseUrl = ".";
             tsconfig.compilerOptions.paths = tsconfig.compilerOptions.paths || {};
             // Correct path mapping with leading relative dot ./src/*
             tsconfig.compilerOptions.paths["@/*"] = ["./src/*"];

package/dist/utils/init/setup-ai-rules.d.ts

@@ -0,0 +1,4 @@
+/**
+ * Sets up AI rules (.cursor/rules/nikala.mdc, .cursorrules, AGENTS.md) in the target workspace.
+ */
+export declare function setupAiRules(cwd: string): Promise<void>;

package/dist/utils/init/setup-ai-rules.js

@@ -0,0 +1,92 @@
+import fs from "fs-extra";
+import path from "node:path";
+import pc from "picocolors";
+const cursorRuleContent = `---
+description: Nikala UI & SolidJS Reactivity Development Rules
+globs: **/*.{ts,tsx,js,jsx}
+alwaysApply: true
+---
+
+# Nikala UI & SolidJS Engineering Guidelines
+
+> Nikala UI is a copy-paste component system and reactive primitives suite for SolidJS built natively for Tailwind CSS v4.
+
+## 1. Strict SolidJS Reactivity Rules
+
+1. **NEVER Destructure Props Directly**:
+   - \`const { variant, class: className } = props;\` -> ❌ **FORBIDDEN** (breaks SolidJS fine-grained signal tracking).
+   - \`const [local, others] = splitProps(props, ["variant", "class"]);\` -> ✅ **REQUIRED**.
+
+2. **Children Inspection & Tab Hydration**:
+   - ALWAYS wrap \`props.children\` with SolidJS's native \`children(() => props.children)\` memoization helper when inspecting, iterating, or rendering dynamic JSX child nodes inside containers or conditional branches.
+
+3. **SSR Safety Guards**:
+   - Always include \`typeof window !== "undefined"\` and \`typeof document !== "undefined"\` guards inside browser event listeners or DOM access logic to prevent SSR hydration crashes in SolidStart environments.
+
+4. **Anti-FOUC Theme Script**:
+   - When using \`ThemeProvider\`, ALWAYS place \`<ThemeScript storageKey="nikala-theme" />\` synchronously inside \`<head>\` or root HTML before \`<ThemeProvider>\` to eliminate flash of unstyled content during SSR.
+
+## 2. Tailwind CSS v4 Native Design Tokens
+
+- All components must use semantic design tokens defined in modern \`@import "tailwindcss";\` setups (\`bg-background\`, \`text-foreground\`, \`bg-card\`, \`border-border\`, \`bg-primary\`, etc.).
+- Avoid hardcoded arbitrary color values; prefer semantic design tokens.
+
+## 3. Pure Copy-Paste Primitives Ownership
+
+- UI components are placed in \`src/components/ui/\` (or configured alias).
+- Reactive hooks are placed in \`src/hooks/\` and imported locally:
+  \`import { createClipboard } from "@/hooks/create-clipboard";\`
+`;
+const rootAgentsRuleContent = `# Nikala UI & SolidJS Development Guidelines
+
+> Nikala UI is a copy-paste component system and reactive primitives suite for SolidJS built natively for Tailwind CSS v4.
+
+## 1. Strict SolidJS Reactivity Rules
+
+1. **NEVER Destructure Props Directly**:
+   - \`const { variant, class: className } = props;\` -> ❌ **FORBIDDEN** (breaks SolidJS fine-grained signal tracking).
+   - \`const [local, others] = splitProps(props, ["variant", "class"]);\` -> ✅ **REQUIRED**.
+
+2. **Children Inspection & Tab Hydration**:
+   - ALWAYS wrap \`props.children\` with SolidJS's native \`children(() => props.children)\` memoization helper when inspecting, iterating, or rendering dynamic JSX child nodes.
+
+3. **SSR Safety Guards**:
+   - Always include \`typeof window !== "undefined"\` and \`typeof document !== "undefined"\` guards inside browser event listeners or DOM access logic.
+
+4. **Anti-FOUC Theme Script**:
+   - When using \`ThemeProvider\`, ALWAYS place \`<ThemeScript storageKey="nikala-theme" />\` synchronously inside \`<head>\` or root HTML before \`<ThemeProvider>\`.
+
+## 2. Tailwind CSS v4 Native Design Tokens
+
+- All components must use semantic design tokens (\`bg-background\`, \`text-foreground\`, \`bg-card\`, \`border-border\`, \`bg-primary\`, etc.).
+
+## 3. Pure Copy-Paste Primitives Ownership
+
+- UI components live in \`src/components/ui/\`.
+- Reactive hooks live in \`src/hooks/\` and are imported locally:
+  \`import { createClipboard } from "@/hooks/create-clipboard";\`
+`;
+/**
+ * Sets up AI rules (.cursor/rules/nikala.mdc, .cursorrules, AGENTS.md) in the target workspace.
+ */
+export async function setupAiRules(cwd) {
+    try {
+        // 1. .cursor/rules/nikala.mdc
+        const cursorRulesDir = path.join(cwd, ".cursor", "rules");
+        await fs.ensureDir(cursorRulesDir);
+        const mdcPath = path.join(cursorRulesDir, "nikala.mdc");
+        await fs.writeFile(mdcPath, cursorRuleContent.trim() + "\n", "utf-8");
+        // 2. .cursorrules (legacy Cursor format)
+        const cursorRulesPath = path.join(cwd, ".cursorrules");
+        await fs.writeFile(cursorRulesPath, rootAgentsRuleContent.trim() + "\n", "utf-8");
+        // 3. AGENTS.md / CLAUDE.md
+        const agentsPath = path.join(cwd, "AGENTS.md");
+        if (!(await fs.pathExists(agentsPath))) {
+            await fs.writeFile(agentsPath, rootAgentsRuleContent.trim() + "\n", "utf-8");
+        }
+        console.log(pc.green("✓ Generated AI assistant rules (.cursor/rules/nikala.mdc, .cursorrules, AGENTS.md)"));
+    }
+    catch (error) {
+        console.log(pc.yellow(`⚠️  Failed to write AI assistant rules: ${error}`));
+    }
+}

package/dist/utils/pkg.js

@@ -1,8 +1,10 @@
 import fs from "fs-extra";
 import path from "node:path";
-import { execSync } from "node:child_process";
+import { execFileSync } from "node:child_process";
 import pc from "picocolors";
 import stripJsonComments from "strip-json-comments";
+// Standard npm package name regex validator (supports scoped packages and version specifiers)
+const NPM_PACKAGE_REGEX = /^(@[a-z0-9-~][a-z0-9-._~]*\/)?[a-z0-9-~][a-z0-9-._~]*(@[a-zA-Z0-9^~.*><=-]+)?$/;
 /**
  * Detects the package manager used in the target project workspace by checking lockfiles.
  *
@@ -47,27 +49,16 @@ export async function installDependencies(dependencies, cwd = process.cwd()) {
             // Failed to parse original package.json
         }
     }
-    const depsString = dependencies.join(" ");
-    let command = "";
-    switch (pkgManager) {
-        case "bun":
-            command = `bun add ${depsString}`;
-            break;
-        case "pnpm":
-            command = `pnpm add ${depsString}`;
-            break;
-        case "yarn":
-            command = `yarn add ${depsString}`;
-            break;
-        case "npm":
-        default:
-            command = `npm install ${depsString}`;
-            break;
-    }
+    // Validate and sanitize dependency names to prevent any shell metacharacter injection
+    const validDeps = dependencies.filter((dep) => NPM_PACKAGE_REGEX.test(dep));
+    if (validDeps.length === 0)
+        return;
+    const subCommand = pkgManager === "npm" ? "install" : "add";
+    const args = [subCommand, ...validDeps];
     console.log(pc.yellow(`\n📦 Installing required component dependencies (${pkgManager})...`));
-    console.log(pc.white(`   ${command}\n`));
+    console.log(pc.white(`   ${pkgManager} ${args.join(" ")}\n`));
     try {
-        execSync(command, { cwd, stdio: "inherit" });
+        execFileSync(pkgManager, args, { cwd, stdio: "inherit" });
         // 2. Validate package.json integrity after installation and restore stripped fields if necessary
         if (originalPkgJson && (await fs.pathExists(pkgPath))) {
             try {
@@ -97,6 +88,6 @@ export async function installDependencies(dependencies, cwd = process.cwd()) {
     }
     catch (error) {
         console.log(pc.red(`❌ Failed to install dependencies automatically.`));
-        console.log(pc.yellow(`   Please run manually: ${command}`));
+        console.log(pc.yellow(`   Please run manually: ${pkgManager} ${args.join(" ")}`));
     }
 }

package/dist/utils/registry.d.ts

@@ -3,23 +3,25 @@ import type { RegistryIndex, RegistryItem } from "../types/registry.js";
 export declare const OFFICIAL_REGISTRY_URL = "https://raw.githubusercontent.com/nikala-ui/ui/main/packages/core/registry";
 /**
  * Reads and parses the central registry index manifest.
- * Bypasses GitHub Raw CDN caching using timestamps and fetches fresh index files.
+ * Prioritizes local monorepo registry during development, and falls back to remote CDN for end-users.
  *
+ * @param customRegistryUrl - Optional custom registry base URL to fetch index from
  * @returns The list of available registry items or null if not found.
  */
-export declare function getRegistryIndex(): Promise<RegistryIndex | null>;
+export declare function getRegistryIndex(customRegistryUrl?: string): Promise<RegistryIndex | null>;
 /**
  * Fetches a component manifest from a remote HTTP(S) URL with cache-busting.
  */
 export declare function fetchRemoteRegistryItem(url: string): Promise<RegistryItem | null>;
 /**
- * Fetches the manifest for a component by name or remote URL.
- * Checks official remote GitHub registry first, then falls back to local package manifest if offline.
+ * Fetches the manifest for a component by name, namespace, or remote URL.
+ * Checks local package manifest first (for monorepo dev & offline), then custom registries from config, and finally official remote GitHub CDN.
  *
- * @param nameOrUrl - Component identifier or full HTTP(S) URL
+ * @param nameOrUrl - Component identifier (e.g. "button", "@acme/hero-01", "https://...")
+ * @param customRegistries - Optional dictionary of custom namespace registries from nikala.config.json
  */
-export declare function getRegistryItem(nameOrUrl: string): Promise<RegistryItem | null>;
+export declare function getRegistryItem(nameOrUrl: string, customRegistries?: Record<string, string>): Promise<RegistryItem | null>;
 /**
  * Recursively resolves all required internal registry dependencies for a set of component names or URLs.
  */
-export declare function resolveRegistryDependencies(namesOrUrls: string[]): Promise<string[]>;
+export declare function resolveRegistryDependencies(namesOrUrls: string[], customRegistries?: Record<string, string>): Promise<string[]>;

package/dist/utils/registry.js

@@ -9,19 +9,40 @@ export const OFFICIAL_REGISTRY_URL = "https://raw.githubusercontent.com/nikala-u
 function getLocalRegistryDirectory() {
     const __filename = fileURLToPath(import.meta.url);
     const __dirname = path.dirname(__filename);
+    // 1. Monorepo development path (packages/core/registry)
+    const monorepoCorePath = path.resolve(__dirname, "../../../core/registry");
+    if (fs.existsSync(monorepoCorePath)) {
+        return monorepoCorePath;
+    }
     return path.resolve(__dirname, "../../registry");
 }
 /**
  * Reads and parses the central registry index manifest.
- * Bypasses GitHub Raw CDN caching using timestamps and fetches fresh index files.
+ * Prioritizes local monorepo registry during development, and falls back to remote CDN for end-users.
  *
+ * @param customRegistryUrl - Optional custom registry base URL to fetch index from
  * @returns The list of available registry items or null if not found.
  */
-export async function getRegistryIndex() {
-    // 1. Attempt fetching online manifest from GitHub Raw CDN with cache-busting
+export async function getRegistryIndex(customRegistryUrl) {
+    const baseUrl = customRegistryUrl || OFFICIAL_REGISTRY_URL;
+    // 1. Prioritize local monorepo registry if present
+    if (!customRegistryUrl) {
+        const localDir = getLocalRegistryDirectory();
+        const indexPath = path.join(localDir, "index.json");
+        if (await fs.pathExists(indexPath)) {
+            try {
+                const content = await fs.readFile(indexPath, "utf-8");
+                return JSON.parse(content);
+            }
+            catch {
+                // Fallback to online CDN
+            }
+        }
+    }
+    // 2. Fetch online manifest from remote CDN with cache-busting
     try {
         const cacheBuster = Date.now();
-        const response = await fetch(`${OFFICIAL_REGISTRY_URL}/index.json?t=${cacheBuster}`, {
+        const response = await fetch(`${baseUrl}/index.json?t=${cacheBuster}`, {
             headers: { "Cache-Control": "no-cache, no-store" },
         });
         if (response.ok) {
@@ -33,18 +54,6 @@ export async function getRegistryIndex() {
     catch {
         // Fallback to local files if offline or network error occurs
     }
-    // 2. Local package fallback
-    const localDir = getLocalRegistryDirectory();
-    const indexPath = path.join(localDir, "index.json");
-    if (await fs.pathExists(indexPath)) {
-        try {
-            const content = await fs.readFile(indexPath, "utf-8");
-            return JSON.parse(content);
-        }
-        catch {
-            return null;
-        }
-    }
     return null;
 }
 /**
@@ -69,21 +78,29 @@ export async function fetchRemoteRegistryItem(url) {
     }
 }
 /**
- * Fetches the manifest for a component by name or remote URL.
- * Checks official remote GitHub registry first, then falls back to local package manifest if offline.
+ * Fetches the manifest for a component by name, namespace, or remote URL.
+ * Checks local package manifest first (for monorepo dev & offline), then custom registries from config, and finally official remote GitHub CDN.
  *
- * @param nameOrUrl - Component identifier or full HTTP(S) URL
+ * @param nameOrUrl - Component identifier (e.g. "button", "@acme/hero-01", "https://...")
+ * @param customRegistries - Optional dictionary of custom namespace registries from nikala.config.json
  */
-export async function getRegistryItem(nameOrUrl) {
+export async function getRegistryItem(nameOrUrl, customRegistries) {
+    // 1. Direct HTTP(S) URL
     if (nameOrUrl.startsWith("http://") || nameOrUrl.startsWith("https://")) {
         return fetchRemoteRegistryItem(nameOrUrl);
     }
-    // 1. Attempt fetching online component manifest from official GitHub CDN
-    const remoteUrl = `${OFFICIAL_REGISTRY_URL}/${nameOrUrl}.json`;
-    const remoteItem = await fetchRemoteRegistryItem(remoteUrl);
-    if (remoteItem)
-        return remoteItem;
-    // 2. Fallback to local package files if offline or unreleased
+    // 2. Custom 3rd-party namespace registry (e.g. "@acme/hero-01")
+    if (nameOrUrl.startsWith("@") && nameOrUrl.includes("/")) {
+        const [namespace, ...rest] = nameOrUrl.split("/");
+        const itemName = rest.join("/");
+        const registryBaseUrl = customRegistries?.[namespace];
+        if (registryBaseUrl) {
+            const cleanBase = registryBaseUrl.replace(/\/$/, "");
+            const remoteUrl = `${cleanBase}/${itemName}.json`;
+            return fetchRemoteRegistryItem(remoteUrl);
+        }
+    }
+    // 3. Local package / Monorepo registry file
     const localDir = getLocalRegistryDirectory();
     const itemPath = path.join(localDir, `${nameOrUrl}.json`);
     if (await fs.pathExists(itemPath)) {
@@ -92,22 +109,24 @@ export async function getRegistryItem(nameOrUrl) {
             return JSON.parse(content);
         }
         catch {
-            return null;
+            // Fallback to online CDN
         }
     }
-    return null;
+    // 4. Official GitHub CDN registry
+    const remoteUrl = `${OFFICIAL_REGISTRY_URL}/${nameOrUrl}.json`;
+    return fetchRemoteRegistryItem(remoteUrl);
 }
 /**
  * Recursively resolves all required internal registry dependencies for a set of component names or URLs.
  */
-export async function resolveRegistryDependencies(namesOrUrls) {
+export async function resolveRegistryDependencies(namesOrUrls, customRegistries) {
     const resolved = new Set();
     const queue = [...namesOrUrls];
     while (queue.length > 0) {
         const current = queue.shift();
         if (!current || resolved.has(current))
             continue;
-        const item = await getRegistryItem(current);
+        const item = await getRegistryItem(current, customRegistries);
         if (!item)
             continue;
         resolved.add(current);

package/dist/utils/theme.js

@@ -171,16 +171,16 @@ export const PRIMARY_COLORS = {
         },
     },
     yellow: {
-        light: "oklch(0.75 0.18 90)",
-        dark: "oklch(0.82 0.16 90)",
+        light: "oklch(0.795 0.184 86.047)",
+        dark: "oklch(0.852 0.199 91.936)",
         lightFg: "oklch(0.1450 0 0)",
         darkFg: "oklch(0.1450 0 0)",
         charts: {
-            chart1: "oklch(0.82 0.18 90)",
-            chart2: "oklch(0.72 0.16 80)",
-            chart3: "oklch(0.62 0.14 100)",
-            chart4: "oklch(0.88 0.12 95)",
-            chart5: "oklch(0.52 0.15 85)",
+            chart1: "oklch(0.795 0.184 86.047)",
+            chart2: "oklch(0.65 0.16 50)",
+            chart3: "oklch(0.55 0.15 85)",
+            chart4: "oklch(0.85 0.12 60)",
+            chart5: "oklch(0.45 0.14 75)",
         },
     },
     lime: {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@nikala-ui/cli",
-  "version": "0.10.1",
+  "version": "0.11.0-nightly.63085f3",
   "description": "Command line interface for Nikala UI",
   "type": "module",
   "main": "./dist/index.js",