create-bunli 0.1.0

package/README.md

@@ -0,0 +1,302 @@
+# create-bunli
+
+Scaffold new Bunli CLI projects with ease.
+
+## Quick Start
+
+```bash
+# Using bunx (recommended)
+bunx create-bunli my-cli
+
+# Using npm
+npm create bunli@latest my-cli
+
+# Using yarn
+yarn create bunli my-cli
+
+# Using pnpm
+pnpm create bunli my-cli
+```
+
+## Features
+
+- 🚀 **Fast scaffolding** - Get started in seconds
+- 📦 **Multiple templates** - Choose from basic, advanced, or monorepo setups
+- 🔧 **TypeScript ready** - Full TypeScript support out of the box
+- 🧪 **Testing included** - Comes with @bunli/test for CLI testing
+- 🎨 **Best practices** - Follows Bunli conventions and patterns
+- 🌐 **Flexible sources** - Use bundled templates or any GitHub repository
+
+## Usage
+
+### Basic Usage
+
+Create a new project with the default template:
+
+```bash
+bunx create-bunli my-cli
+```
+
+### Using Templates
+
+Choose from bundled templates:
+
+```bash
+# Basic single-command CLI
+bunx create-bunli my-cli --template basic
+
+# Advanced multi-command CLI with subcommands
+bunx create-bunli my-cli --template advanced
+
+# Monorepo setup with Turborepo
+bunx create-bunli my-cli --template monorepo
+```
+
+### Using External Templates
+
+Use any GitHub repository as a template:
+
+```bash
+# GitHub repository
+bunx create-bunli my-cli --template username/repo
+
+# With full GitHub URL
+bunx create-bunli my-cli --template github:username/repo
+
+# Specific branch or tag
+bunx create-bunli my-cli --template username/repo#branch
+```
+
+### Options
+
+```bash
+bunx create-bunli [name] [options]
+
+Options:
+  -t, --template <template>    Project template (default: "basic")
+  -d, --dir <dir>             Directory to create project in
+  -p, --package-manager <pm>   Package manager (bun, npm, yarn, pnpm) (default: "bun")
+  -g, --git                   Initialize git repository (default: true)
+  -i, --install               Install dependencies (default: true)
+  --offline                   Use cached templates when available
+  -h, --help                  Display help
+  -v, --version               Display version
+```
+
+### Examples
+
+```bash
+# Create in current directory
+bunx create-bunli .
+
+# Create with specific package manager
+bunx create-bunli my-cli --package-manager pnpm
+
+# Create without installing dependencies
+bunx create-bunli my-cli --no-install
+
+# Create in custom directory
+bunx create-bunli my-cli --dir ~/projects/my-cli
+
+# Use external template
+bunx create-bunli my-cli --template pvtnbr/bunli-starter
+```
+
+## Templates
+
+### Basic Template
+
+Perfect for simple CLI tools with a single command.
+
+**Features:**
+- Single command setup
+- TypeScript configuration
+- Test setup with @bunli/test
+- Build script using bunli
+
+**Structure:**
+```
+my-cli/
+├── src/
+│   ├── index.ts         # CLI entry point
+│   └── commands/
+│       └── hello.ts     # Example command
+├── test/
+│   └── hello.test.ts    # Example test
+├── package.json
+├── tsconfig.json
+└── README.md
+```
+
+### Advanced Template
+
+For complex CLIs with multiple commands and features.
+
+**Features:**
+- Multiple commands with subcommands
+- Configuration management
+- File validation system
+- Built-in development server
+- Advanced command examples
+
+**Commands included:**
+- `init` - Initialize configuration
+- `validate` - Validate files with rules
+- `serve` - Start development server
+- `config` - Manage configuration
+
+**Structure:**
+```
+my-cli/
+├── src/
+│   ├── index.ts         # CLI entry point
+│   ├── commands/        # Command implementations
+│   │   ├── init.ts
+│   │   ├── validate.ts
+│   │   ├── serve.ts
+│   │   └── config.ts
+│   └── utils/          # Utility functions
+│       ├── config.ts
+│       ├── validator.ts
+│       └── glob.ts
+├── test/
+├── package.json
+├── tsconfig.json
+└── README.md
+```
+
+### Monorepo Template
+
+For large projects with multiple packages.
+
+**Features:**
+- Turborepo configuration
+- Multiple packages setup
+- Shared dependencies
+- Changeset support
+- Parallel builds
+
+**Structure:**
+```
+my-cli/
+├── packages/
+│   ├── cli/            # Main CLI package
+│   ├── core/           # Core functionality
+│   └── utils/          # Shared utilities
+├── turbo.json          # Turborepo config
+├── package.json        # Root package.json
+├── tsconfig.json       # Root TypeScript config
+└── README.md
+```
+
+## Creating Custom Templates
+
+Templates can include a `template.json` manifest:
+
+```json
+{
+  "name": "my-template",
+  "description": "My custom template",
+  "variables": [
+    {
+      "name": "projectName",
+      "message": "Project name",
+      "type": "string",
+      "default": "my-project"
+    },
+    {
+      "name": "license",
+      "message": "License",
+      "type": "select",
+      "choices": ["MIT", "Apache-2.0", "GPL-3.0"]
+    }
+  ]
+}
+```
+
+### Template Variables
+
+Use these variables in your template files:
+
+- `{{projectName}}` - The project name
+- `{{description}}` - Project description
+- `{{author}}` - Author name
+- `{{license}}` - License type
+- `{{year}}` - Current year
+- `{{packageManager}}` - Selected package manager
+
+Variables can be used in file contents and filenames:
+- `__projectName__.config.js` → `my-app.config.js`
+
+## Programmatic Usage
+
+```typescript
+import { createProject } from 'create-bunli'
+
+await createProject({
+  name: 'my-cli',
+  template: 'advanced',
+  packageManager: 'bun',
+  install: true,
+  git: true
+})
+```
+
+## Development
+
+```bash
+# Clone the repository
+git clone https://github.com/AryaLabsHQ/bunli.git
+cd bunli/packages/create-bunli
+
+# Install dependencies
+bun install
+
+# Run in development
+bun dev
+
+# Run tests
+bun test
+
+# Build
+bun run build
+```
+
+## Troubleshooting
+
+### Template not found
+
+If you get a "template not found" error, ensure:
+- The template name is correct
+- For GitHub templates, the repository exists and is public
+- You have internet connection (for external templates)
+
+### Installation fails
+
+If dependency installation fails:
+- Check your internet connection
+- Ensure the package manager is installed
+- Try running with `--no-install` and install manually
+
+### Permission errors
+
+If you get permission errors:
+- Ensure you have write access to the target directory
+- Try running in a different directory
+- Check disk space availability
+
+## Contributing
+
+Contributions are welcome! Please read our [Contributing Guide](../../CONTRIBUTING.md) for details.
+
+### Adding a New Template
+
+1. Create a new directory in `templates/`
+2. Add all template files
+3. Create a `template.json` manifest
+4. Test the template thoroughly
+5. Submit a pull request
+
+## License
+
+MIT © [Arya Labs, Inc.](../../LICENSE)

