create-bunli 0.8.0 → 0.8.2

package/templates/advanced/src/commands/serve.ts

@@ -1,113 +1,107 @@
-import { defineCommand, option } from '@bunli/core'
-import { z } from 'zod'
-import { loadConfig } from '../utils/config.js'
+import { defineCommand, option } from "@bunli/core";
+import { z } from "zod";
+
+import { loadConfig } from "../utils/config.js";
 
 const serveCommand = defineCommand({
-  name: 'serve',
-  description: 'Start a development server',
+  name: "serve",
+  description: "Start a development server",
   options: {
-    port: option(
-      z.coerce.number().int().min(1).max(65535).default(3000),
-      {
-        short: 'p',
-        description: 'Port to listen on'
-      }
-    ),
-    host: option(
-      z.string().default('localhost'),
-      {
-        short: 'h',
-        description: 'Host to bind to'
-      }
-    ),
-    open: option(
-      z.boolean().default(true),
-      {
-        description: 'Open browser on start',
-        argumentKind: 'flag'
-      }
-    )
+    port: option(z.coerce.number().int().min(1).max(65535).default(3000), {
+      short: "p",
+      description: "Port to listen on",
+    }),
+    host: option(z.string().default("localhost"), {
+      short: "h",
+      description: "Host to bind to",
+    }),
+    open: option(z.boolean().default(true), {
+      description: "Open browser on start",
+      argumentKind: "flag",
+    }),
   },
   handler: async ({ flags, colors, spinner, shell }) => {
-    const spin = spinner('Starting server...')
-    spin.start()
-    
+    const spin = spinner("Starting server...");
+    spin.start();
+
     try {
       // Load config
-      const config = await loadConfig()
-      
+      const config = await loadConfig();
+
       // Merge flags with config
-      const port = flags.port || config.server?.port || 3000
-      const host = flags.host || config.server?.host || 'localhost'
-      const shouldOpen = flags.open ?? config.server?.open ?? true
-      
+      const port = flags.port || config.server?.port || 3000;
+      const host = flags.host || config.server?.host || "localhost";
+      const shouldOpen = flags.open ?? config.server?.open ?? true;
+
       // Create server
       const server = Bun.serve({
         port,
         hostname: host,
         fetch(req) {
-          const url = new URL(req.url)
-          
+          const url = new URL(req.url);
+
           // Simple router
-          if (url.pathname === '/') {
+          if (url.pathname === "/") {
             return new Response(getHomePage(), {
-              headers: { 'Content-Type': 'text/html' }
-            })
+              headers: { "Content-Type": "text/html" },
+            });
           }
-          
-          if (url.pathname === '/api/status') {
+
+          if (url.pathname === "/api/status") {
             return Response.json({
-              status: 'ok',
-              version: '0.1.0',
-              uptime: process.uptime()
-            })
+              status: "ok",
+              version: "0.1.0",
+              uptime: process.uptime(),
+            });
           }
-          
-          return new Response('Not Found', { status: 404 })
-        }
-      })
-      
-      spin.succeed(`Server running at http://${host}:${port}`)
-      
+
+          return new Response("Not Found", { status: 404 });
+        },
+      });
+
+      spin.succeed(`Server running at http://${host}:${port}`);
+
       // Open browser
       if (shouldOpen) {
-        const openSpin = spinner('Opening browser...')
-        openSpin.start()
-        
+        const openSpin = spinner("Opening browser...");
+        openSpin.start();
+
         try {
-          const url = `http://${host === '0.0.0.0' ? 'localhost' : host}:${port}`
-          
+          const url = `http://${host === "0.0.0.0" ? "localhost" : host}:${port}`;
+
           // Platform-specific open commands
-          const openCommand = process.platform === 'darwin' ? 'open' :
-                            process.platform === 'win32' ? 'start' :
-                            'xdg-open'
-          
-          await shell`${openCommand} ${url}`.quiet()
-          openSpin.succeed('Browser opened')
+          const openCommand =
+            process.platform === "darwin"
+              ? "open"
+              : process.platform === "win32"
+                ? "start"
+                : "xdg-open";
+
+          await shell`${openCommand} ${url}`.quiet();
+          openSpin.succeed("Browser opened");
         } catch {
-          openSpin.fail('Failed to open browser')
+          openSpin.fail("Failed to open browser");
         }
       }
-      
+
       // Keep server running
-      console.log()
-      console.log(colors.dim('Press Ctrl+C to stop the server'))
-      
+      console.log();
+      console.log(colors.dim("Press Ctrl+C to stop the server"));
+
       // Handle shutdown
