create-bunli 0.1.0

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

@@ -0,0 +1,153 @@
+import { defineCommand, option } from '@bunli/core'
+import { z } from 'zod'
+import { CONFIG_FILE_NAME, DEFAULT_CONFIG } from '../utils/constants.js'
+
+export const initCommand = defineCommand({
+  name: 'init',
+  description: 'Initialize a new configuration file',
+  options: {
+    force: option(
+      z.boolean().default(false),
+      { 
+        short: 'f',
+        description: 'Overwrite existing config' 
+      }
+    ),
+    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}`
+    
+    // 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 }
+      )
+      
+      if (!overwrite) {
+        console.log(colors.yellow('Init cancelled'))
+        return
+      }
+    }
+    
+    const spin = spinner('Creating config file...')
+    spin.start()
+    
+    try {
+      // Get template content
+      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}`))
+      
+      // 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 '{{projectName}} validate' to check your files`))
+      
+    } catch (error) {
+      spin.fail('Failed to create config file')
+      console.error(colors.red(String(error)))
+      process.exit(1)
+    }
+  }
+})
+
+function getConfigTemplate(template: 'minimal' | 'default' | 'full'): string {
+  const templates = {
+    minimal: `export default ${JSON.stringify(DEFAULT_CONFIG, null, 2)}`,
+    
+    default: `export default {
+  // Validation rules
+  rules: {
+    // Add your validation rules here
+    noConsoleLog: true,
+    requireFileHeader: false,
+  },
+  
+  // Server configuration
+  server: {
+    port: 3000,
+    host: 'localhost',
+    open: true,
+  },
+  
+  // File patterns
+  include: ['src/**/*.{js,ts}'],
+  exclude: ['node_modules', 'dist', 'test'],
+}`,
+    
+    full: `import { defineConfig } from '{{projectName}}'
+
+export default defineConfig({
+  // Validation rules
+  rules: {
+    // Code style rules
+    noConsoleLog: true,
+    noDebugger: true,
+    requireFileHeader: true,
+    maxLineLength: 100,
+    
+    // Import rules
+    noUnusedImports: true,
+    sortImports: true,
+    
+    // Function rules
+    maxFunctionLength: 50,
+    maxComplexity: 10,
+  },
+  
+  // Server configuration
+  server: {
+    port: process.env.PORT || 3000,
+    host: process.env.HOST || 'localhost',
+    open: !process.env.CI,
+    cors: true,
+  },
+  
+  // File patterns
+  include: [
+    'src/**/*.{js,ts,jsx,tsx}',
+    'scripts/**/*.{js,ts}',
+  ],
+  exclude: [
+    'node_modules',
+    'dist',
+    'build',
+    'coverage',
+    '**/*.test.{js,ts}',
+    '**/*.spec.{js,ts}',
+  ],
+  
+  // Caching
+  cache: {
+    enabled: true,
+    directory: '.cache',
+  },
+  
+  // Hooks
+  hooks: {
+    beforeValidate: async (files) => {
+      console.log(\`Validating \${files.length} files...\`)
+    },
+    afterValidate: async (results) => {
+      console.log(\`Found \${results.errors} errors and \${results.warnings} warnings\`)
+    },
+  },
+})`
+  }
+  
+  return templates[template]
+}

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

@@ -0,0 +1,176 @@
+import { defineCommand, option } from '@bunli/core'
+import { z } from 'zod'
+import { loadConfig } from '../utils/config.js'
+
+export const serveCommand = defineCommand({
+  name: 'serve',
+  description: 'Start a development server',
+  options: {
+    port: option(
+      z.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'
+      }
+    )
+  },
+  handler: async ({ flags, colors, spinner, shell }) => {
+    const spin = spinner('Starting server...')
+    spin.start()
+    
+    try {
+      // Load config
+      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
+      
+      // Create server
+      const server = Bun.serve({
+        port,
+        hostname: host,
+        fetch(req) {
+          const url = new URL(req.url)
+          
+          // Simple router
+          if (url.pathname === '/') {
+            return new Response(getHomePage(), {
+              headers: { 'Content-Type': 'text/html' }
+            })
+          }
+          
+          if (url.pathname === '/api/status') {
+            return Response.json({
+              status: 'ok',
+              version: '0.1.0',
+              uptime: process.uptime()
+            })
+          }
+          
+          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()
+        
+        try {
+          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')
+        } catch {
+          openSpin.fail('Failed to open browser')
+        }
+      }
+      
+      // Keep server running
+      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)
+      })
+      
+    } catch (error) {
+      spin.fail('Failed to start server')
+      console.error(colors.red(String(error)))
+      process.exit(1)
+    }
+  }
+})
+
+function getHomePage(): string {
+  return `
+<!DOCTYPE html>
+<html>
+<head>
+  <title>{{projectName}}</title>
+  <style>
+    body {
+      font-family: system-ui, -apple-system, sans-serif;
+      max-width: 800px;
+      margin: 0 auto;
+      padding: 2rem;
+      background: #f5f5f5;
+    }
+    .container {
+      background: white;
+      padding: 2rem;
+      border-radius: 8px;
+      box-shadow: 0 2px 4px rgba(0,0,0,0.1);
+    }
+    h1 {
+      color: #333;
+      margin-top: 0;
+    }
+    .status {
+      display: inline-block;
+      padding: 0.25rem 0.5rem;
+      background: #10b981;
+      color: white;
+      border-radius: 4px;
+      font-size: 0.875rem;
+    }
+    code {
+      background: #f3f4f6;
+      padding: 0.125rem 0.25rem;
+      border-radius: 3px;
+      font-family: monospace;
+    }
+    .endpoints {
+      margin-top: 2rem;
+      padding: 1rem;
+      background: #f9fafb;
+      border-radius: 4px;
+    }
+  </style>
+</head>
+<body>
+  <div class="container">
+    <h1>{{projectName}}</h1>
+    <p>{{description}}</p>
+    <p><span class="status">Running</span></p>
+    
+    <div class="endpoints">
+      <h3>API Endpoints</h3>
+      <ul>
+        <li><code>GET /</code> - This page</li>
+        <li><code>GET /api/status</code> - Server status</li>
+      </ul>
+    </div>
+    
+    <p>To get started, check out the <a href="https://github.com/AryaLabsHQ/bunli">documentation</a>.</p>
+  </div>
+</body>
+</html>
+  `.trim()
+}

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

