create-bunli 0.1.0

package/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/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/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/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/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/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"
+  }
+}

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

@@ -0,0 +1,17 @@
+#!/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
+})
+
+console.log('✅ @{{projectName}}/utils built successfully')

package/templates/monorepo/packages/utils/src/format.ts

@@ -0,0 +1,27 @@
+export function formatTable(data: Record<string, any>[]): string {
+  if (data.length === 0) return ''
+  
+  const headers = Object.keys(data[0])
+  const rows = data.map(item => headers.map(h => String(item[h] ?? '')))
+  
+  // Calculate column widths
+  const widths = headers.map((h, i) => {
+    const headerWidth = h.length
+    const maxDataWidth = Math.max(...rows.map(r => r[i].length))
+    return Math.max(headerWidth, maxDataWidth)
+  })
+  
+  // Build table
+  const lines: string[] = []
+  
+  // Header
+  lines.push(headers.map((h, i) => h.padEnd(widths[i])).join('  '))
+  lines.push(widths.map(w => '-'.repeat(w)).join('  '))
+  
+  // Rows
+  for (const row of rows) {
+    lines.push(row.map((cell, i) => cell.padEnd(widths[i])).join('  '))
+  }
+  
+  return lines.join('\\n')
+}

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

@@ -0,0 +1,3 @@
+export { logger } from './logger.js'
+export { formatTable } from './format.js'
+export { parseJSON, stringifyJSON } from './json.js'

package/templates/monorepo/packages/utils/src/json.ts

@@ -0,0 +1,11 @@
+export function parseJSON<T = any>(text: string): T {
+  try {
+    return JSON.parse(text)
+  } catch (error) {
+    throw new Error(`Invalid JSON: ${error}`)
+  }
+}
+
+export function stringifyJSON(data: any, pretty = false): string {
+  return JSON.stringify(data, null, pretty ? 2 : 0)
+}

package/templates/monorepo/packages/utils/src/logger.ts

@@ -0,0 +1,19 @@
+export const logger = {
+  debug: (...args: any[]) => {
+    if (process.env.DEBUG) {
+      console.log('[DEBUG]', ...args)
+    }
+  },
+  
+  info: (...args: any[]) => {
+    console.log('[INFO]', ...args)
+  },
+  
+  warn: (...args: any[]) => {
+    console.warn('[WARN]', ...args)
+  },
+  
+  error: (...args: any[]) => {
+    console.error('[ERROR]', ...args)
+  }
+}

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

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

package/templates/monorepo/template.json

@@ -0,0 +1,24 @@
+{
+  "name": "bunli-monorepo",
+  "description": "Monorepo template for multi-package Bunli projects",
+  "variables": [
+    {
+      "name": "projectName",
+      "message": "Project name",
+      "type": "string",
+      "default": "my-bunli-monorepo"
+    },
+    {
+      "name": "description",
+      "message": "Project description",
+      "type": "string",
+      "default": "A monorepo CLI project built with Bunli"
+    },
+    {
+      "name": "author",
+      "message": "Author name",
+      "type": "string",
+      "default": ""
+    }
+  ]
+}

package/templates/monorepo/tsconfig.json

@@ -0,0 +1,14 @@
+{
+  "compilerOptions": {
+    "target": "ES2022",
+    "module": "ESNext",
+    "moduleResolution": "bundler",
+    "strict": true,
+    "esModuleInterop": true,
+    "skipLibCheck": true,
+    "forceConsistentCasingInFileNames": true,
+    "resolveJsonModule": true,
+    "types": ["bun-types"]
+  },
+  "exclude": ["node_modules", "dist", "build", ".turbo"]
+}

package/templates/monorepo/turbo.json

@@ -0,0 +1,28 @@
+{
+  "$schema": "https://turbo.build/schema.json",
+  "globalDependencies": ["**/.env.*local"],
+  "pipeline": {
+    "build": {
+      "dependsOn": ["^build"],
+      "outputs": ["dist/**", ".next/**", "!.next/cache/**"]
+    },
+    "test": {
+      "dependsOn": ["build"],
+      "outputs": ["coverage/**"],
+      "cache": false
+    },
+    "lint": {
+      "dependsOn": ["^build"]
+    },
+    "type-check": {
+      "dependsOn": ["^build"]
+    },
+    "dev": {
+      "cache": false,
+      "persistent": true
+    },
+    "clean": {
+      "cache": false
+    }
+  }
+}