create-bunli 0.7.0 → 0.8.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"],
+};

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

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

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

@@ -1,131 +1,130 @@
 export interface ValidationResult {
-  file: string
-  errors: ValidationIssue[]
-  warnings: ValidationIssue[]
+  file: string;
+  errors: ValidationIssue[];
+  warnings: ValidationIssue[];
 }
 
 export interface ValidationIssue {
-  line: number
-  column: number
-  message: string
-  rule: string
+  line: number;
+  column: number;
+  message: string;
+  rule: string;
 }
 
 export interface ValidateOptions {
-  rules?: Record<string, any>
-  fix?: boolean
-  cache?: boolean
+  rules?: Record<string, any>;
+  fix?: boolean;
+  cache?: boolean;
 }
 
 export async function validateFiles(
   files: string[],
-  options: ValidateOptions = {}
+  options: ValidateOptions = {},
 ): Promise<ValidationResult[]> {
-  const { rules = {}, fix = false } = options
-  const results: ValidationResult[] = []
-  
+  const { rules = {}, fix = false } = options;
+  const results: ValidationResult[] = [];
+
   for (const file of files) {
-    const result = await validateFile(file, rules, fix)
-    results.push(result)
+    const result = await validateFile(file, rules, fix);
+    results.push(result);
   }
-  
-  return results
+
+  return results;
 }
 
 async function validateFile(
   filePath: string,
   rules: Record<string, any>,
-  fix: boolean
+  fix: boolean,
 ): Promise<ValidationResult> {
-  const errors: ValidationIssue[] = []
-  const warnings: ValidationIssue[] = []
-  
+  const errors: ValidationIssue[] = [];
+  const warnings: ValidationIssue[] = [];
+
   try {
-    const content = await Bun.file(filePath).text()
-    const lines = content.split('\n')
-    
+    const content = await Bun.file(filePath).text();
+    const lines = content.split("\n");
+
     // Example rule implementations
     if (rules.noConsoleLog) {
       lines.forEach((line, index) => {
-        const match = line.match(/console\.log\s*\(/)
+        const match = line.match(/console\.log\s*\(/);
         if (match) {
           errors.push({
             line: index + 1,
             column: match.index! + 1,
-            message: 'console.log is not allowed',
-            rule: 'noConsoleLog'
-          })
+            message: "console.log is not allowed",
+            rule: "noConsoleLog",
+          });
         }
-      })
+      });
     }
-    
+
     if (rules.noDebugger) {
       lines.forEach((line, index) => {
-        const match = line.match(/\bdebugger\b/)
+        const match = line.match(/\bdebugger\b/);
         if (match) {
           errors.push({
             line: index + 1,
             column: match.index! + 1,
-            message: 'debugger statement is not allowed',
-            rule: 'noDebugger'
-          })
+            message: "debugger statement is not allowed",
+            rule: "noDebugger",
+          });
         }
-      })
+      });
     }
-    
+
     if (rules.maxLineLength) {
-      const maxLength = typeof rules.maxLineLength === 'number' ? rules.maxLineLength : 100
+      const maxLength = typeof rules.maxLineLength === "number" ? rules.maxLineLength : 100;
       lines.forEach((line, index) => {
         if (line.length > maxLength) {
           warnings.push({
             line: index + 1,
             column: maxLength + 1,
             message: `Line exceeds maximum length of ${maxLength}`,
-            rule: 'maxLineLength'
-          })
+            rule: "maxLineLength",
+          });
         }
-      })
+      });
     }
-    
+
     if (rules.requireFileHeader) {
-      if (!content.startsWith('/*') && !content.startsWith('//')) {
+      if (!content.startsWith("/*") && !content.startsWith("//")) {
         errors.push({
           line: 1,
           column: 1,
-          message: 'File must start with a header comment',
-          rule: 'requireFileHeader'
-        })
+          message: "File must start with a header comment",
+          rule: "requireFileHeader",
+        });
       }
     }
-    
+
     // Auto-fix if requested
     if (fix && errors.length > 0) {
       // This is a simplified example - real fix logic would be more complex
-      let fixedContent = content
-      
+      let fixedContent = content;
+
       if (rules.noConsoleLog) {
-        fixedContent = fixedContent.replace(/console\.log\s*\([^)]*\);?/g, '')
+        fixedContent = fixedContent.replace(/console\.log\s*\([^)]*\);?/g, "");
       }
-      
+
       if (rules.noDebugger) {
-        fixedContent = fixedContent.replace(/\bdebugger\b;?/g, '')
+        fixedContent = fixedContent.replace(/\bdebugger\b;?/g, "");
       }
-      
-      await Bun.write(filePath, fixedContent)
+
+      await Bun.write(filePath, fixedContent);
     }
-    
   } catch (error) {
     errors.push({
       line: 0,
       column: 0,
       message: `Failed to validate file: ${error}`,
-      rule: 'system'
-    })
+      rule: "system",
+    });
   }
-  
+
   return {
     file: filePath,
     errors,
-    warnings
-  }
-}
+    warnings,
+  };
+}

package/templates/advanced/template.json

@@ -35,10 +35,6 @@
     }
   ],
   "files": {
-    "exclude": [
-      "node_modules/**",
-      ".git/**",
-      "template.json"
-    ]
+    "exclude": ["node_modules/**", ".git/**", "template.json"]
   }
