create-bunli 0.1.0

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

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

@@ -0,0 +1,84 @@
+import { defineCommand, option } from '@bunli/core'
+import { z } from 'zod'
+import { logger, formatTable } from '@{{projectName}}/utils'
+import type { AnalyzeResult } from '../types.js'
+
+export 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),
+      {
+        short: 'd',
+        description: 'Show detailed analysis'
+      }
+    )
+  },
+  handler: async ({ args, flags, colors }) => {
+    logger.info('Starting analysis...')
+    
+    const results: AnalyzeResult[] = []
+    
+    for (const file of args) {
+      try {
+        const result = await analyzeFile(file)
+        results.push(result)
+      } catch (error) {
+        logger.error(`Failed to analyze ${file}:`, error)
+      }
+    }
+    
+    // Display results
+    console.log()
+    console.log(colors.bold('Analysis Results:'))
+    console.log()
+    
+    const tableData = results.map(r => ({
+      File: r.file,
+      Lines: r.metrics.lines,
+      Words: r.metrics.words,
+      Issues: r.issues.length
+    }))
+    
+    console.log(formatTable(tableData))
+    
+    if (flags.detailed) {
+      console.log()
+      console.log(colors.bold('Detailed Issues:'))
+      
+      for (const result of results) {
+        if (result.issues.length > 0) {
+          console.log()
+          console.log(colors.underline(result.file))
+          
+          for (const issue of result.issues) {
+            const icon = issue.type === 'error' ? '✗' :
+                        issue.type === 'warning' ? '⚠' : 'ℹ'
+            const color = issue.type === 'error' ? colors.red :
+                         issue.type === 'warning' ? colors.yellow : colors.blue
+            
+            console.log(color(`  ${icon} ${issue.line}:${issue.column} ${issue.message}`))
+          }
+        }
+      }
+    }
+  }
+})
+
+async function analyzeFile(file: string): Promise<AnalyzeResult> {
+  const content = await Bun.file(file).text()
+  const lines = content.split('\n')
+  const words = content.split(/\\s+/).filter(w => w.length > 0)
+  
+  return {
+    file,
+    metrics: {
+      lines: lines.length,
+      characters: content.length,
+      words: words.length
+    },
+    issues: []
+  }
+}

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

@@ -0,0 +1,64 @@
+import { defineCommand, option } from '@bunli/core'
+import { z } from 'zod'
+import { logger } from '@{{projectName}}/utils'
+import type { ProcessOptions } from '../types.js'
+
+export 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(),
+      {
+        short: 'o',
+        description: 'Output directory'
+      }
+    ),
+    format: option(
+      z.enum(['json', 'yaml', 'text']).default('json'),
+      {
+        short: 'f',
+        description: 'Output format'
+      }
+    ),
+    verbose: option(
+      z.boolean().default(false),
+      {
+        short: 'v',
+        description: 'Verbose output'
+      }
+    )
+  },
+  handler: async ({ args, flags, spinner }) => {
+    const spin = spinner('Processing files...')
+    spin.start()
+    
+    try {
+      for (const file of args) {
+        if (flags.verbose) {
+          logger.info(`Processing ${file}`)
+        }
+        
+        // Process logic here
+        await processFile(file, {
+          input: file,
+          output: flags.output,
+          format: flags.format,
+          verbose: flags.verbose
+        })
+      }
+      
+      spin.succeed(`Processed ${args.length} files`)
+    } catch (error) {
+      spin.fail('Processing failed')
+      logger.error(error)
+      process.exit(1)
+    }
+  }
+})
+
+async function processFile(file: string, options: ProcessOptions): Promise<void> {
+  // Implementation here
+  logger.debug(`Processing ${file} with options:`, options)
+}

package/dist/templates/monorepo/packages/core/src/index.ts

@@ -0,0 +1,3 @@
+export { processCommand } from './commands/process.js'
+export { analyzeCommand } from './commands/analyze.js'
+export type { ProcessOptions, AnalyzeResult } from './types.js'

package/dist/templates/monorepo/packages/core/src/types.ts

@@ -0,0 +1,21 @@
+export interface ProcessOptions {
+  input: string
+  output?: string
+  format?: 'json' | 'yaml' | 'text'
+  verbose?: boolean
+}
+
+export interface AnalyzeResult {
+  file: string
+  metrics: {
+    lines: number
+    characters: number
+    words: number
+  }
+  issues: Array<{
+    type: 'error' | 'warning' | 'info'
+    line: number
+    column: number
+    message: string
+  }>
+}

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

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

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

@@ -0,0 +1,26 @@
+{
+  "name": "@{{projectName}}/utils",
+  "version": "0.1.0",
+  "type": "module",
+  "description": "Shared utilities 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"
+  },
+  "devDependencies": {
+    "@types/bun": "latest",
+    "typescript": "^5.0.0"
+  }
+}