create-bunli 0.1.0

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

@@ -0,0 +1,131 @@
+export interface ValidationResult {
+  file: string
+  errors: ValidationIssue[]
+  warnings: ValidationIssue[]
+}
+
+export interface ValidationIssue {
+  line: number
+  column: number
+  message: string
+  rule: string
+}
+
+export interface ValidateOptions {
+  rules?: Record<string, any>
+  fix?: boolean
+  cache?: boolean
+}
+
+export async function validateFiles(
+  files: string[],
+  options: ValidateOptions = {}
+): Promise<ValidationResult[]> {
+  const { rules = {}, fix = false } = options
+  const results: ValidationResult[] = []
+  
+  for (const file of files) {
+    const result = await validateFile(file, rules, fix)
+    results.push(result)
+  }
+  
+  return results
+}
+
+async function validateFile(
+  filePath: string,
+  rules: Record<string, any>,
+  fix: boolean
+): Promise<ValidationResult> {
+  const errors: ValidationIssue[] = []
+  const warnings: ValidationIssue[] = []
+  
+  try {
+    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*\(/)
+        if (match) {
+          errors.push({
+            line: index + 1,
+            column: match.index! + 1,
+            message: 'console.log is not allowed',
+            rule: 'noConsoleLog'
+          })
+        }
+      })
+    }
+    
+    if (rules.noDebugger) {
+      lines.forEach((line, index) => {
+        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'
+          })
+        }
+      })
+    }
+    
+    if (rules.maxLineLength) {
+      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'
+          })
+        }
+      })
+    }
+    
+    if (rules.requireFileHeader) {
+      if (!content.startsWith('/*') && !content.startsWith('//')) {
+        errors.push({
+          line: 1,
+          column: 1,
+          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
+      
+      if (rules.noConsoleLog) {
+        fixedContent = fixedContent.replace(/console\.log\s*\([^)]*\);?/g, '')
+      }
+      
+      if (rules.noDebugger) {
+        fixedContent = fixedContent.replace(/\bdebugger\b;?/g, '')
+      }
+      
+      await Bun.write(filePath, fixedContent)
+    }
+    
+  } catch (error) {
+    errors.push({
+      line: 0,
+      column: 0,
+      message: `Failed to validate file: ${error}`,
+      rule: 'system'
+    })
+  }
+  
+  return {
+    file: filePath,
+    errors,
+    warnings
+  }
+}

package/templates/advanced/template.json

@@ -0,0 +1,37 @@
+{
+  "name": "bunli-advanced",
+  "description": "Advanced Bunli CLI template with multiple commands",
+  "variables": [
+    {
+      "name": "projectName",
+      "message": "Project name",
+      "type": "string",
+      "default": "my-bunli-cli"
+    },
+    {
+      "name": "description",
+      "message": "Project description",
+      "type": "string",
+      "default": "A powerful CLI built with Bunli"
+    },
+    {
+      "name": "author",
+      "message": "Author name",
+      "type": "string",
+      "default": ""
+    },
+    {
+      "name": "license",
+      "message": "License",
+      "type": "select",
+      "default": "MIT",
+      "choices": [
+        { "label": "MIT", "value": "MIT" },
+        { "label": "Apache-2.0", "value": "Apache-2.0" },
+        { "label": "GPL-3.0", "value": "GPL-3.0" },
+        { "label": "BSD-3-Clause", "value": "BSD-3-Clause" },
+        { "label": "Unlicense", "value": "Unlicense" }
+      ]
+    }
+  ]
+}

package/templates/advanced/test/commands.test.ts

