create-bunli 0.1.0

package/dist/index.js

@@ -0,0 +1,217 @@
+// @bun
+// src/template-engine.ts
+import { downloadTemplate } from "giget";
+import { readdir } from "fs/promises";
+import { join } from "path";
+async function processTemplate(options) {
+  const { source, dir, offline, variables = {} } = options;
+  let templateDir;
+  if (source.startsWith("/") || source.startsWith("./") || source.startsWith("../")) {
+    const sourceDir = source.startsWith("/") ? source : join(process.cwd(), source);
+    await Bun.spawn(["cp", "-r", sourceDir + "/.", dir], {
+      stdout: "inherit",
+      stderr: "inherit"
+    }).exited;
+    templateDir = dir;
+  } else {
+    const result = await downloadTemplate(source, {
+      dir,
+      offline,
+      preferOffline: true,
+      force: true
+    });
+    templateDir = result.dir;
+  }
+  const manifest = await loadTemplateManifest(templateDir);
+  if (manifest?.files || Object.keys(variables).length > 0) {
+    await processTemplateFiles(templateDir, variables, manifest);
+  }
+  if (manifest?.hooks?.postInstall) {
+    await runPostInstallHooks(templateDir, manifest.hooks.postInstall);
+  }
+  return { dir: templateDir, manifest };
+}
+async function loadTemplateManifest(dir) {
+  const possiblePaths = [
+    join(dir, "template.json"),
+    join(dir, ".template.json"),
+    join(dir, "template.yaml"),
+    join(dir, ".template.yaml")
+  ];
+  for (const path of possiblePaths) {
+    const file = Bun.file(path);
+    if (await file.exists()) {
+      const content = await file.text();
+      if (path.endsWith(".json")) {
+        const manifest = JSON.parse(content);
+        try {
+          await Bun.spawn(["rm", "-f", path], {
+            stdout: "ignore",
+            stderr: "ignore"
+          }).exited;
+        } catch {}
+        return manifest;
+      }
+    }
+  }
+  return null;
+}
+async function processTemplateFiles(dir, variables, manifest) {
+  const files = await getFilesToProcess(dir, manifest);
+  for (const file of files) {
+    const filePath = join(dir, file);
+    const content = await Bun.file(filePath).text();
+    let processedContent = content;
+    for (const [key, value] of Object.entries(variables)) {
+      processedContent = processedContent.replaceAll(`{{${key}}}`, value).replaceAll(`<%= ${key} %>`, value).replaceAll(`$${key}`, value).replaceAll(`__${key}__`, value);
+    }
+    let newFilePath = filePath;
+    for (const [key, value] of Object.entries(variables)) {
+      newFilePath = newFilePath.replaceAll(`__${key}__`, value);
+    }
+    await Bun.write(newFilePath, processedContent);
+    if (newFilePath !== filePath) {
+      await Bun.spawn(["rm", filePath]).exited;
+    }
+  }
+}
+async function getFilesToProcess(dir, manifest) {
+  if (manifest?.files?.include) {
+    return manifest.files.include;
+  }
+  const files = [];
+  async function walk(currentDir, prefix = "") {
+    const entries = await readdir(currentDir, { withFileTypes: true });
+    for (const entry of entries) {
+      const path = join(prefix, entry.name);
+      if (entry.isDirectory()) {
+        if (!["node_modules", ".git", ".next", "dist", "build"].includes(entry.name)) {
+          await walk(join(currentDir, entry.name), path);
+        }
+      } else {
+        if (!path.match(/^(template\.json|\.template\.json|\.DS_Store|Thumbs\.db)$/)) {
+          files.push(path);
+        }
+      }
+    }
+  }
+  await walk(dir);
+  return files;
+}
+async function runPostInstallHooks(dir, hooks) {
+  for (const hook of hooks) {
+    const proc = Bun.spawn(hook.split(" "), {
+      cwd: dir,
+      stdout: "inherit",
+      stderr: "inherit"
+    });
+    await proc.exited;
+  }
+}
+function resolveTemplateSource(template) {
+  const specialTemplates = {
+    basic: "github:bunli/templates/basic",
+    advanced: "github:bunli/templates/advanced",
+    monorepo: "github:bunli/templates/monorepo"
+  };
+  if (specialTemplates[template]) {
+    return specialTemplates[template];
+  }
+  if (template.startsWith("npm:")) {
+    return template.replace("npm:", "npm:/");
+  }
+  if (template.includes("/") && !template.includes(":")) {
+    return `github:${template}`;
+  }
+  return template;
+}
+function getBundledTemplatePath(name) {
+  return join(import.meta.dir, "..", "templates", name);
+}
+async function isLocalTemplate(template) {
+  if (template.startsWith("file:") || template.startsWith("./") || template.startsWith("../")) {
+    return true;
+  }
+  const bundledPath = getBundledTemplatePath(template);
+  return await Bun.file(join(bundledPath, "package.json")).exists();
+}
+
+// src/create-project.ts
+async function createProject(options) {
+  const { name, dir, template, git, install, packageManager, prompt, spinner, colors, shell, offline } = options;
+  try {
+    await shell`test -d ${dir}`.quiet();
+    const overwrite = await prompt.confirm(`Directory ${dir} already exists. Overwrite?`, { default: false });
+    if (!overwrite) {
+      console.log(colors.red("Cancelled"));
+      process.exit(1);
+    }
+    await shell`rm -rf ${dir}`;
+  } catch {}
+  const spin = spinner("Creating project structure...");
+  spin.start();
+  await shell`mkdir -p ${dir}`;
+  try {
+    let templateSource = template;
+    if (await isLocalTemplate(template)) {
+      templateSource = getBundledTemplatePath(template);
+    } else {
+      templateSource = resolveTemplateSource(template);
+    }
+    const { manifest } = await processTemplate({
+      source: templateSource,
+      dir,
+      offline,
+      variables: {
+        projectName: name,
+        description: `A CLI built with Bunli`,
+        author: "",
+        packageManager: packageManager || "bun",
+        year: new Date().getFullYear().toString()
+      }
+    });
+    spin.succeed("Project structure created");
+    if (git) {
+      const gitSpin = spinner("Initializing git repository...");
+      gitSpin.start();
+      try {
+        await shell`cd ${dir} && git init`.quiet();
+        await shell`cd ${dir} && git add .`.quiet();
+        await shell`cd ${dir} && git commit -m "Initial commit"`.quiet();
+        gitSpin.succeed("Git repository initialized");
+      } catch (error) {
+        gitSpin.fail("Failed to initialize git repository");
+        console.error(colors.dim(`  ${error}`));
+      }
+    }
+    if (install) {
+      const installSpin = spinner(`Installing dependencies with ${packageManager}...`);
+      installSpin.start();
+      try {
+        const installCmd = packageManager === "bun" ? "bun install" : packageManager === "pnpm" ? "pnpm install" : packageManager === "yarn" ? "yarn install" : "npm install";
+        await shell`cd ${dir} && ${installCmd}`;
+        installSpin.succeed("Dependencies installed");
+      } catch (error) {
+        installSpin.fail("Failed to install dependencies");
+        console.error(colors.dim(`  You can install them manually by running: ${packageManager} install`));
+      }
+    }
+  } catch (error) {
+    spin.fail("Failed to create project");
+    console.error(colors.red(`Error: ${error}`));
+    try {
+      await shell`rm -rf ${dir}`.quiet();
+    } catch {}
+    process.exit(1);
+  }
+}
+
+// src/index.ts
+var version = "0.1.0";
+export {
+  version,
+  resolveTemplateSource,
+  processTemplate,
+  isLocalTemplate,
+  createProject
+};

