create-bunli 0.8.0 → 0.8.2

package/dist/templates/advanced/src/commands/init.ts

@@ -1,75 +1,68 @@
-import { defineCommand, option } from '@bunli/core'
-import { z } from 'zod'
-import { CONFIG_FILE_NAME, DEFAULT_CONFIG } from '../utils/constants.js'
+import { defineCommand, option } from "@bunli/core";
+import { z } from "zod";
+
+import { CONFIG_FILE_NAME, DEFAULT_CONFIG } from "../utils/constants.js";
 
 const initCommand = defineCommand({
-  name: 'init',
-  description: 'Initialize a new configuration file',
+  name: "init",
+  description: "Initialize a new configuration file",
   options: {
-    force: option(
-      z.boolean().default(false),
-      { 
-        short: 'f',
-        description: 'Overwrite existing config',
-        argumentKind: 'flag'
-      }
-    ),
-    template: option(
-      z.enum(['minimal', 'default', 'full']).default('default'),
-      {
-        short: 't',
-        description: 'Config template to use'
-      }
-    )
+    force: option(z.boolean().default(false), {
+      short: "f",
+      description: "Overwrite existing config",
+      argumentKind: "flag",
+    }),
+    template: option(z.enum(["minimal", "default", "full"]).default("default"), {
+      short: "t",
+      description: "Config template to use",
+    }),
   },
   handler: async ({ flags, colors, prompt, spinner }) => {
-    const configPath = `${process.cwd()}/${CONFIG_FILE_NAME}`
-    
+    const configPath = `${process.cwd()}/${CONFIG_FILE_NAME}`;
+
     // Check if config already exists
-    const configFile = Bun.file(configPath)
-    if (await configFile.exists() && !flags.force) {
-      const overwrite = await prompt.confirm(
-        `Config file already exists. Overwrite?`,
-        { default: false }
-      )
-      
+    const configFile = Bun.file(configPath);
+    if ((await configFile.exists()) && !flags.force) {
+      const overwrite = await prompt.confirm(`Config file already exists. Overwrite?`, {
+        default: false,
+      });
+
       if (!overwrite) {
-        console.log(colors.yellow('Init cancelled'))
-        return
+        console.log(colors.yellow("Init cancelled"));
+        return;
       }
     }
-    
-    const spin = spinner('Creating config file...')
-    spin.start()
-    
+
+    const spin = spinner("Creating config file...");
+    spin.start();
+
     try {
       // Get template content
-      const configContent = getConfigTemplate(flags.template)
-      
+      const configContent = getConfigTemplate(flags.template);
+
       // Write config file
-      await Bun.write(configPath, configContent)
-      
-      spin.succeed('Config file created')
-      console.log(colors.dim(`  ${CONFIG_FILE_NAME}`))
-      
+      await Bun.write(configPath, configContent);
+
+      spin.succeed("Config file created");
+      console.log(colors.dim(`  ${CONFIG_FILE_NAME}`));
+
       // Next steps
-      console.log()
-      console.log('Next steps:')
-      console.log(colors.gray(`  1. Edit ${CONFIG_FILE_NAME} to customize your configuration`))
-      console.log(colors.gray(`  2. Run '{{name}} validate' to check your files`))
-      
+      console.log();
+      console.log("Next steps:");
+      console.log(colors.gray(`  1. Edit ${CONFIG_FILE_NAME} to customize your configuration`));
+      console.log(colors.gray(`  2. Run '{{name}} validate' to check your files`));
     } catch (error) {
-      spin.fail('Failed to create config file')
-      console.error(colors.red(String(error)))
-      process.exit(1)
+      spin.fail("Failed to create config file");
+      console.error(colors.red(String(error)));
+      process.exit(1);
     }
-  }
-})
+  },
+});
 
-function getConfigTemplate(template: 'minimal' | 'default' | 'full'): string {
+function getConfigTemplate(template: "minimal" | "default" | "full"): string {
   const templates = {
     minimal: `export default ${JSON.stringify(DEFAULT_CONFIG, null, 2)}`,
-    
+
     default: `export default {
   // Validation rules
   rules: {
@@ -89,7 +82,7 @@ function getConfigTemplate(template: 'minimal' | 'default' | 'full'): string {
   include: ['src/**/*.{js,ts}'],
   exclude: ['node_modules', 'dist', 'test'],
 }`,
-    
+
     full: `import { defineConfig } from '{{name}}'
 
 export default defineConfig({
@@ -147,10 +140,10 @@ export default defineConfig({
       console.log(\`Found \${results.errors} errors and \${results.warnings} warnings\`)
     },
   },
-})`
-  }
-  
-  return templates[template]
+})`,
+  };
+
+  return templates[template];
 }
 
-export default initCommand
+export default initCommand;

package/dist/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/dist/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/dist/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);
 }