@@ -0,0 +1,34 @@
+import { test, expect } from 'bun:test'
+import { testCommand, expectCommand } from '@bunli/test'
+import { initCommand } from '../src/commands/init.js'
+import { validateCommand } from '../src/commands/validate.js'
+import { configCommand } from '../src/commands/config.js'
+
+test('init command - creates config file', async () => {
+  const result = await testCommand(initCommand, {
+    flags: { template: 'minimal', force: true }
+  })
+  
+  expectCommand(result).toHaveSucceeded()
+  expectCommand(result).toContainInStdout('Config file created')
+})
+
+test('validate command - reports errors', async () => {
+  const result = await testCommand(validateCommand, {
+    args: ['src/**/*.ts'],
+    flags: { fix: false }
+  })
+  
+  // Result depends on actual files, but command should run
+  expect(result.exitCode).toBeDefined()
+})
+
+test('config list command', async () => {
+  const listCommand = configCommand.subcommands?.find(cmd => cmd.name === 'list')
+  expect(listCommand).toBeDefined()
+  
+  const result = await testCommand(listCommand!, {})
+  
+  expectCommand(result).toHaveSucceeded()
+  expectCommand(result).toContainInStdout('Configuration:')
+})

package/templates/advanced/tsconfig.json

@@ -0,0 +1,23 @@
+{
+  "compilerOptions": {
+    "target": "ES2022",
+    "module": "ESNext",
+    "moduleResolution": "bundler",
+    "strict": true,
+    "esModuleInterop": true,
+    "skipLibCheck": true,
+    "forceConsistentCasingInFileNames": true,
+    "resolveJsonModule": true,
+    "declaration": true,
+    "declarationMap": true,
+    "outDir": "./dist",
+    "rootDir": "./src",
+    "types": ["bun-types"],
+    "noUnusedLocals": true,
+    "noUnusedParameters": true,
+    "noImplicitReturns": true,
+    "noFallthroughCasesInSwitch": true
+  },
+  "include": ["src/**/*"],
+  "exclude": ["node_modules", "dist", "test/**/*"]
+}

package/templates/basic/README.md

@@ -0,0 +1,41 @@
+# {{projectName}}
+
+{{description}}
+
+## Installation
+
+```bash
+bun install
+```
+
+## Development
+
+```bash
+bun dev -- [command]
+```
+
+## Building
+
+```bash
+bun run build
+```
+
+## Testing
+
+```bash
+bun test
+```
+
+## Usage
+
+```bash
+{{projectName}} hello --name World
+```
+
+## Commands
+
+- `hello` - A simple greeting command
+
+## License
+
+MIT

package/templates/basic/package.json

@@ -0,0 +1,29 @@
+{
+  "name": "{{projectName}}",
+  "version": "0.1.0",
+  "type": "module",
+  "description": "{{description}}",
+  "author": "{{author}}",
+  "bin": {
+    "{{projectName}}": "./dist/index.js"
+  },
+  "scripts": {
+    "dev": "bun run src/index.ts",
+    "build": "bunli build",
+    "test": "bun test",
+    "type-check": "tsc --noEmit"
+  },
+  "dependencies": {
+    "@bunli/core": "latest"
+  },
+  "devDependencies": {
+    "@bunli/test": "latest",
+    "@types/bun": "latest",
+    "bunli": "latest",
+    "typescript": "^5.0.0"
+  },
+  "bunli": {
+    "entry": "./src/index.ts",
+    "outDir": "./dist"
+  }
+}

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

@@ -0,0 +1,29 @@
+import { defineCommand, option } from '@bunli/core'
+import { z } from 'zod'
+
+export const helloCommand = defineCommand({
+  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'
+      }
+    )
+  },
+  handler: async ({ flags, colors }) => {
+    const greeting = `Hello, ${flags.name}`
+    const message = flags.excited ? `${greeting}!` : `${greeting}.`
+    
+    console.log(colors.green(message))
+  }
+})

package/templates/basic/src/index.ts

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

package/templates/basic/template.json

@@ -0,0 +1,31 @@
+{
+  "name": "bunli-basic",
+  "description": "Basic Bunli CLI template",
+  "variables": [
+    {
+      "name": "projectName",
+      "message": "Project name",
+      "type": "string",
+      "default": "my-bunli-cli"
+    },
+    {
+      "name": "description",
+      "message": "Project description",
+      "type": "string",
+      "default": "A CLI built with Bunli"
+    },
+    {
+      "name": "author",
+      "message": "Author name",
+      "type": "string",
+      "default": ""
+    }
+  ],
+  "files": {
+    "exclude": [
+      "node_modules/**",
+      ".git/**",
+      "template.json"
+    ]
+  }
+}