-}
+}

package/templates/advanced/tsconfig.json

@@ -20,4 +20,4 @@
   },
   "include": ["src/**/*"],
   "exclude": ["node_modules", "dist", "test/**/*"]
-}
+}

package/templates/basic/README.md

@@ -38,4 +38,4 @@ bun test
 
 ## License
 
-MIT
+MIT

package/templates/basic/bunli.config.ts

@@ -1,33 +1,33 @@
-import { defineConfig } from '@bunli/core'
+import { defineConfig } from "@bunli/core";
 
 export default defineConfig({
-  name: '{{name}}',
-  version: '{{version}}',
-  description: '{{description}}',
-  
+  name: "{{name}}",
+  version: "{{version}}",
+  description: "{{description}}",
+
   commands: {
-    directory: './src/commands'
+    directory: "./src/commands",
   },
-  
+
   build: {
-    entry: './src/index.ts',
-    outdir: './dist',
-    targets: ['native'],
+    entry: "./src/index.ts",
+    outdir: "./dist",
+    targets: ["native"],
     minify: true,
     sourcemap: true,
-    compress: false
+    compress: false,
   },
-  
+
   dev: {
     watch: true,
-    inspect: true
+    inspect: true,
   },
-  
+
   test: {
-    pattern: ['**/*.test.ts', '**/*.spec.ts'],
+    pattern: ["**/*.test.ts", "**/*.spec.ts"],
     coverage: true,
-    watch: false
+    watch: false,
   },
 
   plugins: [],
-})
+});

package/templates/basic/package.json

@@ -1,24 +1,25 @@
 {
   "name": "{{name}}",
   "version": "0.1.0",
-  "type": "module",
   "description": "{{description}}",
   "author": "{{author}}",
   "bin": {
     "{{name}}": "./dist/index.js"
   },
+  "type": "module",
   "scripts": {
     "postinstall": "bunli generate",
     "dev": "bun run src/index.ts",
     "build": "bunli build",
     "test": "bun test",
-    "typecheck": "tsc --noEmit"
+    "typecheck": "tsgo --noEmit"
   },
   "dependencies": {
     "@bunli/core": "latest"
   },
   "devDependencies": {
     "@bunli/test": "latest",
+    "@tsconfig/bun": "catalog:",
     "@types/bun": "latest",
     "bunli": "latest",
     "typescript": "^5.0.0"
@@ -27,4 +28,4 @@
     "entry": "./src/index.ts",
     "outDir": "./dist"
   }
-}
+}

package/templates/basic/src/commands/hello.ts

@@ -1,31 +1,26 @@
-import { defineCommand, option } from '@bunli/core'
-import { z } from 'zod'
+import { defineCommand, option } from "@bunli/core";
+import { z } from "zod";
 
 const helloCommand = defineCommand({
-  name: 'hello',
-  description: 'Say hello to someone',
+  name: "hello",
+  description: "Say hello to someone",
   options: {
-    name: option(
-      z.string().default('World'),
-      { 
-        description: 'Name to greet',
-        short: 'n'
-      }
-    ),
-    excited: option(
-      z.boolean().default(false),
-      {
-        description: 'Add excitement!',
-        short: 'e'
-      }
-    )
+    name: option(z.string().default("World"), {
+      description: "Name to greet",
+      short: "n",
+    }),
+    excited: option(z.boolean().default(false), {
+      description: "Add excitement!",
+      short: "e",
+      argumentKind: "flag",
+    }),
   },
   handler: async ({ flags, colors }) => {
-    const greeting = `Hello, ${flags.name}`
-    const message = flags.excited ? `${greeting}!` : `${greeting}.`
-    
-    console.log(colors.green(message))
-  }
-})
+    const greeting = `Hello, ${flags.name}`;
+    const message = flags.excited ? `${greeting}!` : `${greeting}.`;
 
-export default helloCommand
+    console.log(colors.green(message));
+  },
+});
+
+export default helloCommand;

package/templates/basic/src/index.ts

@@ -1,13 +1,14 @@
 #!/usr/bin/env bun
-import { createCLI } from '@bunli/core'
-import helloCommand from './commands/hello.js'
+import { createCLI } from "@bunli/core";
+
+import helloCommand from "./commands/hello.js";
 
 const cli = await createCLI({
-  name: '{{name}}',
-  version: '0.1.0',
-  description: '{{description}}'
-})
+  name: "{{name}}",
+  version: "0.1.0",
+  description: "{{description}}",
+});
 
-cli.command(helloCommand)
+cli.command(helloCommand);
 
-await cli.run()
+await cli.run();

package/templates/basic/template.json

@@ -22,10 +22,6 @@
     }
   ],
   "files": {
-    "exclude": [
-      "node_modules/**",
-      ".git/**",
-      "template.json"
-    ]
+    "exclude": ["node_modules/**", ".git/**", "template.json"]
   }
-}
+}

package/templates/basic/tsconfig.json

@@ -16,4 +16,4 @@
   },
   "include": ["src/**/*"],
   "exclude": ["node_modules", "dist", "test/**/*"]
-}
+}

package/templates/monorepo/README.md

@@ -71,4 +71,4 @@ bun run release
 
 ## License
 
-MIT
+MIT