package/dist/cli.d.ts

@@ -0,0 +1,2 @@
+#!/usr/bin/env bun
+export {};

package/dist/cli.js

@@ -0,0 +1,310 @@
+#!/usr/bin/env bun
+#!/usr/bin/env bun
+// @bun
+
+// src/cli.ts
+import { createCLI, defineCommand, option } from "@bunli/core";
+import { z } from "zod";
+
+// 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/create.ts
+import path from "path";
+async function create(context) {
+  const { flags, positional, prompt, spinner, colors, shell } = context;
+  let projectName = positional[0] || flags.name;
+  if (!projectName) {
+    projectName = await prompt("Project name:", {
+      validate: (value) => {
+        if (!value)
+          return "Project name is required";
+        if (!/^[a-z0-9-]+$/.test(value)) {
+          return "Project name must only contain lowercase letters, numbers, and hyphens";
+        }
+        return true;
+      }
+    });
+  } else if (!/^[a-z0-9-]+$/.test(projectName)) {
+    console.error(colors.red("Project name must only contain lowercase letters, numbers, and hyphens"));
+    process.exit(1);
+  }
+  const projectDir = flags.dir || path.join(process.cwd(), projectName);
+  console.log();
+  console.log(colors.bold("Creating Bunli project:"));
+  console.log(colors.dim("  Name:     ") + colors.cyan(projectName));
+  console.log(colors.dim("  Template: ") + colors.cyan(flags.template));
+  console.log(colors.dim("  Location: ") + colors.cyan(projectDir));
+  console.log(colors.dim("  Git:      ") + colors.cyan(flags.git ? "Yes" : "No"));
+  console.log(colors.dim("  Install:  ") + colors.cyan(flags.install ? "Yes" : "No"));
+  console.log(colors.dim("  Package:  ") + colors.cyan(flags["package-manager"]));
+  console.log();
+  const confirmed = await prompt.confirm("Continue?", { default: true });
+  if (!confirmed) {
+    console.log(colors.red("Cancelled"));
+    process.exit(1);
+  }
+  console.log();
+  await createProject({
+    name: projectName,
+    dir: projectDir,
+    template: flags.template,
+    git: flags.git,
+    install: flags.install,
+    packageManager: flags["package-manager"],
+    offline: flags.offline,
+    prompt,
+    spinner,
+    colors,
+    shell
+  });
+  console.log();
+  console.log(colors.green("\u2728 Project created successfully!"));
+  console.log();
+  console.log("Next steps:");
+  console.log(colors.gray(`  cd ${path.relative(process.cwd(), projectDir)}`));
+  if (!flags.install) {
+    console.log(colors.gray(`  ${flags["package-manager"]} install`));
+  }
+  if (flags.template === "monorepo") {
+    console.log(colors.gray(`  ${flags["package-manager"]} run dev`));
+  } else {
+    console.log(colors.gray(`  ${flags["package-manager"] === "bun" ? "bun" : flags["package-manager"] + " run"} dev`));
+  }
+  console.log();
+}
+
+// src/cli.ts
+async function run() {
+  const args = process.argv.slice(2);
+  if (args.length === 0 || args[0]?.startsWith("-")) {
+    process.argv.splice(2, 0, "create");
+  } else if (args[0] && !args[0].startsWith("-") && args[0] !== "create") {
+    process.argv.splice(2, 0, "create");
+  }
+  const cli = createCLI({
+    name: "create-bunli",
+    version: "0.1.0",
+    description: "Scaffold new Bunli CLI projects"
+  });
+  cli.command(defineCommand({
+    name: "create",
+    description: "Create a new Bunli CLI project",
+    options: {
+      name: option(z.string().optional(), { description: "Project name" }),
+      template: option(z.string().default("basic"), { short: "t", description: "Project template (basic, advanced, monorepo, or github:user/repo)" }),
+      dir: option(z.string().optional(), { short: "d", description: "Directory to create project in" }),
+      git: option(z.boolean().default(true), { short: "g", description: "Initialize git repository" }),
+      install: option(z.boolean().default(true), { short: "i", description: "Install dependencies" }),
+      "package-manager": option(z.enum(["bun", "pnpm", "yarn", "npm"]).default("bun"), { short: "p", description: "Package manager to use" }),
+      offline: option(z.boolean().default(false), { description: "Use cached templates when available" })
+    },
+    handler: create
+  }));
+  await cli.run();
+}
+await run();