package/templates/basic/test/hello.test.ts

@@ -0,0 +1,26 @@
+import { test, expect } from 'bun:test'
+import { testCommand, expectCommand } from '@bunli/test'
+import { helloCommand } from '../src/commands/hello.js'
+
+test('hello command - default name', async () => {
+  const result = await testCommand(helloCommand)
+  
+  expectCommand(result).toHaveSucceeded()
+  expectCommand(result).toContainInStdout('Hello, World.')
+})
+
+test('hello command - custom name', async () => {
+  const result = await testCommand(helloCommand, {
+    flags: { name: 'Alice' }
+  })
+  
+  expectCommand(result).toContainInStdout('Hello, Alice.')
+})
+
+test('hello command - excited flag', async () => {
+  const result = await testCommand(helloCommand, {
+    flags: { name: 'Bob', excited: true }
+  })
+  
+  expectCommand(result).toContainInStdout('Hello, Bob!')
+})

package/templates/basic/tsconfig.json

@@ -0,0 +1,19 @@
+{
+  "compilerOptions": {
+    "target": "ES2022",
+    "module": "ESNext",
+    "moduleResolution": "bundler",
+    "strict": true,
+    "esModuleInterop": true,
+    "skipLibCheck": true,
+    "forceConsistentCasingInFileNames": true,
+    "resolveJsonModule": true,
+    "declaration": true,
+    "declarationMap": true,
+    "outDir": "./dist",
+    "rootDir": "./src",
+    "types": ["bun-types"]
+  },
+  "include": ["src/**/*"],
+  "exclude": ["node_modules", "dist", "test/**/*"]
+}

package/templates/monorepo/README.md

