create-bunli 0.5.5 → 0.6.1

package/dist/templates/advanced/package.json

@@ -21,6 +21,7 @@
   "dependencies": {
     "@bunli/core": "latest",
     "@bunli/utils": "latest",
+    "better-result": "^2.7.0",
     "zod": "^3.22.0"
   },
   "devDependencies": {
@@ -34,4 +35,4 @@
     "outDir": "./dist",
     "external": ["@bunli/core", "@bunli/utils", "zod"]
   }
-}
+}

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

@@ -1,77 +1,150 @@
 import { defineCommand, option } from '@bunli/core'
+import { Result, TaggedError } from 'better-result'
 import { z } from 'zod'
 import { loadConfig, saveConfig, getConfigPath } from '../utils/config.js'
+import { DEFAULT_CONFIG } from '../utils/constants.js'
+
+const toErrorMessage = (error: unknown): string =>
+  error instanceof Error ? error.message : String(error)
+
+class ConfigCommandError extends TaggedError('ConfigCommandError')<{
+  message: string
+  cause?: unknown
+}>() {
+  constructor(message: string, cause?: unknown) {
+    super(cause === undefined ? { message } : { message, cause })
+  }
+}
 
 const configCommand = defineCommand({
   name: 'config',
   description: 'Manage configuration',
-  subcommands: [
+  commands: [
     defineCommand({
       name: 'get',
       description: 'Get a config value',
-      args: z.tuple([z.string()]).describe('Config key to get'),
-      handler: async ({ args, colors }) => {
-        const [key] = args
-        
-        try {
-          const config = await loadConfig()
-          const value = getNestedValue(config, key)
-          
-          if (value === undefined) {
-            console.log(colors.yellow(`Config key '${key}' not found`))
-          } else {
-            console.log(JSON.stringify(value, null, 2))
-          }
-        } catch (error) {
-          console.error(colors.red(`Failed to load config: ${error}`))
-          process.exit(1)
+      handler: async ({ positional, colors }) => {
+        const key = positional[0]
+        if (!key) {
+          console.error(colors.red('Usage: config get <key>'))
+          process.exitCode = 1
+          return
+        }
+
+        const configResult = await Result.tryPromise({
+          try: () => loadConfig(),
+          catch: (cause) => new ConfigCommandError(`Failed to load config: ${toErrorMessage(cause)}`, cause)
+        })
+
+        if (Result.isError(configResult)) {
+          console.error(colors.red(configResult.error.message))
+          process.exitCode = 1
+          return
+        }
+
+        const value = getNestedValue(configResult.value as Record<string, unknown>, key)
+
+        if (value === undefined) {
+          console.log(colors.yellow(`Config key '${key}' not found`))
+        } else {
+          console.log(JSON.stringify(value, null, 2))
         }
       }
     }),
-    
+
     defineCommand({
       name: 'set',
       description: 'Set a config value',
-      args: z.tuple([z.string(), z.string()]).describe('Config key and value'),
-      handler: async ({ args, colors, spinner }) => {
-        const [key, value] = args
-        
+      handler: async ({ positional, colors, spinner }) => {
+        const key = positional[0]
+        const rawValue = positional[1]
+
+        if (!key || rawValue === undefined) {
+          console.error(colors.red('Usage: config set <key> <json-value>'))
+          process.exitCode = 1
+          return
+        }
+
         const spin = spinner('Updating config...')
         spin.start()
-        
-        try {
-          const config = await loadConfig()
-          setNestedValue(config, key, JSON.parse(value))
-          await saveConfig(config)
-          
-          spin.succeed(`Config '${key}' updated`)
-        } catch (error) {
+
+        const configResult = await Result.tryPromise({
+          try: () => loadConfig(),
+          catch: (cause) => new ConfigCommandError(`Failed to load config: ${toErrorMessage(cause)}`, cause)
+        })
+
+        if (Result.isError(configResult)) {
+          spin.fail('Failed to update config')
+          console.error(colors.red(configResult.error.message))
+          process.exitCode = 1
+          return
+        }
+
+        const parsedValue = Result.try({
+          try: () => JSON.parse(rawValue),
+          catch: (cause) =>
+            new ConfigCommandError(`Failed to parse value as JSON: ${toErrorMessage(cause)}`, cause)
+        })
+
+        if (Result.isError(parsedValue)) {
+          spin.fail('Failed to update config')
+          console.error(colors.red(parsedValue.error.message))
+          process.exitCode = 1
+          return
+        }
+
+        const nextConfig = configResult.value as Record<string, unknown>
+        setNestedValue(nextConfig, key, parsedValue.value)
+
+        const saveResult = await Result.tryPromise({
+          try: () => saveConfig(nextConfig),
+          catch: (cause) => new ConfigCommandError(`Failed to save config: ${toErrorMessage(cause)}`, cause)
+        })
+
+        if (Result.isError(saveResult)) {
           spin.fail('Failed to update config')
-          console.error(colors.red(String(error)))
-          process.exit(1)
+          console.error(colors.red(saveResult.error.message))
+          process.exitCode = 1
+          return
         }
+
+        spin.succeed(`Config '${key}' updated`)
       }
     }),
-    
+
     defineCommand({
       name: 'list',
       description: 'List all config values',
       handler: async ({ colors }) => {
-        try {
-          const config = await loadConfig()
-          const configPath = await getConfigPath()
-          
-          console.log(colors.bold('Configuration:'))
-          console.log(colors.dim(`  File: ${configPath}`))
-          console.log()
-          console.log(JSON.stringify(config, null, 2))
-        } catch (error) {
-          console.error(colors.red(`Failed to load config: ${error}`))
-          process.exit(1)
+        const configResult = await Result.tryPromise({
+          try: () => loadConfig(),
+          catch: (cause) => new ConfigCommandError(`Failed to load config: ${toErrorMessage(cause)}`, cause)
+        })
+
+        if (Result.isError(configResult)) {
+          console.error(colors.red(configResult.error.message))
+          process.exitCode = 1
+          return
         }
+
+        const configPathResult = await Result.tryPromise({
+          try: () => getConfigPath(),
+          catch: (cause) => new ConfigCommandError(`Failed to resolve config path: ${toErrorMessage(cause)}`, cause)
+        })
+
+        if (Result.isError(configPathResult)) {
+          console.error(colors.red(configPathResult.error.message))
+          process.exitCode = 1
+          return
+        }
+
+        console.log(colors.bold('Configuration:'))
+        console.log(colors.dim(`  File: ${configPathResult.value}`))
+        console.log()
+        console.log(JSON.stringify(configResult.value, null, 2))
       }
     }),
-    
+
     defineCommand({
       name: 'reset',
       description: 'Reset config to defaults',
@@ -90,58 +163,67 @@ const configCommand = defineCommand({
             'This will reset all config to defaults. Continue?',
             { default: false }
           )
-          
+
           if (!confirmed) {
             console.log(colors.yellow('Reset cancelled'))
             return
           }
         }
-        
+
         const spin = spinner('Resetting config...')
         spin.start()
-        
-        try {
-          const { DEFAULT_CONFIG } = await import('../utils/constants.js')
-          await saveConfig(DEFAULT_CONFIG)
-          
-          spin.succeed('Config reset to defaults')
-        } catch (error) {
+
+        const saveResult = await Result.tryPromise({
+          try: () => saveConfig(DEFAULT_CONFIG),
+          catch: (cause) => new ConfigCommandError(`Failed to save config: ${toErrorMessage(cause)}`, cause)
+        })
+
+        if (Result.isError(saveResult)) {
           spin.fail('Failed to reset config')
-          console.error(colors.red(String(error)))
-          process.exit(1)
+          console.error(colors.red(saveResult.error.message))
+          process.exitCode = 1
+          return
         }
+
+        spin.succeed('Config reset to defaults')
       }
     })
   ]
 })
 
-function getNestedValue(obj: any, path: string): any {
+function getNestedValue(obj: Record<string, unknown>, path: string): unknown {
   const keys = path.split('.')
-  let current = obj
-  
+  let current: unknown = obj
+
   for (const key of keys) {
-    if (current === null || current === undefined) {
+    if (!current || typeof current !== 'object') {
       return undefined
     }
-    current = current[key]
+
+    current = (current as Record<string, unknown>)[key]
   }
-  
+
   return current
 }
 
-function setNestedValue(obj: any, path: string, value: any): void {
+function setNestedValue(obj: Record<string, unknown>, path: string, value: unknown): void {
   const keys = path.split('.')
-  const lastKey = keys.pop()!
-  let current = obj
-  
+  const lastKey = keys.pop()
+  if (!lastKey) {
+    return
+  }
+
+  let current: Record<string, unknown> = obj
+
   for (const key of keys) {
-    if (!(key in current) || typeof current[key] !== 'object') {
+    const next = current[key]
+    if (!next || typeof next !== 'object' || Array.isArray(next)) {
       current[key] = {}
     }
-    current = current[key]
+    current = current[key] as Record<string, unknown>
   }
-  
+
   current[lastKey] = value
 }
 
-export default configCommand
+export default configCommand

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

@@ -7,7 +7,7 @@ const serveCommand = defineCommand({
   description: 'Start a development server',
   options: {
     port: option(
-      z.number().int().min(1).max(65535).default(3000),
+      z.coerce.number().int().min(1).max(65535).default(3000),
       {
         short: 'p',
         description: 'Port to listen on'
@@ -175,4 +175,4 @@ function getHomePage(): string {
   `.trim()
 }
 
-export default serveCommand
+export default serveCommand

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

@@ -7,7 +7,6 @@ import { glob } from '../utils/glob.js'
 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(),
@@ -30,66 +29,63 @@ const validateCommand = defineCommand({
       }
     )
   },
-  handler: async ({ args, flags, colors, spinner }) => {
+  handler: async ({ positional, 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 patterns = positional.length > 0 ? positional : config.include || ['src/**/*.{js,ts}']
+
       const fileSpin = spinner('Resolving files...')
       fileSpin.start()
-      
-      const files = await glob(args, {
+
+      const files = await glob(patterns, {
         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!'))
@@ -101,12 +97,11 @@ const validateCommand = defineCommand({
         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)))
@@ -115,4 +110,4 @@ const validateCommand = defineCommand({
   }
 })
 
-export default validateCommand
+export default validateCommand

package/dist/templates/advanced/src/index.ts

@@ -1,44 +1,55 @@
 #!/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'
 
+const toErrorMessage = (error: unknown): string =>
+  error instanceof Error ? error.message : String(error)
+
+class CliStartupError extends TaggedError('CliStartupError')<{
+  message: string
+  cause: unknown
+}>() {
+  constructor(cause: unknown) {
+    super({ message: `Failed to start CLI: ${toErrorMessage(cause)}`, cause })
+  }
+}
+
 const cli = await createCLI({
   name: '{{name}}',
   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)
+async function run(): Promise<Result<void, CliStartupError>> {
+  const configResult = await Result.tryPromise({
+    try: () => loadConfig(),
+    catch: (cause) => new CliStartupError(cause)
+  })
+
+  if (Result.isError(configResult)) {
+    return configResult
   }
+
+  return Result.tryPromise({
+    try: async () => {
+      await cli.run()
+    },
+    catch: (cause) => new CliStartupError(cause)
+  })
 }
 
-await run()
+const result = await run()
+if (Result.isError(result)) {
+  console.error(result.error.message)
+  process.exit(1)
+}

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

@@ -43,7 +43,7 @@ export async function loadConfig(configPath?: string): Promise<Config> {
     const config = configModule.default || configModule
     
     // Merge with defaults
-    cachedConfig = {
+    const mergedConfig: Config = {
       ...DEFAULT_CONFIG,
       ...config,
       server: {
@@ -51,8 +51,9 @@ export async function loadConfig(configPath?: string): Promise<Config> {
         ...(config.server || {})
       }
     }
-    
-    return cachedConfig
+
+    cachedConfig = mergedConfig
+    return mergedConfig
   } catch (error) {
     console.warn(`Failed to load config from ${finalPath}:`, error)
     return DEFAULT_CONFIG
@@ -80,4 +81,4 @@ export async function getConfigPath(): Promise<string> {
   }
   
   return 'No config file found'
-}
+}

package/dist/templates/monorepo/packages/cli/package.json

@@ -18,8 +18,8 @@
   },
   "dependencies": {
     "@bunli/core": "latest",
-    "@{{name}}/core": "workspace:*",
-    "@{{name}}/utils": "workspace:*"
+    "@{{name}}/core": "workspace:^",
+    "@{{name}}/utils": "workspace:^"
   },
   "devDependencies": {
     "@bunli/test": "latest",

package/dist/templates/monorepo/packages/core/package.json

@@ -21,7 +21,7 @@
   },
   "dependencies": {
     "@bunli/core": "latest",
-    "@{{name}}/utils": "workspace:*",
+    "@{{name}}/utils": "workspace:^",
     "zod": "^3.22.0"
   },
   "devDependencies": {

package/dist/templates/monorepo/packages/core/src/commands/analyze.ts

@@ -6,7 +6,6 @@ import type { AnalyzeResult } from '../types.js'
 const analyzeCommand = defineCommand({
   name: 'analyze',
   description: 'Analyze files and generate reports',
-  args: z.array(z.string()).min(1).describe('Files to analyze'),
   options: {
     detailed: option(
       z.boolean().default(false),
@@ -16,12 +15,18 @@ const analyzeCommand = defineCommand({
       }
     )
   },
-  handler: async ({ args, flags, colors }) => {
+  handler: async ({ positional, flags, colors }) => {
+    const files = positional
+    if (files.length === 0) {
+      logger.error('Usage: analyze <file...>')
+      process.exit(1)
+    }
+
     logger.info('Starting analysis...')
     
     const results: AnalyzeResult[] = []
     
-    for (const file of args) {
+    for (const file of files) {
       try {
         const result = await analyzeFile(file)
         results.push(result)
@@ -83,4 +88,4 @@ async function analyzeFile(file: string): Promise<AnalyzeResult> {
   }
 }
 
-export default analyzeCommand
+export default analyzeCommand

package/dist/templates/monorepo/packages/core/src/commands/process.ts

@@ -6,7 +6,6 @@ import type { ProcessOptions } from '../types.js'
 const processCommand = defineCommand({
   name: 'process',
   description: 'Process input files',
-  args: z.array(z.string()).min(1).describe('Files to process'),
   options: {
     output: option(
       z.string().optional(),
@@ -30,12 +29,18 @@ const processCommand = defineCommand({
       }
     )
   },
-  handler: async ({ args, flags, spinner }) => {
+  handler: async ({ positional, flags, spinner }) => {
+    const files = positional
+    if (files.length === 0) {
+      logger.error('Usage: process <file...>')
+      process.exit(1)
+    }
+
     const spin = spinner('Processing files...')
     spin.start()
     
     try {
-      for (const file of args) {
+      for (const file of files) {
         if (flags.verbose) {
           logger.info(`Processing ${file}`)
         }
@@ -49,7 +54,7 @@ const processCommand = defineCommand({
         })
       }
       
-      spin.succeed(`Processed ${args.length} files`)
+      spin.succeed(`Processed ${files.length} files`)
     } catch (error) {
       spin.fail('Processing failed')
       logger.error(error)
@@ -63,4 +68,4 @@ async function processFile(file: string, options: ProcessOptions): Promise<void>
   logger.debug(`Processing ${file} with options:`, options)
 }
 
-export default processCommand
+export default processCommand

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "create-bunli",
-  "version": "0.5.5",
+  "version": "0.6.1",
   "type": "module",
   "description": "Scaffold new Bunli CLI projects",
   "bin": {
@@ -47,14 +47,15 @@
     "prepublishOnly": "bun run build"
   },
   "dependencies": {
-    "@bunli/core": "0.5.7",
-    "@bunli/test": "0.3.5",
-    "@bunli/utils": "0.3.3",
+    "@bunli/core": "^0.6.1",
+    "@bunli/test": "^0.4.1",
+    "@bunli/utils": "^0.4.0",
+    "better-result": "^2.7.0",
     "giget": "^2.0.0",
     "zod": "^4.3.6"
   },
   "devDependencies": {
-    "@types/bun": "1.3.7",
+    "@types/bun": "1.3.9",
     "typescript": "^5.8.3"
   }
 }

package/templates/advanced/package.json

@@ -21,6 +21,7 @@
   "dependencies": {
     "@bunli/core": "latest",
     "@bunli/utils": "latest",
+    "better-result": "^2.7.0",
     "zod": "^3.22.0"
   },
   "devDependencies": {
@@ -34,4 +35,4 @@
     "outDir": "./dist",
     "external": ["@bunli/core", "@bunli/utils", "zod"]
   }
-}
+}