fiboui 2.6.3 → 2.7.0

package/README.md

@@ -26,12 +26,12 @@ There is no JSX — the function return **is** the view.
 
 ### Live product
 
-| Marketing site | Store demo |
+| Marketing site | Store (in-app `/shop`) |
 | :---: | :---: |
-| [![FiboUI site](./docs/brand/site-hero.png)](https://fiboui.vercel.app) | [![Fibo Store](./docs/brand/store-hero.png)](https://fiboui-store.vercel.app) |
-| [**fiboui.vercel.app**](https://fiboui.vercel.app) | [**fiboui-store.vercel.app**](https://fiboui-store.vercel.app) |
+| [![FiboUI site](./docs/brand/site-hero.png)](https://fiboui.vercel.app) | [![Fibo Store](./docs/brand/store-hero.png)](https://fiboui.vercel.app/shop) |
+| [**fiboui.vercel.app**](https://fiboui.vercel.app) | [**fiboui.vercel.app/shop**](https://fiboui.vercel.app/shop) |
 
-Both ships are built **only** with FiboUI fluent builders — no JSX in the product UI.
+Both ships are built **only** with FiboUI fluent builders — no JSX in the product UI. The store is `/shop` (alias `/store`). The playground is [`/play`](https://fiboui.vercel.app/play) (alias `/playground`). Same Vercel app, not extra deployments.
 
 </div>
 
@@ -71,7 +71,16 @@ function App() {
 mount('#root', App)
 ```
 
-ESM-only · React **18 / 19** · Next App Router → `'use client'` on files that call builders.
+Tree-shakeable entries (each has its own `types`): `fiboui/core`, `fiboui/layout`, `fiboui/content`, `fiboui/interactive`, `fiboui/structure`, `fiboui/navigation`, `fiboui/theme`, `fiboui/server`.
+
+```tsx
+import { signal } from 'fiboui/core'
+import { Column } from 'fiboui/layout'
+import { Button } from 'fiboui/interactive'
+import { page } from 'fiboui/server'
+```
+
+ESM-only · React **18 / 19** · Next App Router: static builders + `page()` work in Server Components (`fiboui/server` / the `react-server` export); signals / Router still need `'use client'`.
 
 ---
 
@@ -247,6 +256,7 @@ Column().crossAxisAlignment('stretch')
 
 | | |
 | :--- | :--- |
+| Getting started | [`docs/guide/getting-started.md`](./docs/guide/getting-started.md) |
 | Migration from 1.x | [MIGRATION.md](./MIGRATION.md) |
 | Contributing & release | [CONTRIBUTING.md](./CONTRIBUTING.md) |
 | Animation guide | [`docs/guide/animation.md`](./docs/guide/animation.md) |
@@ -266,6 +276,6 @@ Publishing is automated on **`main`** (GitHub Actions + `NPM_TOKEN`). Prefer not
 
 MIT © 2025–2026 FiboUI
 
-[Site](https://fiboui.vercel.app) · [Store](https://fiboui-store.vercel.app) · [npm](https://www.npmjs.com/package/fiboui) · [GitHub](https://github.com/felipeoliveiradev/fiboui)
+[Site](https://fiboui.vercel.app) · [Store](https://fiboui.vercel.app/shop) · [Play](https://fiboui.vercel.app/play) · [npm](https://www.npmjs.com/package/fiboui) · [GitHub](https://github.com/felipeoliveiradev/fiboui)
 
 </div>

package/dist/cli/bin.js

@@ -1,8 +1,8 @@
 #!/usr/bin/env node
 import { createRequire } from 'node:module';
 import { Command } from 'commander';
-import { generateCommand } from './commands/generate';
-import { initCommand } from './commands/init';
+import { generateCommand } from './commands/generate/index.js';
+import { initCommand } from './commands/init.js';
 const require = createRequire(import.meta.url);
 const pkg = require('../../package.json');
 const version = pkg.version;
@@ -11,10 +11,9 @@ program
     .name('fibo')
     .description('FiboUI CLI - Supercharge your development')
     .version(version);
-// ... (version import)
 program.addCommand(initCommand);
 program.addCommand(generateCommand);
-program.parse(process.argv);
+await program.parseAsync(process.argv);
 if (!process.argv.slice(2).length) {
     program.outputHelp();
 }

package/dist/cli/commands/generate/component.js

@@ -4,64 +4,52 @@ import chalk from 'chalk';
 import fs from 'fs-extra';
 import path from 'path';
 import ora from 'ora';
+import { joinBasename, loadFiboConfig, resolveGenerateDir } from '../../config.js';
+import { toPascalCase } from '../../names.js';
+import { componentTemplate } from '../../templates.js';
 export const componentCommand = new Command('component')
     .alias('c')
     .description('Generate a new FiboUI functional component')
     .argument('[name]', 'Name of the component')
     .action(async (name) => {
-    let componentName = name;
-    if (!componentName) {
+    let rawName = name;
+    if (!rawName) {
         const response = await prompts({
             type: 'text',
             name: 'value',
             message: 'What is the name of your Component?',
-            validate: value => value.length < 3 ? 'Component name must be at least 3 characters' : true
+            validate: (value) => (value.length < 3 ? 'Component name must be at least 3 characters' : true),
         });
-        componentName = response.value;
+        rawName = response.value;
     }
+    if (!rawName)
+        process.exit(1);
+    const componentName = toPascalCase(rawName);
     if (!componentName)
         process.exit(1);
     const spinner = ora(`Scaffolding component ${chalk.bold(componentName)}...`).start();
-    // Try to guess location: src/components or current dir
-    const srcComponents = path.resolve(process.cwd(), 'src/components');
-    const targetDir = (await fs.pathExists(srcComponents)) ? srcComponents : process.cwd();
-    // Create folder for component? Or just file? Let's do file for simplicity or folder if preferred.
-    // Standard: src/components/MyComponent/index.tsx
-    const componentDir = path.join(targetDir, componentName);
-    const targetFile = path.join(componentDir, 'index.tsx');
     try {
+        const cwd = process.cwd();
+        const config = await loadFiboConfig(cwd);
+        const srcComponents = path.resolve(cwd, 'src/components');
+        const targetDir = resolveGenerateDir('component', cwd, config, undefined, {
+            componentsDirExists: await fs.pathExists(srcComponents),
+        });
+        const componentDir = joinBasename(targetDir, componentName);
+        const targetFile = joinBasename(componentDir, 'index.tsx');
         if (await fs.pathExists(componentDir)) {
             spinner.fail(`Component ${componentName} already exists at ${componentDir}`);
+            process.exitCode = 1;
             return;
         }
         await fs.ensureDir(componentDir);
-        const content = `import React from 'react';
-import { Component, Text, Row, FiboBuilder } from 'fiboui';
-
-export interface ${componentName}Props {
-  title?: string;
-}
-
-export const ${componentName} = Component<${componentName}Props>()(
-  ({ title = '${componentName}' }) => {
-    return Row()
-      .padding(16)
-      .bg('white')
-      .rounded('lg')
-      .shadow('sm')
-      .children([
-        Text(title).size(18).weight('bold').build()
-      ])
-      .build();
-  }
-);
-`;
-        await fs.writeFile(targetFile, content);
+        await fs.writeFile(targetFile, componentTemplate(componentName));
         spinner.succeed(`Component ${chalk.green(componentName)} created successfully!`);
         console.log(chalk.dim(`\nLocated at: ${targetFile}`));
     }
     catch (error) {
         spinner.fail('Failed to create component');
         console.error(error);
+        process.exitCode = 1;
     }
 });

package/dist/cli/commands/generate/index.js

@@ -1,7 +1,7 @@
 import { Command } from 'commander';
-import { moduleCommand } from './module';
-import { pluginCommand } from './plugin';
-import { componentCommand } from './component';
+import { moduleCommand } from './module.js';
+import { pluginCommand } from './plugin.js';
+import { componentCommand } from './component.js';
 export const generateCommand = new Command('generate')
     .alias('g')
     .description('Generate new architectural components (modules, plugins, etc.)')

package/dist/cli/commands/generate/module.js

@@ -4,55 +4,52 @@ import chalk from 'chalk';
 import fs from 'fs-extra';
 import path from 'path';
 import ora from 'ora';
+import { loadFiboConfig, resolveGenerateDir, resolveUnderRoot } from '../../config.js';
+import { toPascalCase } from '../../names.js';
+import { moduleFiles } from '../../templates.js';
 export const moduleCommand = new Command('module')
     .alias('m')
     .description('Generate a new clean architecture module')
     .argument('[name]', 'Name of the module')
     .action(async (name) => {
-    let moduleName = name;
-    if (!moduleName) {
+    let rawName = name;
+    if (!rawName) {
         const response = await prompts({
             type: 'text',
             name: 'value',
             message: 'What is the name of your module?',
-            validate: value => value.length < 3 ? 'Module name must be at least 3 characters' : true
+            validate: (value) => (value.length < 3 ? 'Module name must be at least 3 characters' : true),
         });
-        moduleName = response.value;
+        rawName = response.value;
     }
+    if (!rawName)
+        process.exit(1);
+    const moduleName = toPascalCase(rawName);
     if (!moduleName)
         process.exit(1);
     const spinner = ora(`Scaffolding module ${chalk.bold(moduleName)}...`).start();
-    // Normalize path: assume we are in project root or src
-    const targetDir = path.resolve(process.cwd(), 'src/modules', moduleName);
     try {
+        const cwd = process.cwd();
+        const config = await loadFiboConfig(cwd);
+        const targetDir = resolveGenerateDir('module', cwd, config, moduleName);
         if (await fs.pathExists(targetDir)) {
             spinner.fail(`Module ${moduleName} already exists at ${targetDir}`);
+            process.exitCode = 1;
             return;
         }
         await fs.ensureDir(targetDir);
-        // 1. Domain Layer
-        await fs.ensureDir(path.join(targetDir, 'domain/entities'));
-        await fs.ensureDir(path.join(targetDir, 'domain/repositories'));
-        await fs.writeFile(path.join(targetDir, 'domain/entities', `${moduleName}.entity.ts`), `export interface ${capitalize(moduleName)} {\n  id: string;\n  // Add properties\n}\n`);
-        await fs.writeFile(path.join(targetDir, 'domain/repositories', `${moduleName}.repository.ts`), `import { ${capitalize(moduleName)} } from '../entities/${moduleName}.entity';\n\nexport interface I${capitalize(moduleName)}Repository {\n  getAll(): Promise<${capitalize(moduleName)}[]>;\n  getById(id: string): Promise<${capitalize(moduleName)} | null>;\n}\n`);
-        // 2. Application Layer (Use Cases)
-        await fs.ensureDir(path.join(targetDir, 'application/usecases'));
-        await fs.writeFile(path.join(targetDir, 'application/usecases', `Get${capitalize(moduleName)}.usecase.ts`), `import { I${capitalize(moduleName)}Repository } from '../../domain/repositories/${moduleName}.repository';\n\nexport class Get${capitalize(moduleName)}UseCase {\n  constructor(private repo: I${capitalize(moduleName)}Repository) {}\n\n  async execute() {\n    return this.repo.getAll();\n  }\n}\n`);
-        // 3. Infrastructure Layer
-        await fs.ensureDir(path.join(targetDir, 'infrastructure/api'));
-        await fs.writeFile(path.join(targetDir, 'infrastructure/api', `${moduleName}.api.ts`), `import { I${capitalize(moduleName)}Repository } from '../../domain/repositories/${moduleName}.repository';\nimport { ${capitalize(moduleName)} } from '../../domain/entities/${moduleName}.entity';\n\nexport class ${capitalize(moduleName)}ApiRepository implements I${capitalize(moduleName)}Repository {\n  async getAll(): Promise<${capitalize(moduleName)}[]> {\n    // Implement API call\n    return [];\n  }\n\n  async getById(id: string): Promise<${capitalize(moduleName)} | null> {\n    return null;\n  }\n}\n`);
-        // 4. Presentation Layer (UI)
-        await fs.ensureDir(path.join(targetDir, 'presentation/components'));
-        await fs.ensureDir(path.join(targetDir, 'presentation/pages'));
-        await fs.writeFile(path.join(targetDir, 'presentation/pages', `${capitalize(moduleName)}Page.tsx`), `import React from 'react';\nimport { Column, Text, FiboBuilder } from 'fiboui';\n\nexport const ${capitalize(moduleName)}Page = () => \n  Column()\n    .center()\n    .gap(20)\n    .children([\n      Text('${capitalize(moduleName)} Module').size(24).weight('bold').build()\n    ])\n    .build();\n`);
+        const files = moduleFiles(moduleName);
+        for (const [rel, content] of Object.entries(files)) {
+            const full = resolveUnderRoot(targetDir, rel);
+            await fs.ensureDir(path.dirname(full));
+            await fs.writeFile(full, content);
+        }
         spinner.succeed(`Module ${chalk.green(moduleName)} created successfully!`);
         console.log(chalk.dim(`\nLocated at: ${targetDir}`));
     }
     catch (error) {
         spinner.fail('Failed to create module');
         console.error(error);
+        process.exitCode = 1;
     }
 });
-function capitalize(str) {
-    return str.charAt(0).toUpperCase() + str.slice(1);
-}

package/dist/cli/commands/generate/plugin.js

@@ -2,60 +2,43 @@ import { Command } from 'commander';
 import prompts from 'prompts';
 import chalk from 'chalk';
 import fs from 'fs-extra';
-import path from 'path';
 import ora from 'ora';
+import { joinBasename, loadFiboConfig, resolveGenerateDir } from '../../config.js';
+import { pluginNames } from '../../names.js';
+import { pluginTemplate } from '../../templates.js';
 export const pluginCommand = new Command('plugin')
     .alias('p')
     .description('Generate a new FiboUI plugin')
     .argument('[name]', 'Name of the plugin')
     .action(async (name) => {
-    let pluginName = name;
-    if (!pluginName) {
+    let rawName = name;
+    if (!rawName) {
         const response = await prompts({
             type: 'text',
             name: 'value',
             message: 'What is the name of your Plugin?',
-            validate: value => value.length < 3 ? 'Plugin name must be at least 3 characters' : true
+            validate: (value) => (value.length < 3 ? 'Plugin name must be at least 3 characters' : true),
         });
-        pluginName = response.value;
+        rawName = response.value;
     }
-    if (!pluginName)
+    if (!rawName)
+        process.exit(1);
+    const { safeName } = pluginNames(rawName);
+    if (!safeName)
         process.exit(1);
-    const safeName = pluginName.endsWith('Plugin') ? pluginName : `${pluginName}Plugin`;
     const spinner = ora(`Scaffolding plugin ${chalk.bold(safeName)}...`).start();
-    const targetDir = path.resolve(process.cwd(), 'src/plugins');
-    const targetFile = path.resolve(targetDir, `${safeName}.ts`);
     try {
+        const cwd = process.cwd();
+        const config = await loadFiboConfig(cwd);
+        const targetDir = resolveGenerateDir('plugin', cwd, config);
+        const targetFile = joinBasename(targetDir, `${safeName}.ts`);
         await fs.ensureDir(targetDir);
         if (await fs.pathExists(targetFile)) {
             spinner.fail(`Plugin ${safeName} already exists at ${targetFile}`);
+            process.exitCode = 1;
             return;
         }
-        const content = `import { FiboPlugin, FiboContext, Card, Text, Icon } from 'fiboui';
-import { Settings } from 'lucide-react';
-
-export const ${safeName}: FiboPlugin = {
-  name: '${safeName}',
-  version: '1.0.0',
-  setup: (ctx: FiboContext) => {
-    console.log('Initializing ${safeName}...');
-
-    // Example: Register Sidebar Item
-    ctx.registerSidebarItem({
-      label: '${pluginName.replace('Plugin', '')}',
-      path: '/${pluginName.toLowerCase().replace('plugin', '')}',
-      icon: Settings, // Example icon
-      order: 10
-    });
-
-    // Example: Register an Overlay
-    // ctx.registerOverlay(() => 
-    //   Card().padding(10).children([ Text('Hello from ${safeName}').build() ]).build()
-    // );
-  }
-};
-`;
-        await fs.writeFile(targetFile, content);
+        await fs.writeFile(targetFile, pluginTemplate(rawName));
         spinner.succeed(`Plugin ${chalk.green(safeName)} created successfully!`);
         console.log(chalk.dim(`\nLocated at: ${targetFile}`));
         console.log(chalk.blue(`\nNext step: Register it in your main.tsx using .plugins([${safeName}])`));
@@ -63,5 +46,6 @@ export const ${safeName}: FiboPlugin = {
     catch (error) {
         spinner.fail('Failed to create plugin');
         console.error(error);
+        process.exitCode = 1;
     }
 });

package/dist/cli/commands/init.js

@@ -3,49 +3,28 @@ import chalk from 'chalk';
 import fs from 'fs-extra';
 import path from 'path';
 import ora from 'ora';
+import { initConfigSource } from '../templates.js';
 export const initCommand = new Command('init')
     .description('Initialize FiboUI configuration')
     .action(async () => {
     const spinner = ora('Checking project structure...').start();
-    const configPath = path.resolve(process.cwd(), 'fibo.config.js'); // Keeping it JS for wider compatibility or TS? User asked for ts.
+    const configPath = path.resolve(process.cwd(), 'fibo.config.js');
     if (await fs.pathExists(configPath)) {
         spinner.fail('fibo.config.js already exists.');
+        process.exitCode = 1;
         return;
     }
-    // Heuristics for standard architecture
     const hasModules = await fs.pathExists(path.resolve(process.cwd(), 'src/modules'));
     const hasPlugins = await fs.pathExists(path.resolve(process.cwd(), 'src/plugins'));
     const hasComponents = await fs.pathExists(path.resolve(process.cwd(), 'src/components'));
     const isStandard = hasModules && hasPlugins && hasComponents;
-    let configContent = '';
+    const configContent = initConfigSource(isStandard);
     if (isStandard) {
         spinner.succeed('Standard FiboUI architecture detected.');
-        configContent = `/** @type {import('fiboui').FiboConfig} */
-module.exports = {
-  paths: {
-    modules: 'src/modules',
-    plugins: 'src/plugins',
-    components: 'src/components',
-    core: 'src/core'
-  },
-  architecture: 'clean'
-};
-`;
     }
     else {
         spinner.warn('Standard architecture NOT detected.');
         console.log(chalk.yellow('Creating configuration with default/empty values. Please update "fibo.config.js" with your project paths.'));
-        configContent = `/** @type {import('fiboui').FiboConfig} */
-module.exports = {
-  paths: {
-    modules: 'src/modules', // Update this
-    plugins: 'src/plugins', // Update this
-    components: 'src/components', // Update this
-    core: 'src/core' // Update this
-  },
-  architecture: 'custom'
-};
-`;
     }
     try {
         await fs.writeFile(configPath, configContent);
@@ -54,5 +33,6 @@ module.exports = {
     }
     catch (error) {
         console.error(chalk.red('Failed to write config file.'), error);
+        process.exitCode = 1;
     }
 });

package/dist/cli/config.js

@@ -0,0 +1,118 @@
+import { execFile } from 'node:child_process';
+import { promisify } from 'node:util';
+import { pathToFileURL } from 'node:url';
+import fs from 'fs-extra';
+import path from 'path';
+const execFileAsync = promisify(execFile);
+const CONFIG_EXPORT_MARK = '__FIBO_CLI_CONFIG__';
+const CONFIG_FILES = ['fibo.config.js', 'fibo.config.mjs', 'fibo.config.cjs'];
+/** Parse `export default { … }` or `module.exports = { … }` data configs. */
+export function parseFiboConfigSource(source) {
+    const trimmed = source.trim();
+    const body = trimmed.match(/export\s+default\s+(\{[\s\S]*\})\s*;?\s*$/)?.[1] ??
+        trimmed.match(/module\.exports\s*=\s*(\{[\s\S]*\})\s*;?\s*$/)?.[1];
+    if (!body)
+        return null;
+    const jsonish = body
+        .replace(/\/\/[^\n]*/g, '')
+        .replace(/'([^'\\]*)'/g, '"$1"')
+        .replace(/([,{]\s*)([A-Za-z_][\w]*)\s*:/g, '$1"$2":')
+        .replace(/,(\s*[}\]])/g, '$1');
+    try {
+        const cfg = JSON.parse(jsonish);
+        if (!cfg || typeof cfg !== 'object')
+            return null;
+        return { paths: cfg.paths ?? {}, architecture: cfg.architecture };
+    }
+    catch {
+        return null;
+    }
+}
+function normalizeFiboConfig(raw) {
+    if (!raw || typeof raw !== 'object' || Array.isArray(raw))
+        return null;
+    const cfg = raw;
+    if (cfg.paths != null && (typeof cfg.paths !== 'object' || Array.isArray(cfg.paths)))
+        return null;
+    return { paths: cfg.paths ?? {}, architecture: cfg.architecture };
+}
+/** Load `fibo.config.*` as a real Node module (computed ESM/CJS), not a JSON-ish regex. */
+async function importConfigModule(full) {
+    const href = pathToFileURL(full).href;
+    const script = `import(${JSON.stringify(href)}).then((m)=>{process.stdout.write(${JSON.stringify(CONFIG_EXPORT_MARK)}+JSON.stringify(m.default??null))})`;
+    const { stdout } = await execFileAsync(process.execPath, ['--input-type=module', '-e', script], {
+        timeout: 8000,
+        maxBuffer: 256 * 1024,
+        windowsHide: true,
+        encoding: 'utf8',
+    });
+    const idx = stdout.lastIndexOf(CONFIG_EXPORT_MARK);
+    if (idx === -1)
+        return undefined;
+    return JSON.parse(stdout.slice(idx + CONFIG_EXPORT_MARK.length));
+}
+export async function loadFiboConfig(cwd) {
+    for (const name of CONFIG_FILES) {
+        const full = path.resolve(cwd, name);
+        if (!(await fs.pathExists(full)))
+            continue;
+        let loaded = null;
+        try {
+            loaded = normalizeFiboConfig(await importConfigModule(full));
+        }
+        catch {
+            loaded = null;
+        }
+        if (!loaded) {
+            const source = await fs.readFile(full, 'utf8');
+            loaded = parseFiboConfigSource(source);
+        }
+        if (!loaded) {
+            throw new Error(`Invalid ${name}: could not load FiboUI config`);
+        }
+        return loaded;
+    }
+    return null;
+}
+export function isInsideRoot(root, target) {
+    const resolvedRoot = path.resolve(root);
+    const resolvedTarget = path.resolve(target);
+    const rel = path.relative(resolvedRoot, resolvedTarget);
+    return rel === '' || (rel !== '..' && !rel.startsWith(`..${path.sep}`) && !path.isAbsolute(rel));
+}
+/** Join `dir` with a single path segment. Rejects `..`, separators, and empty names. */
+export function joinBasename(dir, name) {
+    if (typeof name !== 'string' || name.length === 0 || name === '.' || name === '..' || name.includes('\0')) {
+        throw new Error(`Invalid path segment: ${name}`);
+    }
+    if (/[/\\]/.test(name) || path.basename(name) !== name) {
+        throw new Error(`Invalid path segment: ${name}`);
+    }
+    const resolved = path.resolve(dir, name);
+    if (!isInsideRoot(dir, resolved)) {
+        throw new Error(`Invalid path segment: ${name}`);
+    }
+    return resolved;
+}
+export function resolveUnderRoot(root, rel) {
+    if (typeof rel !== 'string' || rel.trim() === '') {
+        throw new Error(`Path escapes project: ${rel}`);
+    }
+    const resolved = path.resolve(root, rel);
+    if (!isInsideRoot(root, resolved)) {
+        throw new Error(`Path escapes project: ${rel}`);
+    }
+    return resolved;
+}
+export function resolveGenerateDir(kind, cwd, config, extra, opts) {
+    const paths = config?.paths ?? {};
+    if (kind === 'component') {
+        const rel = paths.components ?? (opts?.componentsDirExists ? 'src/components' : null);
+        return rel ? resolveUnderRoot(cwd, rel) : path.resolve(cwd);
+    }
+    if (kind === 'plugin') {
+        return resolveUnderRoot(cwd, paths.plugins ?? 'src/plugins');
+    }
+    const modulesRoot = resolveUnderRoot(cwd, paths.modules ?? 'src/modules');
+    return extra ? joinBasename(modulesRoot, extra) : modulesRoot;
+}

package/dist/cli/names.js

@@ -0,0 +1,35 @@
+/** Turn `my-card` / `user_profile` / `Hero` into a TS identifier. */
+export function toPascalCase(name) {
+    if (name == null)
+        return '';
+    const parts = String(name)
+        .replace(/[^a-zA-Z0-9]+/g, ' ')
+        .trim()
+        .split(/\s+/)
+        .filter(Boolean);
+    if (parts.length === 0)
+        return '';
+    const ident = parts.map((part) => part.charAt(0).toUpperCase() + part.slice(1)).join('');
+    return /^[0-9]/.test(ident) ? `N${ident}` : ident;
+}
+export function toKebabCase(name) {
+    const pascal = toPascalCase(name);
+    return pascal
+        .replace(/([a-z0-9])([A-Z])/g, '$1-$2')
+        .replace(/([A-Z]+)([A-Z][a-z])/g, '$1-$2')
+        .toLowerCase();
+}
+export function pluginNames(raw) {
+    const pascal = toPascalCase(raw);
+    if (!pascal)
+        return { safeName: '', label: '', path: '' };
+    // Strip a redundant "Plugin" suffix, but keep the stem when the name is only "Plugin"
+    // (otherwise label is empty and the sidebar path becomes "/").
+    const stripped = pascal.endsWith('Plugin') ? pascal.slice(0, -'Plugin'.length) : pascal;
+    const base = stripped || pascal;
+    return {
+        safeName: `${stripped}Plugin`,
+        label: base,
+        path: `/${toKebabCase(base)}`,
+    };
+}

package/dist/cli/templates.js

@@ -0,0 +1,76 @@
+import { pluginNames, toPascalCase } from './names.js';
+/** 2.0 playground style: builders are React nodes, 2-space indent, no `.build()`. */
+export function componentTemplate(name) {
+    const componentName = toPascalCase(name);
+    return `import { Row, Text } from 'fiboui';
+
+export interface ${componentName}Props {
+  title?: string;
+}
+
+export function ${componentName}({ title = '${componentName}' }: ${componentName}Props) {
+  return Row()
+    .padding(16)
+    .bg('white')
+    .rounded('lg')
+    .shadow('sm')
+    .children([
+      Text(title).fontSize(18).fontWeight('bold'),
+    ]);
+}
+`;
+}
+export function pluginTemplate(raw) {
+    const { safeName, label, path } = pluginNames(raw);
+    return `import type { FiboPlugin, FiboContext } from 'fiboui';
+
+export const ${safeName}: FiboPlugin = {
+  name: '${safeName}',
+  version: '1.0.0',
+  setup: (ctx: FiboContext) => {
+    ctx.registerSidebarItem({
+      label: '${label}',
+      path: '${path}',
+      order: 10,
+    });
+  },
+};
+`;
+}
+export function modulePageTemplate(name) {
+    const moduleName = toPascalCase(name);
+    return `import { Column, Text } from 'fiboui';
+
+export function ${moduleName}Page() {
+  return Column()
+    .center()
+    .gap(20)
+    .children([
+      Text('${moduleName} Module').variant('h2'),
+    ]);
+}
+`;
+}
+export function moduleFiles(name) {
+    const moduleName = toPascalCase(name);
+    return {
+        [`domain/entities/${moduleName}.entity.ts`]: `export interface ${moduleName} {\n  id: string;\n}\n`,
+        [`domain/repositories/${moduleName}.repository.ts`]: `import { ${moduleName} } from '../entities/${moduleName}.entity';\n\nexport interface I${moduleName}Repository {\n  getAll(): Promise<${moduleName}[]>;\n  getById(id: string): Promise<${moduleName} | null>;\n}\n`,
+        [`application/usecases/Get${moduleName}.usecase.ts`]: `import { I${moduleName}Repository } from '../../domain/repositories/${moduleName}.repository';\n\nexport class Get${moduleName}UseCase {\n  constructor(private repo: I${moduleName}Repository) {}\n\n  async execute() {\n    return this.repo.getAll();\n  }\n}\n`,
+        [`infrastructure/api/${moduleName}.api.ts`]: `import { I${moduleName}Repository } from '../../domain/repositories/${moduleName}.repository';\nimport { ${moduleName} } from '../../domain/entities/${moduleName}.entity';\n\nexport class ${moduleName}ApiRepository implements I${moduleName}Repository {\n  async getAll(): Promise<${moduleName}[]> {\n    return [];\n  }\n\n  async getById(id: string): Promise<${moduleName} | null> {\n    return null;\n  }\n}\n`,
+        [`presentation/pages/${moduleName}Page.tsx`]: modulePageTemplate(moduleName),
+    };
+}
+export function initConfigSource(isStandard) {
+    const note = isStandard ? '' : ' // Update this';
+    return `export default {
+  paths: {
+    modules: 'src/modules',${note}
+    plugins: 'src/plugins',${note}
+    components: 'src/components',${note}
+    core: 'src/core',${note}
+  },
+  architecture: '${isStandard ? 'clean' : 'custom'}',
+};
+`;
+}