@@ -0,0 +1,116 @@
+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'
+
+export const validateCommand = defineCommand({
+  name: 'validate',
+  description: 'Validate files against defined rules',
+  args: z.array(z.string()).min(1).describe('Files to validate'),
+  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'
+      }
+    ),
+    cache: option(
+      z.boolean().default(true),
+      {
+        description: 'Enable caching'
+      }
+    )
+  },
+  handler: async ({ args, flags, colors, spinner }) => {
+    const spin = spinner('Loading configuration...')
+    spin.start()
+    
+    try {
+      // Load config
+      const config = await loadConfig(flags.config)
+      spin.succeed('Configuration loaded')
+      
+      // Resolve files
+      const fileSpin = spinner('Resolving files...')
+      fileSpin.start()
+      
+      const files = await glob(args, {
+        include: config.include,
+        exclude: config.exclude
+      })
+      
+      fileSpin.succeed(`Found ${files.length} files to validate`)
+      
+      if (files.length === 0) {
+        console.log(colors.yellow('No files matched the pattern'))
+        return
+      }
+      
+      // Run validation
+      const validateSpin = spinner('Validating files...')
+      validateSpin.start()
+      
+      const results = await validateFiles(files, {
+        rules: config.rules,
+        fix: flags.fix,
+        cache: flags.cache && config.cache?.enabled
+      })
+      
+      validateSpin.stop()
+      
+      // Display results
+      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))
+          
+          for (const error of result.errors) {
+            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}`))
+          }
+        }
+      }
+      
+      // Summary
+      const totalErrors = results.reduce((sum, r) => sum + r.errors.length, 0)
+      const totalWarnings = results.reduce((sum, r) => sum + r.warnings.length, 0)
+      
+      console.log()
+      if (totalErrors === 0 && totalWarnings === 0) {
+        console.log(colors.green('✅ All files passed validation!'))
+      } else {
+        console.log(colors.bold('Summary:'))
+        if (totalErrors > 0) {
+          console.log(colors.red(`  ${totalErrors} error${totalErrors !== 1 ? 's' : ''}`))
+        }
+        if (totalWarnings > 0) {
+          console.log(colors.yellow(`  ${totalWarnings} warning${totalWarnings !== 1 ? 's' : ''}`))
+        }
+        
+        if (hasErrors) {
+          process.exit(1)
+        }
+      }
+      
+    } catch (error) {
+      spin.fail('Validation failed')
+      console.error(colors.red(String(error)))
+      process.exit(1)
+    }
+  }
+})

package/templates/advanced/src/index.ts

@@ -0,0 +1,44 @@
+#!/usr/bin/env bun
+import { createCLI } from '@bunli/core'
+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'
+
+const cli = createCLI({
+  name: '{{projectName}}',
+  version: '0.1.0',
+  description: '{{description}}'
+})
+
+// Global options
+cli.option('verbose', {
+  type: 'boolean',
+  description: 'Enable verbose output'
+})
+
+cli.option('quiet', {
+  type: 'boolean',
+  description: 'Suppress output'
+})
+
+// Add commands
+cli.command(initCommand)
+cli.command(validateCommand)
+cli.command(serveCommand)
+cli.command(configCommand)
+
+// Load config and run
+async function run() {
+  try {
+    const config = await loadConfig()
+    // Store config in global context if needed
+    await cli.run()
+  } catch (error) {
+    console.error('Failed to start CLI:', error)
+    process.exit(1)
+  }
+}
+
+await run()

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

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

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

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

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

@@ -0,0 +1,49 @@
+import { Glob } from 'bun'
+import path from 'node:path'
+
+export interface GlobOptions {
+  include?: string[]
+  exclude?: string[]
+}
+
+export async function glob(patterns: string[], options: GlobOptions = {}): Promise<string[]> {
+  const { include = [], exclude = [] } = options
+  
+  // Combine user patterns with include patterns
+  const allPatterns = [...patterns, ...include]
+  
+  // Convert exclude patterns to absolute paths
+  const excludePatterns = exclude.map(pattern => {
+    if (pattern.startsWith('/')) {
+      return pattern
+    }
+    return path.join(process.cwd(), pattern)
+  })
+  
+  const results = new Set<string>()
+  
+  for (const pattern of allPatterns) {
+    const glob = new Glob(pattern)
+    
+    for await (const file of glob.scan({
+      cwd: process.cwd(),
+      absolute: true
+    })) {
+      // Check if file should be excluded
+      let shouldExclude = false
+      
+      for (const excludePattern of excludePatterns) {
+        if (file.includes(excludePattern)) {
+          shouldExclude = true
+          break
+        }
+      }
+      
+      if (!shouldExclude) {
+        results.add(file)
+      }
+    }
+  }
+  
+  return Array.from(results).sort()
+}