package/dist/template-engine.d.ts

@@ -0,0 +1,27 @@
+import type { TemplateManifest } from './types.js';
+export interface TemplateOptions {
+    source: string;
+    type?: 'github' | 'npm' | 'local' | 'bundled';
+    dir: string;
+    offline?: boolean;
+    variables?: Record<string, string>;
+}
+/**
+ * Download and process a template
+ */
+export declare function processTemplate(options: TemplateOptions): Promise<{
+    dir: string;
+    manifest: TemplateManifest | null;
+}>;
+/**
+ * Resolve template source to giget-compatible format
+ */
+export declare function resolveTemplateSource(template: string): string;
+/**
+ * Get bundled template path
+ */
+export declare function getBundledTemplatePath(name: string): string;
+/**
+ * Check if template exists locally (for development)
+ */
+export declare function isLocalTemplate(template: string): Promise<boolean>;

package/dist/templates/advanced/README.md

@@ -0,0 +1,114 @@
+# {{projectName}}
+
+{{description}}
+
+## Installation
+
+```bash
+# Install globally
+bun add -g {{projectName}}
+
+# Or use directly with bunx
+bunx {{projectName}} [command]
+```
+
+## Usage
+
+```bash
+{{projectName}} <command> [options]
+```
+
+### Commands
+
+#### `init`
+Initialize a new configuration file in the current directory.
+
+```bash
+{{projectName}} init [options]
+
+Options:
+  -f, --force     Overwrite existing config
+  -t, --template  Config template to use
+```
+
+#### `validate`
+Validate files against defined rules.
+
+```bash
+{{projectName}} validate <files...> [options]
+
+Options:
+  -c, --config    Path to config file
+  -f, --fix       Auto-fix issues
+  --no-cache      Disable caching
+```
+
+#### `serve`
+Start a development server.
+
+```bash
+{{projectName}} serve [options]
+
+Options:
+  -p, --port      Port to listen on (default: 3000)
+  -h, --host      Host to bind to (default: localhost)
+  --no-open       Don't open browser
+```
+
+#### `config`
+Manage configuration settings.
+
+```bash
+{{projectName}} config <action> [key] [value]
+
+Actions:
+  get <key>       Get a config value
+  set <key> <value>  Set a config value
+  list            List all config values
+  reset           Reset to defaults
+```
+
+### Global Options
+
+- `-v, --version` - Show version
+- `-h, --help` - Show help
+- `--verbose` - Enable verbose output
+- `--quiet` - Suppress output
+- `--no-color` - Disable colored output
+
+## Configuration
+
+Create a `{{projectName}}.config.js` file in your project root:
+
+```javascript
+export default {
+  // Configuration options
+  rules: {
+    // Define your rules
+  },
+  server: {
+    port: 3000,
+    host: 'localhost'
+  }
+}
+```
+
+## Development
+
+```bash
+# Install dependencies
+bun install
+
+# Run in development
+bun dev
+
+# Run tests
+bun test
+
+# Build for production
+bun run build
+```
+
+## License
+
+{{license}}