@@ -0,0 +1,74 @@
+# {{projectName}}
+
+{{description}}
+
+## Structure
+
+This is a monorepo managed with Bun workspaces and Turborepo.
+
+```
+.
+├── packages/
+│   ├── cli/          # Main CLI package
+│   ├── core/         # Core functionality
+│   └── utils/        # Shared utilities
+├── package.json      # Root package.json
+└── turbo.json       # Turborepo configuration
+```
+
+## Development
+
+```bash
+# Install dependencies
+bun install
+
+# Run all packages in development mode
+bun dev
+
+# Build all packages
+bun run build
+
+# Run tests
+bun test
+
+# Type check
+bun run type-check
+```
+
+## Creating a New Package
+
+1. Create a new directory under `packages/`
+2. Add a `package.json` with the package name and dependencies
+3. Add the package to the workspace in root `package.json` if needed
+4. Run `bun install` to link the workspace
+
+## Publishing
+
+This monorepo uses [Changesets](https://github.com/changesets/changesets) for version management.
+
+```bash
+# Create a changeset
+bun run changeset
+
+# Version packages
+bun run version
+
+# Publish to npm
+bun run release
+```
+
+## Scripts
+
+- `dev` - Run all packages in development mode
+- `build` - Build all packages
+- `test` - Run all tests
+- `type-check` - Type check all packages
+- `lint` - Lint all packages
+- `clean` - Clean all build artifacts
+- `changeset` - Create a new changeset
+- `version` - Update versions based on changesets
+- `release` - Build and publish packages
+
+## License
+
+MIT

package/templates/monorepo/package.json

@@ -0,0 +1,28 @@
+{
+  "name": "{{projectName}}",
+  "version": "0.0.0",
+  "private": true,
+  "type": "module",
+  "description": "{{description}}",
+  "author": "{{author}}",
+  "workspaces": [
+    "packages/*"
+  ],
+  "scripts": {
+    "dev": "turbo run dev",
+    "build": "turbo run build",
+    "test": "turbo run test",
+    "type-check": "turbo run type-check",
+    "lint": "turbo run lint",
+    "clean": "turbo run clean && rm -rf node_modules",
+    "changeset": "changeset",
+    "version": "changeset version",
+    "release": "turbo run build && changeset publish"
+  },
+  "devDependencies": {
+    "@changesets/cli": "^2.27.0",
+    "@types/bun": "latest",
+    "turbo": "latest",
+    "typescript": "^5.0.0"
+  }
+}

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

@@ -0,0 +1,34 @@
+{
+  "name": "@{{projectName}}/cli",
+  "version": "0.1.0",
+  "type": "module",
+  "description": "CLI for {{projectName}}",
+  "author": "{{author}}",
+  "license": "MIT",
+  "bin": {
+    "{{projectName}}": "./dist/index.js"
+  },
+  "scripts": {
+    "dev": "bun run src/index.ts",
+    "build": "bunli build",
+    "test": "bun test",
+    "type-check": "tsc --noEmit",
+    "clean": "rm -rf dist"
+  },
+  "dependencies": {
+    "@bunli/core": "latest",
+    "@{{projectName}}/core": "workspace:*",
+    "@{{projectName}}/utils": "workspace:*"
+  },
+  "devDependencies": {
+    "@bunli/test": "latest",
+    "@types/bun": "latest",
+    "bunli": "latest",
+    "typescript": "^5.0.0"
+  },
+  "bunli": {
+    "entry": "./src/index.ts",
+    "outDir": "./dist",
+    "external": ["@bunli/core", "@{{projectName}}/core", "@{{projectName}}/utils"]
+  }
+}

package/templates/monorepo/packages/cli/src/index.ts

@@ -0,0 +1,22 @@
+#!/usr/bin/env bun
+import { createCLI } from '@bunli/core'
+import { logger } from '@{{projectName}}/utils'
+import { processCommand, analyzeCommand } from '@{{projectName}}/core'
+
+const cli = createCLI({
+  name: '{{projectName}}',
+  version: '0.1.0',
+  description: '{{description}}'
+})
+
+// Add commands
+cli.command(processCommand)
+cli.command(analyzeCommand)
+
+// Run CLI
+try {
+  await cli.run()
+} catch (error) {
+  logger.error('CLI failed:', error)
+  process.exit(1)
+}

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

@@ -0,0 +1,15 @@
+{
+  "extends": "../../tsconfig.json",
+  "compilerOptions": {
+    "outDir": "./dist",
+    "rootDir": "./src",
+    "declaration": true,
+    "declarationMap": true
+  },
+  "include": ["src/**/*"],
+  "exclude": ["node_modules", "dist", "test/**/*"],
+  "references": [
+    { "path": "../core" },
+    { "path": "../utils" }
+  ]
+}

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

@@ -0,0 +1,32 @@
+{
+  "name": "@{{projectName}}/core",
+  "version": "0.1.0",
+  "type": "module",
+  "description": "Core functionality for {{projectName}}",
+  "author": "{{author}}",
+  "license": "MIT",
+  "main": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "exports": {
+    ".": {
+      "import": "./dist/index.js",
+      "types": "./dist/index.d.ts"
+    }
+  },
+  "scripts": {
+    "build": "bun scripts/build.ts && bun run tsc",
+    "test": "bun test",
+    "type-check": "tsc --noEmit",
+    "clean": "rm -rf dist"
+  },
+  "dependencies": {
+    "@bunli/core": "latest",
+    "@{{projectName}}/utils": "workspace:*",
+    "zod": "^3.22.0"
+  },
+  "devDependencies": {
+    "@bunli/test": "latest",
+    "@types/bun": "latest",
+    "typescript": "^5.0.0"
+  }
+}

package/templates/monorepo/packages/core/scripts/build.ts

@@ -0,0 +1,18 @@
+#!/usr/bin/env bun
+import { $ } from 'bun'
+
+// Clean dist directory
+await $`rm -rf dist`
+await $`mkdir -p dist`
+
+// Build TypeScript files
+await Bun.build({
+  entrypoints: ['./src/index.ts'],
+  outdir: './dist',
+  target: 'bun',
+  format: 'esm',
+  minify: false,
+  external: ['@bunli/core', '@{{projectName}}/utils', 'zod']
+})
+
+console.log('✅ @{{projectName}}/core built successfully')