package/dist/create-project.d.ts

@@ -0,0 +1,13 @@
+import type { BunliUtils } from '@bunli/utils';
+import type { CreateOptions } from './types.js';
+interface CreateProjectOptions extends CreateOptions {
+    name: string;
+    dir: string;
+    template: string;
+    prompt: BunliUtils['prompt'];
+    spinner: BunliUtils['spinner'];
+    colors: BunliUtils['colors'];
+    shell: typeof Bun.$;
+}
+export declare function createProject(options: CreateProjectOptions): Promise<void>;
+export {};

package/dist/create.d.ts

@@ -0,0 +1,13 @@
+import type { HandlerArgs } from '@bunli/core';
+import type { PackageManager } from './types.js';
+interface CreateOptions {
+    name?: string;
+    template: string;
+    dir?: string;
+    git: boolean;
+    install: boolean;
+    'package-manager': PackageManager;
+    offline?: boolean;
+}
+export declare function create(context: HandlerArgs<CreateOptions>): Promise<void>;
+export {};

package/dist/index.d.ts

@@ -0,0 +1,4 @@
+export { createProject } from './create-project.js';
+export { processTemplate, resolveTemplateSource, isLocalTemplate } from './template-engine.js';
+export type { CreateOptions, ProjectConfig, TemplateManifest, TemplateVariable } from './types.js';
+export declare const version = "0.1.0";