package/dist/templates/advanced/package.json

@@ -0,0 +1,36 @@
+{
+  "name": "{{projectName}}",
+  "version": "0.1.0",
+  "type": "module",
+  "description": "{{description}}",
+  "author": "{{author}}",
+  "license": "{{license}}",
+  "bin": {
+    "{{projectName}}": "./dist/index.js"
+  },
+  "scripts": {
+    "dev": "bun run src/index.ts",
+    "build": "bunli build",
+    "test": "bun test",
+    "test:watch": "bun test --watch",
+    "type-check": "tsc --noEmit",
+    "lint": "tsc --noEmit",
+    "prepare": "bun run build"
+  },
+  "dependencies": {
+    "@bunli/core": "latest",
+    "@bunli/utils": "latest",
+    "zod": "^3.22.0"
+  },
+  "devDependencies": {
+    "@bunli/test": "latest",
+    "@types/bun": "latest",
+    "bunli": "latest",
+    "typescript": "^5.0.0"
+  },
+  "bunli": {
+    "entry": "./src/index.ts",
+    "outDir": "./dist",
+    "external": ["@bunli/core", "@bunli/utils", "zod"]
+  }
+}

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

@@ -0,0 +1,145 @@
+import { defineCommand, option } from '@bunli/core'
+import { z } from 'zod'
+import { loadConfig, saveConfig, getConfigPath } from '../utils/config.js'
+
+export const configCommand = defineCommand({
+  name: 'config',
+  description: 'Manage configuration',
+  subcommands: [
+    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)
+        }
+      }
+    }),
+    
+    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
+        
+        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) {
+          spin.fail('Failed to update config')
+          console.error(colors.red(String(error)))
+          process.exit(1)
+        }
+      }
+    }),
+    
+    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)
+        }
+      }
+    }),
+    
+    defineCommand({
+      name: 'reset',
+      description: 'Reset config to defaults',
+      options: {
+        force: option(
+          z.boolean().default(false),
+          {
+            short: 'f',
+            description: 'Skip confirmation'
+          }
+        )
+      },
+      handler: async ({ flags, colors, prompt, spinner }) => {
+        if (!flags.force) {
+          const confirmed = await prompt.confirm(
+            '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) {
+          spin.fail('Failed to reset config')
+          console.error(colors.red(String(error)))
+          process.exit(1)
+        }
+      }
+    })
+  ]
+})
+
+function getNestedValue(obj: any, path: string): any {
+  const keys = path.split('.')
+  let current = obj
+  
+  for (const key of keys) {
+    if (current === null || current === undefined) {
+      return undefined
+    }
+    current = current[key]
+  }
+  
+  return current
+}
+
+function setNestedValue(obj: any, path: string, value: any): void {
+  const keys = path.split('.')
+  const lastKey = keys.pop()!
+  let current = obj
+  
+  for (const key of keys) {
+    if (!(key in current) || typeof current[key] !== 'object') {
+      current[key] = {}
+    }
+    current = current[key]
+  }
+  
+  current[lastKey] = value
+}

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