-      process.on('SIGINT', () => {
-        console.log()
-        console.log(colors.yellow('Shutting down server...'))
-        server.stop()
-        process.exit(0)
-      })
-      
+      process.on("SIGINT", () => {
+        console.log();
+        console.log(colors.yellow("Shutting down server..."));
+        server.stop();
+        process.exit(0);
+      });
     } catch (error) {
-      spin.fail('Failed to start server')
-      console.error(colors.red(String(error)))
-      process.exit(1)
+      spin.fail("Failed to start server");
+      console.error(colors.red(String(error)));
+      process.exit(1);
     }
-  }
-})
+  },
+});
 
 function getHomePage(): string {
   return `
@@ -173,7 +167,7 @@ function getHomePage(): string {
   </div>
 </body>
 </html>
-  `.trim()
+  `.trim();
 }
 
-export default serveCommand
+export default serveCommand;

package/templates/advanced/src/commands/validate.ts

@@ -1,115 +1,107 @@
-import { defineCommand, option } from '@bunli/core'
-import { z } from 'zod'
-import { loadConfig } from '../utils/config.js'
-import { validateFiles } from '../utils/validator.js'
-import { glob } from '../utils/glob.js'
+import { defineCommand, option } from "@bunli/core";
+import { z } from "zod";
+
+import { loadConfig } from "../utils/config.js";
+import { glob } from "../utils/glob.js";
+import { validateFiles } from "../utils/validator.js";
 
 const validateCommand = defineCommand({
-  name: 'validate',
-  description: 'Validate files against defined rules',
+  name: "validate",
+  description: "Validate files against defined rules",
   options: {
-    config: option(
-      z.string().optional(),
-      {
-        short: 'c',
-        description: 'Path to config file'
-      }
-    ),
-    fix: option(
-      z.boolean().default(false),
-      {
-        short: 'f',
-        description: 'Auto-fix issues',
-        argumentKind: 'flag'
-      }
-    ),
-    cache: option(
-      z.boolean().default(true),
-      {
-        description: 'Enable caching',
-        argumentKind: 'flag'
-      }
-    )
+    config: option(z.string().optional(), {
+      short: "c",
+      description: "Path to config file",
+    }),
+    fix: option(z.boolean().default(false), {
+      short: "f",
+      description: "Auto-fix issues",
+      argumentKind: "flag",
+    }),
+    cache: option(z.boolean().default(true), {
+      description: "Enable caching",
+      argumentKind: "flag",
+    }),
   },
   handler: async ({ positional, flags, colors, spinner }) => {
-    const spin = spinner('Loading configuration...')
-    spin.start()
+    const spin = spinner("Loading configuration...");
+    spin.start();
 
     try {
-      const config = await loadConfig(flags.config)
-      spin.succeed('Configuration loaded')
+      const config = await loadConfig(flags.config);
+      spin.succeed("Configuration loaded");
 
-      const patterns = positional.length > 0 ? positional : config.include || ['src/**/*.{js,ts}']
+      const patterns = positional.length > 0 ? positional : config.include || ["src/**/*.{js,ts}"];
 
-      const fileSpin = spinner('Resolving files...')
-      fileSpin.start()
+      const fileSpin = spinner("Resolving files...");
+      fileSpin.start();
 
       const files = await glob(patterns, {
         include: config.include,
-        exclude: config.exclude
-      })
+        exclude: config.exclude,
+      });
 
-      fileSpin.succeed(`Found ${files.length} files to validate`)
+      fileSpin.succeed(`Found ${files.length} files to validate`);
 
       if (files.length === 0) {
-        console.log(colors.yellow('No files matched the pattern'))
-        return
+        console.log(colors.yellow("No files matched the pattern"));
+        return;
       }
 
-      const validateSpin = spinner('Validating files...')
-      validateSpin.start()
+      const validateSpin = spinner("Validating files...");
+      validateSpin.start();
 
       const results = await validateFiles(files, {
         rules: config.rules,
         fix: flags.fix,
-        cache: flags.cache && config.cache?.enabled
-      })
+        cache: flags.cache && config.cache?.enabled,
+      });
 
-      validateSpin.stop()
+      validateSpin.stop();
 
-      let hasErrors = false
+      let hasErrors = false;
 
       for (const result of results) {
         if (result.errors.length > 0 || result.warnings.length > 0) {
-          console.log()
-          console.log(colors.bold(result.file))
+          console.log();
+          console.log(colors.bold(result.file));
 
           for (const error of result.errors) {
-            console.log(colors.red(`  ✗ ${error.line}:${error.column} ${error.message}`))
-            hasErrors = true
+            console.log(colors.red(`  ✗ ${error.line}:${error.column} ${error.message}`));
+            hasErrors = true;
           }
 
           for (const warning of result.warnings) {
-            console.log(colors.yellow(`  ⚠ ${warning.line}:${warning.column} ${warning.message}`))
+            console.log(colors.yellow(`  ⚠ ${warning.line}:${warning.column} ${warning.message}`));
           }
         }
       }
 
-      const totalErrors = results.reduce((sum, r) => sum + r.errors.length, 0)
-      const totalWarnings = results.reduce((sum, r) => sum + r.warnings.length, 0)
+      const totalErrors = results.reduce((sum, r) => sum + r.errors.length, 0);
+      const totalWarnings = results.reduce((sum, r) => sum + r.warnings.length, 0);
 
-      console.log()
+      console.log();
       if (totalErrors === 0 && totalWarnings === 0) {
-        console.log(colors.green('✅ All files passed validation!'))
+        console.log(colors.green("✅ All files passed validation!"));
       } else {
-        console.log(colors.bold('Summary:'))
+        console.log(colors.bold("Summary:"));
         if (totalErrors > 0) {
-          console.log(colors.red(`  ${totalErrors} error${totalErrors !== 1 ? 's' : ''}`))
+          console.log(colors.red(`  ${totalErrors} error${totalErrors !== 1 ? "s" : ""}`));
         }
         if (totalWarnings > 0) {
-          console.log(colors.yellow(`  ${totalWarnings} warning${totalWarnings !== 1 ? 's' : ''}`))
+          console.log(colors.yellow(`  ${totalWarnings} warning${totalWarnings !== 1 ? "s" : ""}`));
         }
 
         if (hasErrors) {
-          process.exit(1)
+          process.exit(1);
         }
       }
     } catch (error) {
-      spin.fail('Validation failed')
-      console.error(colors.red(String(error)))
-      process.exit(1)
+      spin.fail("Validation failed");
+      console.error(colors.red(String(error)));
+      process.exit(1);
     }
-  }
-})
+  },
+});
 
-export default validateCommand
+export default validateCommand;

package/templates/advanced/src/index.ts

@@ -1,55 +1,56 @@
 #!/usr/bin/env bun
-import { createCLI } from '@bunli/core'
-import { Result, TaggedError } from 'better-result'
-import initCommand from './commands/init.js'
-import validateCommand from './commands/validate.js'
-import serveCommand from './commands/serve.js'
-import configCommand from './commands/config.js'
-import { loadConfig } from './utils/config.js'
+import { createCLI } from "@bunli/core";
+import { Result, TaggedError } from "better-result";
+
+import configCommand from "./commands/config.js";
+import initCommand from "./commands/init.js";
+import serveCommand from "./commands/serve.js";
+import validateCommand from "./commands/validate.js";
+import { loadConfig } from "./utils/config.js";
 
 const toErrorMessage = (error: unknown): string =>
-  error instanceof Error ? error.message : String(error)
+  error instanceof Error ? error.message : String(error);
 
-class CliStartupError extends TaggedError('CliStartupError')<{
-  message: string
-  cause: unknown
+class CliStartupError extends TaggedError("CliStartupError")<{
+  message: string;
+  cause: unknown;
 }>() {
   constructor(cause: unknown) {
-    super({ message: `Failed to start CLI: ${toErrorMessage(cause)}`, cause })
+    super({ message: `Failed to start CLI: ${toErrorMessage(cause)}`, cause });
   }
 }
 
 const cli = await createCLI({
-  name: '{{name}}',
-  version: '0.1.0',
-  description: '{{description}}'
-})
+  name: "{{name}}",
+  version: "0.1.0",
+  description: "{{description}}",
+});
 
-cli.command(initCommand)
-cli.command(validateCommand)
-cli.command(serveCommand)
-cli.command(configCommand)
+cli.command(initCommand);
+cli.command(validateCommand);
+cli.command(serveCommand);
+cli.command(configCommand);
 
 async function run(): Promise<Result<void, CliStartupError>> {
   const configResult = await Result.tryPromise({
     try: () => loadConfig(),
-    catch: (cause) => new CliStartupError(cause)
-  })
+    catch: (cause) => new CliStartupError(cause),
+  });
 
   if (Result.isError(configResult)) {
-    return configResult
+    return configResult;
   }
 
   return Result.tryPromise({
     try: async () => {
-      await cli.run()
+      await cli.run();
     },
-    catch: (cause) => new CliStartupError(cause)
-  })
+    catch: (cause) => new CliStartupError(cause),
+  });
 }
 
-const result = await run()
+const result = await run();
 if (Result.isError(result)) {
-  console.error(result.error.message)
-  process.exit(1)
+  console.error(result.error.message);
+  process.exit(1);
 }

package/templates/advanced/src/utils/config.ts

@@ -1,84 +1,85 @@
-import { CONFIG_FILE_NAME, DEFAULT_CONFIG } from './constants.js'
-import path from 'node:path'
+import path from "node:path";
+
+import { CONFIG_FILE_NAME, DEFAULT_CONFIG } from "./constants.js";
 
 export interface Config {
-  rules?: Record<string, any>
+  rules?: Record<string, any>;
   server?: {
-    port?: number
-    host?: string
-    open?: boolean
-    cors?: boolean
-  }
-  include?: string[]
-  exclude?: string[]
+    port?: number;
+    host?: string;
+    open?: boolean;
+    cors?: boolean;
+  };
+  include?: string[];
+  exclude?: string[];
   cache?: {
-    enabled?: boolean
-    directory?: string
-  }
+    enabled?: boolean;
+    directory?: string;
+  };
   hooks?: {
-    beforeValidate?: (files: string[]) => Promise<void>
-    afterValidate?: (results: any) => Promise<void>
-  }
+    beforeValidate?: (files: string[]) => Promise<void>;
+    afterValidate?: (results: any) => Promise<void>;
+  };
 }
 
-let cachedConfig: Config | null = null
+let cachedConfig: Config | null = null;
 
 export async function loadConfig(configPath?: string): Promise<Config> {
   // Return cached config if available
   if (cachedConfig && !configPath) {
-    return cachedConfig
+    return cachedConfig;
   }
-  
-  const finalPath = configPath || path.join(process.cwd(), CONFIG_FILE_NAME)
-  
+
+  const finalPath = configPath || path.join(process.cwd(), CONFIG_FILE_NAME);
+
   try {
     // Check if config file exists
-    const file = Bun.file(finalPath)
+    const file = Bun.file(finalPath);
     if (!(await file.exists())) {
-      return DEFAULT_CONFIG
+      return DEFAULT_CONFIG;
     }
-    
+
     // Import the config file
-    const configModule = await import(finalPath)
-    const config = configModule.default || configModule
-    
+    const configModule = await import(finalPath);
+    const config = configModule.default || configModule;
+
     // Merge with defaults
     const mergedConfig: Config = {
       ...DEFAULT_CONFIG,
       ...config,
       server: {
         ...DEFAULT_CONFIG.server,
-        ...(config.server || {})
-      }
-    }
+        ...(config.server || {}),
+      },
+    };
 
-    cachedConfig = mergedConfig
-    return mergedConfig
+    cachedConfig = mergedConfig;
+    return mergedConfig;
   } catch (error) {
-    console.warn(`Failed to load config from ${finalPath}:`, error)
-    return DEFAULT_CONFIG
+    console.warn(`Failed to load config from ${finalPath}:`, error);
+    return DEFAULT_CONFIG;
   }
 }
 
 export async function saveConfig(config: Config): Promise<void> {
-  const configPath = path.join(process.cwd(), CONFIG_FILE_NAME)
-  
+  const configPath = path.join(process.cwd(), CONFIG_FILE_NAME);
+
   // Convert config to ES module format
-  const content = `export default ${JSON.stringify(config, null, 2)}`
-  
-  await Bun.write(configPath, content)
-  
+  const content = `export default ${JSON.stringify(config, null, 2)}`;
+
+  await Bun.write(configPath, content);
+
   // Clear cache
-  cachedConfig = null
+  cachedConfig = null;
 }
 
 export async function getConfigPath(): Promise<string> {
-  const configPath = path.join(process.cwd(), CONFIG_FILE_NAME)
-  const file = Bun.file(configPath)
-  
+  const configPath = path.join(process.cwd(), CONFIG_FILE_NAME);
+  const file = Bun.file(configPath);
+
   if (await file.exists()) {
-    return configPath
+    return configPath;
   }
-  
-  return 'No config file found'
+
+  return "No config file found";
 }

package/templates/advanced/src/utils/constants.ts

@@ -1,12 +1,12 @@
-export const CONFIG_FILE_NAME = '{{name}}.config.js'
+export const CONFIG_FILE_NAME = "{{name}}.config.js";
 
 export const DEFAULT_CONFIG = {
   rules: {},
   server: {
     port: 3000,
-    host: 'localhost',
-    open: true
+    host: "localhost",
+    open: true,
   },
-  include: ['src/**/*.{js,ts}'],
-  exclude: ['node_modules', 'dist']
-}
+  include: ["src/**/*.{js,ts}"],
+  exclude: ["node_modules", "dist"],
+};