@@ -0,0 +1,153 @@
+import { defineCommand, option } from '@bunli/core'
+import { z } from 'zod'
+import { CONFIG_FILE_NAME, DEFAULT_CONFIG } from '../utils/constants.js'
+
+export const initCommand = defineCommand({
+  name: 'init',
+  description: 'Initialize a new configuration file',
+  options: {
+    force: option(
+      z.boolean().default(false),
+      { 
+        short: 'f',
+        description: 'Overwrite existing config' 
+      }
+    ),
+    template: option(
+      z.enum(['minimal', 'default', 'full']).default('default'),
+      {
+        short: 't',
+        description: 'Config template to use'
+      }
+    )
+  },
+  handler: async ({ flags, colors, prompt, spinner }) => {
+    const configPath = `${process.cwd()}/${CONFIG_FILE_NAME}`
+    
+    // Check if config already exists
+    const configFile = Bun.file(configPath)
+    if (await configFile.exists() && !flags.force) {
+      const overwrite = await prompt.confirm(
+        `Config file already exists. Overwrite?`,
+        { default: false }
+      )
+      
+      if (!overwrite) {
+        console.log(colors.yellow('Init cancelled'))
+        return
+      }
+    }
+    
+    const spin = spinner('Creating config file...')
+    spin.start()
+    
+    try {
+      // Get template content
+      const configContent = getConfigTemplate(flags.template)
+      
+      // Write config file
+      await Bun.write(configPath, configContent)
+      
+      spin.succeed('Config file created')
+      console.log(colors.dim(`  ${CONFIG_FILE_NAME}`))
+      
+      // Next steps
+      console.log()
+      console.log('Next steps:')
+      console.log(colors.gray(`  1. Edit ${CONFIG_FILE_NAME} to customize your configuration`))
+      console.log(colors.gray(`  2. Run '{{projectName}} validate' to check your files`))
+      
+    } catch (error) {
+      spin.fail('Failed to create config file')
+      console.error(colors.red(String(error)))
+      process.exit(1)
+    }
+  }
+})
+
+function getConfigTemplate(template: 'minimal' | 'default' | 'full'): string {
+  const templates = {
+    minimal: `export default ${JSON.stringify(DEFAULT_CONFIG, null, 2)}`,
+    
+    default: `export default {
+  // Validation rules
+  rules: {
+    // Add your validation rules here
+    noConsoleLog: true,
+    requireFileHeader: false,
+  },
+  
+  // Server configuration
+  server: {
+    port: 3000,
+    host: 'localhost',
+    open: true,
+  },
+  
+  // File patterns
+  include: ['src/**/*.{js,ts}'],
+  exclude: ['node_modules', 'dist', 'test'],
+}`,
+    
+    full: `import { defineConfig } from '{{projectName}}'
+
+export default defineConfig({
+  // Validation rules
+  rules: {
+    // Code style rules
+    noConsoleLog: true,
+    noDebugger: true,
+    requireFileHeader: true,
+    maxLineLength: 100,
+    
+    // Import rules
+    noUnusedImports: true,
+    sortImports: true,
+    
+    // Function rules
+    maxFunctionLength: 50,
+    maxComplexity: 10,
+  },
+  
+  // Server configuration
+  server: {
+    port: process.env.PORT || 3000,
+    host: process.env.HOST || 'localhost',
+    open: !process.env.CI,
+    cors: true,
+  },
+  
+  // File patterns
+  include: [
+    'src/**/*.{js,ts,jsx,tsx}',
+    'scripts/**/*.{js,ts}',
+  ],
+  exclude: [
+    'node_modules',
+    'dist',
+    'build',
+    'coverage',
+    '**/*.test.{js,ts}',
+    '**/*.spec.{js,ts}',
+  ],
+  
+  // Caching
+  cache: {
+    enabled: true,
+    directory: '.cache',
+  },
+  
+  // Hooks
+  hooks: {
+    beforeValidate: async (files) => {
+      console.log(\`Validating \${files.length} files...\`)
+    },
+    afterValidate: async (results) => {
+      console.log(\`Found \${results.errors} errors and \${results.warnings} warnings\`)
+    },
+  },
+})`
+  }
+  
+  return templates[template]
+}