bunli 0.1.0

package/README.md

@@ -0,0 +1,247 @@
+# bunli
+
+The Bunli CLI toolchain for developing, building, and distributing CLI applications.
+
+## Installation
+
+```bash
+bun add -g bunli
+```
+
+## Usage
+
+### Development
+
+Run your CLI in development mode with hot reloading:
+
+```bash
+bunli dev
+
+# With custom entry file
+bunli dev --entry src/mycli.ts
+
+# Enable debugging
+bunli dev --inspect
+
+# Custom debug port
+bunli dev --inspect --port 9230
+
+# Pass arguments to your CLI
+bunli dev -- --help
+```
+
+Development options:
+- `--entry, -e` - Entry file (defaults to auto-detect)
+- `--watch, -w` - Watch for changes (default: true)
+- `--inspect, -i` - Enable debugger
+- `--port, -p` - Debugger port (default: 9229)
+
+### Building
+
+Build your CLI for production:
+
+```bash
+# Traditional build (requires Bun runtime)
+bunli build
+
+# Build standalone executables for specific platforms
+bunli build --targets darwin-arm64,linux-x64
+
+# Build for the current platform only
+bunli build --targets native
+
+# Build for all supported platforms
+bunli build --targets all
+```
+
+### Available Commands
+
+- `bunli init` - Initialize a new Bunli CLI project
+- `bunli dev` - Run CLI in development mode with hot reloading
+- `bunli build` - Build your CLI for production
+- `bunli test` - Run tests with Bun test runner
+- `bunli release` - Release your CLI package
+
+### Project Initialization
+
+Create a new Bunli CLI project:
+
+```bash
+# Interactive setup
+bunli init
+
+# With project name
+bunli init my-cli
+
+# Advanced template
+bunli init my-cli --template advanced
+
+# Specify directory
+bunli init --name my-cli --dir ./projects
+
+# Skip git/install
+bunli init --no-git --no-install
+```
+
+Init options:
+- `--name, -n` - Project name
+- `--template, -t` - Project template (basic/advanced/monorepo)
+- `--dir, -d` - Directory to create project in
+- `--git, -g` - Initialize git repository (default: true)
+- `--install` - Install dependencies (default: true)
+- `--package-manager, -p` - Package manager to use (bun/pnpm/yarn/npm)
+
+### Testing
+
+Run tests for your CLI:
+
+```bash
+# Run all tests
+bunli test
+
+# Watch mode
+bunli test --watch
+
+# Generate coverage
+bunli test --coverage
+
+# Run tests in all workspace packages
+bunli test --all
+```
+
+Test options:
+- `--pattern, -p` - Test file patterns
+- `--watch, -w` - Watch for changes
+- `--coverage, -c` - Generate coverage report
+- `--bail, -b` - Stop on first failure
+- `--timeout` - Test timeout in milliseconds
+- `--all` - Run tests in all packages (workspace mode)
+
+### Releasing
+
+Create a release of your CLI:
+
+```bash
+# Interactive release
+bunli release
+
+# Specific version bump
+bunli release --version patch
+bunli release --version minor
+bunli release --version major
+bunli release --version 2.0.0
+
+# Dry run
+bunli release --dry
+
+# Release all workspace packages
+bunli release --all
+```
+
+Release options:
+- `--version, -v` - Version to release (patch/minor/major/x.y.z)
+- `--tag, -t` - Git tag format
+- `--npm` - Publish to npm
+- `--github` - Create GitHub release
+- `--dry, -d` - Dry run - show what would be done
+- `--all` - Release all packages (workspace mode)
+
+### Build Options
+
+The `build` command supports several options:
+
+- `--entry, -e` - Entry file (defaults to auto-detect)
+- `--outdir, -o` - Output directory (default: ./dist)
+- `--outfile` - Output filename (for single executable)
+- `--targets, -t` - Target platforms for compilation (comma-separated)
+- `--minify, -m` - Minify output (default: true)
+- `--sourcemap, -s` - Generate sourcemaps
+- `--bytecode` - Enable bytecode compilation (experimental)
+- `--runtime, -r` - Runtime target for non-compiled builds (bun/node)
+- `--watch, -w` - Watch for changes
+
+### Standalone Executables
+
+Bunli creates standalone executables when you specify target platforms. This bundles your CLI application with the Bun runtime into a single binary that can run without requiring Bun to be installed.
+
+```bash
+# Build for specific platforms
+bunli build --targets darwin-arm64,linux-x64,windows-x64
+
+# Build for current platform only
+bunli build --targets native
+
+# Build for all platforms
+bunli build --targets all
+```
+
+Supported platforms:
+- `darwin-arm64` - macOS Apple Silicon
+- `darwin-x64` - macOS Intel
+- `linux-arm64` - Linux ARM64
+- `linux-x64` - Linux x64
+- `windows-x64` - Windows x64
+
+### Configuration
+
+Create a `bunli.config.ts` file in your project root:
+
+```typescript
+import { defineConfig } from 'bunli'
+
+export default defineConfig({
+  name: 'my-cli',
+  version: '1.0.0',
+  
+  build: {
+    entry: './src/cli.ts',
+    outdir: './dist',
+    targets: ['darwin-arm64', 'linux-x64'],  // Compile for these platforms
+    compress: true,  // Compress multi-platform builds
+    minify: true,
+    external: ['some-native-module']
+  },
+  
+  dev: {
+    watch: true,
+    inspect: false
+  }
+})
+```
+
+### Build Behavior
+
+The build system works as follows:
+
+1. **No targets specified** → Traditional JavaScript build
+   - Creates bundled `.js` files with shebangs
+   - Requires Bun (or Node.js) runtime to execute
+   - Supports multiple entry points
+
+2. **Targets specified** → Standalone executables
+   - Creates native binaries with embedded Bun runtime
+   - No runtime dependencies required
+   - Single entry point only
+   - Platform-specific subdirectories for multiple targets
+
+## Development
+
+To work on Bunli itself:
+
+```bash
+# Install dependencies
+bun install
+
+# Run in development
+bun run dev
+
+# Build
+bun run build
+
+# Run tests
+bun test
+```
+
+## License
+
+MIT

package/dist/cli.d.ts

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

package/dist/cli.js

@@ -0,0 +1,4 @@
+#!/usr/bin/env bun
+// @bun
+var U0=Object.defineProperty;var F=(B,L)=>{for(var O in L)U0(B,O,{get:L[O],enumerable:!0,configurable:!0,set:(I)=>L[O]=()=>I})};var x=(B,L)=>()=>(B&&(L=B(B=0)),L);import{z as K}from"zod";import X0 from"path";import{existsSync as Y0}from"fs";async function J(B=process.cwd()){for(let L of j0){let O=X0.join(B,L);if(Y0(O))try{let I=await import(O),q=I.default||I;return Z0.parse(q)}catch(I){throw console.error(`Error loading config from ${O}:`,I),I}}return{}}var Z0,j0;var T=x(()=>{Z0=K.object({name:K.string().optional(),version:K.string().optional(),description:K.string().optional(),commands:K.object({manifest:K.string().optional(),directory:K.string().optional()}).optional(),build:K.object({entry:K.string().or(K.array(K.string())).optional(),outdir:K.string().optional(),targets:K.array(K.string()).optional(),compress:K.boolean().optional(),external:K.array(K.string()).optional(),minify:K.boolean().optional(),sourcemap:K.boolean().optional()}).optional(),dev:K.object({watch:K.boolean().optional(),inspect:K.boolean().optional(),port:K.number().optional()}).optional(),test:K.object({pattern:K.string().or(K.array(K.string())).optional(),coverage:K.boolean().optional(),watch:K.boolean().optional()}).optional(),release:K.object({npm:K.boolean().optional(),github:K.boolean().optional(),tagFormat:K.string().optional(),conventionalCommits:K.boolean().optional()}).optional(),workspace:K.object({packages:K.array(K.string()).optional(),shared:K.any().optional(),versionStrategy:K.enum(["fixed","independent"]).optional()}).optional()}),j0=["bunli.config.ts","bunli.config.js","bunli.config.mjs"]});import{existsSync as p}from"fs";import c from"path";async function h(B=process.cwd()){for(let O of E0){let I=c.join(B,O);if(p(I))return O}let L=c.join(B,"package.json");if(p(L))try{let O=await Bun.file(L).json();if(O.bin){if(typeof O.bin==="string")return O.bin;else if(typeof O.bin==="object"){let I=Object.values(O.bin)[0];if(typeof I==="string")return I}}}catch{}return}var E0;var u=x(()=>{E0=["src/cli.ts","src/index.ts","src/main.ts","cli.ts","index.ts","main.ts","src/cli.js","src/index.js","src/main.js","cli.js","index.js","main.js"]});var f={};F(f,{default:()=>W0});import{defineCommand as H0,option as k}from"@bunli/core";import{z as m}from"zod";import{spawn as J0}from"child_process";var W0;var t=x(()=>{T();u();W0=H0({name:"dev",description:"Run your CLI in development mode with hot reload",alias:"d",options:{entry:k(m.string().optional(),{short:"e",description:"Entry file (defaults to auto-detect)"}),watch:k(m.boolean().default(!0),{short:"w",description:"Watch for changes"}),inspect:k(m.boolean().default(!1),{short:"i",description:"Enable debugger"}),port:k(m.number().int().min(1).max(65535).optional(),{short:"p",description:"Debugger port"})},handler:async({flags:B,positional:L,spinner:O,colors:I})=>{let q=await J(),M=B.entry||q.build?.entry||await h();if(!M)console.error(I.red("No entry file found. Please specify with --entry or in bunli.config.ts")),process.exit(1);let Q=Array.isArray(M)?M[0]:M;if(!Q)console.error(I.red("Entry file is required")),process.exit(1);let Y=["run"];if(B.watch??q.dev?.watch??!0)Y.push("--hot");if(B.inspect??q.dev?.inspect){let U=B.port||q.dev?.port||9229;Y.push(`--inspect=${U}`)}if(Y.push(Q),L.length>0)Y.push("--",...L);console.log(I.cyan("Starting dev server...")),console.log(I.dim(`> bun ${Y.join(" ")}`)),console.log(),J0("bun",Y,{stdio:"inherit",env:{...process.env,NODE_ENV:"development"}}).on("exit",(U)=>{process.exit(U||0)})}})});var i={};F(i,{default:()=>R0});import{defineCommand as _0,option as _}from"@bunli/core";import{z as R}from"zod";var{$:G}=globalThis.Bun;import $ from"path";var R0;var n=x(()=>{T();u();R0=_0({name:"build",description:"Build your CLI for production",alias:"b",options:{entry:_(R.string().optional(),{short:"e",description:"Entry file (defaults to auto-detect)"}),outdir:_(R.string().optional(),{short:"o",description:"Output directory"}),outfile:_(R.string().optional(),{description:"Output filename (for single executable)"}),minify:_(R.boolean().optional(),{short:"m",description:"Minify output"}),sourcemap:_(R.boolean().optional(),{short:"s",description:"Generate sourcemaps"}),bytecode:_(R.boolean().default(!1),{description:"Enable bytecode compilation (experimental)"}),runtime:_(R.enum(["bun","node"]).optional(),{short:"r",description:"Runtime target (for non-compiled builds)"}),targets:_(R.string().optional().transform((B)=>{if(!B)return;return B.split(",").map((L)=>L.trim())}),{short:"t",description:"Target platforms for compilation (e.g., darwin-arm64,linux-x64)"}),watch:_(R.boolean().default(!1),{short:"w",description:"Watch for changes"})},handler:async({flags:B,spinner:L,colors:O})=>{let I=await J(),q=B.entry||I.build?.entry||await h();if(!q)console.error(O.red("No entry file found. Please specify with --entry or in bunli.config.ts")),process.exit(1);let M=B.targets||I.build?.targets,Q=M&&M.length>0;if(Q&&Array.isArray(q))console.error(O.red("Compiled builds only support a single entry file")),process.exit(1);let Y=Array.isArray(q)?q[0]:q;if(!Y)console.error(O.red("Entry file is undefined")),process.exit(1);let Z=B.outdir||I.build?.outdir||"./dist",U=L("Building CLI...");U.start();try{if(await G`rm -rf ${Z}`,await G`mkdir -p ${Z}`,Q){U.update("Compiling to standalone executable...");let X=[];if(M.includes("all"))X=["darwin-arm64","darwin-x64","linux-arm64","linux-x64","windows-x64"];else if(M.includes("native"))X=[`${process.platform}-${process.arch}`];else X=M;for(let E of X){U.update(`Compiling for ${E}...`);let W=X.length>1?$.join(Z,E):Z;await G`mkdir -p ${W}`;let y=$.extname(Y),d=y?Y.slice(0,-y.length):Y,b=$.basename(d),q0=E.includes("windows"),K0=B.outfile||$.join(W,q0?`${b}.exe`:b),V=["build",Y,"--compile","--outfile",K0,"--target",`bun-${E}`];if(B.minify??I.build?.minify??!0)V.push("--minify");if(B.sourcemap??I.build?.sourcemap??!1)V.push("--sourcemap");if(B.bytecode)V.push("--bytecode");let M0=I.build?.external||[];for(let Q0 of M0)V.push("--external",Q0);if((await G`bun ${V}`.quiet()).exitCode!==0)throw new Error(`Compilation failed for ${E}`)}if(I.build?.compress&&X.length>1){U.update("Compressing builds...");for(let E of X)await G`cd ${Z} && tar -czf ${E}.tar.gz ${E}`,await G`rm -rf ${Z}/${E}`}}else{let E={entrypoints:Array.isArray(q)?q:[q],outdir:Z,target:B.runtime||"bun",format:"esm",minify:B.minify??I.build?.minify??!0,sourcemap:B.sourcemap??I.build?.sourcemap??!1,external:I.build?.external||[]},A=await Bun.build(E);if(!A.success)throw new Error(`Build failed: ${A.logs.join("\\n")}`);for(let W of A.outputs)if(W.path.endsWith(".js")){let y=await W.text(),b=`#!/usr/bin/env ${B.runtime==="node"?"node":"bun"}
+${y}`;await Bun.write(W.path,b),await G`chmod +x ${W.path}`}}U.succeed("Build complete!");let j=await G`du -sh ${Z}`.text();console.log(O.dim(`Output size: ${j.trim()}`))}catch(j){U.fail("Build failed"),console.error(O.red(j instanceof Error?j.message:String(j))),process.exit(1)}}})});var a={};F(a,{default:()=>S0});import{defineCommand as G0,option as P}from"@bunli/core";import{z as N}from"zod";import{spawn as N0}from"child_process";import{readdir as x0}from"fs/promises";import{existsSync as g}from"fs";import e from"path";async function l(B,L,O){return new Promise((I,q)=>{let M=["test"],Q=L.pattern||O.test?.pattern||"**/*.test.ts",Y=Array.isArray(Q)?Q:[Q];if(M.push(...Y),L.watch??O.test?.watch)M.push("--watch");if(L.coverage??O.test?.coverage)M.push("--coverage");if(L.bail)M.push("--bail");if(L.timeout)M.push("--timeout",L.timeout.toString());let Z=N0("bun",M,{cwd:B,stdio:["inherit","pipe","pipe"],env:{...process.env,NODE_ENV:"test"}}),U="",j="";Z.stdout?.on("data",(X)=>{U+=X.toString(),process.stdout.write(X)}),Z.stderr?.on("data",(X)=>{j+=X.toString(),process.stderr.write(X)}),Z.on("exit",(X)=>{let E=(U.match(/\u2713/g)||[]).length,A=(U.match(/\u2717/g)||[]).length,W=(U.match(/\u229D/g)||[]).length;I({success:X===0,passed:E,failed:A,skipped:W})}),Z.on("error",q)})}async function A0(B){if(B.endsWith("/*")){let L=B.slice(0,-2);if(g(L))return(await x0(L,{withFileTypes:!0})).filter((I)=>I.isDirectory()&&g(e.join(L,I.name,"package.json"))).map((I)=>e.join(L,I.name))}return[]}var S0;var r=x(()=>{T();S0=G0({name:"test",description:"Run tests for your CLI",alias:"t",options:{pattern:P(N.string().or(N.array(N.string())).optional(),{short:"p",description:"Test file patterns"}),watch:P(N.boolean().default(!1),{short:"w",description:"Watch for changes"}),coverage:P(N.boolean().default(!1),{short:"c",description:"Generate coverage report"}),bail:P(N.boolean().default(!1),{short:"b",description:"Stop on first failure"}),timeout:P(N.number().int().positive().optional(),{description:"Test timeout in milliseconds"}),all:P(N.boolean().default(!1),{description:"Run tests in all packages (workspace mode)"})},handler:async({flags:B,positional:L,spinner:O,colors:I})=>{let q=await J();if(B.all&&q.workspace?.packages){let M=q.workspace.packages,Q=!0;for(let Y of M){let Z=await A0(Y);for(let U of Z){let j=O(`Testing ${U}...`);j.start();try{if((await l(U,B,q)).success)j.succeed(`${U} tests passed`);else if(j.fail(`${U} tests failed`),Q=!1,B.bail)break}catch(X){if(j.fail(`${U} tests failed`),console.error(I.red(X instanceof Error?X.message:String(X))),Q=!1,B.bail)break}}if(!Q&&B.bail)break}if(!Q)process.exit(1)}else{let M=O("Running tests...");M.start();try{let Q=await l(".",B,q);if(Q.success){if(M.succeed("All tests passed!"),console.log(I.green(`\u2713 ${Q.passed} tests passed`)),Q.skipped>0)console.log(I.yellow(`\u229D ${Q.skipped} tests skipped`))}else M.fail("Tests failed"),console.log(I.red(`\u2717 ${Q.failed} tests failed`)),process.exit(1)}catch(Q){M.fail("Tests failed"),console.error(I.red(Q instanceof Error?Q.message:String(Q))),process.exit(1)}}}})});var o={};F(o,{default:()=>P0});import{defineCommand as T0,option as w}from"@bunli/core";import{z as S}from"zod";var{$:H}=globalThis.Bun;async function w0(B,L,O,I,q){let M=await z(),Q=M.version||"0.0.0",Y=await D0(B.version,Q,O);if(console.log(q.bold(`Releasing ${M.name||"CLI"}`)),console.log(q.dim(`  Current: ${Q}`)),console.log(q.dim(`  New:     ${Y}`)),console.log(),!B.dry){if(!await O.confirm("Continue with release?",{default:!0})){console.log(q.yellow("Release cancelled"));return}}let Z=[{name:"Running tests",cmd:()=>H`bun test`},{name:"Building project",cmd:()=>H`bun run build`},{name:"Updating version",cmd:()=>V0(Y)},{name:"Creating git tag",cmd:()=>F0(Y,L,B)},{name:"Publishing to npm",cmd:()=>$0(B,L)},{name:"Creating GitHub release",cmd:()=>v0(Y,B,L)}];for(let U of Z){if(U.name.includes("npm")&&!(B.npm??L.release?.npm??!0))continue;if(U.name.includes("GitHub")&&!(B.github??L.release?.github??!0))continue;let j=I(U.name);j.start();try{if(!B.dry)await U.cmd();j.succeed(U.name)}catch(X){if(j.fail(U.name),console.error(q.red(X instanceof Error?X.message:String(X))),!B.dry)process.exit(1)}}if(console.log(),console.log(q.green(`\u2728 Released ${M.name||"CLI"} v${Y}!`)),B.github??L.release?.github??!0)console.log(q.dim(`GitHub: https://github.com/${await s()}/releases/tag/v${Y}`));if(B.npm??L.release?.npm??!0)console.log(q.dim(`NPM: https://npmjs.com/package/${M.name}`))}async function C0(B,L,O,I,q){if(console.log(q.bold("Workspace Release")),L.workspace?.versionStrategy==="independent")console.log("Using independent versioning...");else console.log("Using fixed versioning...")}async function z(){return await Bun.file("package.json").json()}async function D0(B,L,O){if(B)if(["patch","minor","major"].includes(B))return v(L,B);else return B;let I=await O.select("Select version bump:",{choices:[{name:`patch (${v(L,"patch")})`,value:"patch"},{name:`minor (${v(L,"minor")})`,value:"minor"},{name:`major (${v(L,"major")})`,value:"major"},{name:"custom",value:"custom"}]});if(I==="custom")return await O("Enter version:");return v(L,I)}function v(B,L){let O=B.split(".").map(Number),[I=0,q=0,M=0]=O;switch(L){case"patch":return`${I}.${q}.${M+1}`;case"minor":return`${I}.${q+1}.0`;case"major":return`${I+1}.0.0`}}async function V0(B){let L=await z();L.version=B,await Bun.write("package.json",JSON.stringify(L,null,2)+"\\n")}async function F0(B,L,O){let q=(O.tag||L.release?.tagFormat||"v${version}").replace("${version}",B);await H`git add package.json`,await H`git commit -m "chore: release v${B}"`,await H`git tag ${q}`,await H`git push origin main --tags`}async function $0(B,L){if(!(B.npm??L.release?.npm??!0))return;if((await z()).private)throw new Error("Cannot publish private package to npm");await H`npm publish`}async function v0(B,L,O){if(!(L.github??O.release?.github??!0))return;let I=`v${B}`,q=await s();try{await H`gh --version`.quiet()}catch{console.warn("GitHub CLI not found, skipping GitHub release");return}await H`gh release create ${I} --title "Release ${I}" --generate-notes`}async function s(){return(await H`git remote get-url origin`.text()).match(/github\.com[:/]([^\s/]+\/[^\s/]+?)(?:\.git)?(?:\s|$)/)?.[1]??"unknown/repo"}var P0;var B0=x(()=>{T();P0=T0({name:"release",description:"Create a release of your CLI",alias:"r",options:{version:w(S.enum(["patch","minor","major"]).or(S.string()).optional(),{short:"v",description:"Version to release (patch/minor/major/x.y.z)"}),tag:w(S.string().optional(),{short:"t",description:"Git tag format"}),npm:w(S.boolean().optional(),{description:"Publish to npm"}),github:w(S.boolean().optional(),{description:"Create GitHub release"}),dry:w(S.boolean().default(!1),{short:"d",description:"Dry run - show what would be done"}),all:w(S.boolean().default(!1),{description:"Release all packages (workspace mode)"})},handler:async({flags:B,prompt:L,spinner:O,colors:I})=>{let q=await J();try{if((await H`git status --porcelain`.text()).trim()&&!B.dry)console.error(I.red("Working directory is not clean. Please commit or stash changes first.")),process.exit(1)}catch{console.error(I.red("Not a git repository")),process.exit(1)}if(B.all&&q.workspace?.packages)await C0(B,q,L,O,I);else await w0(B,q,L,O,I)}})});var I0={};F(I0,{default:()=>h0});import{defineCommand as y0,option as C}from"@bunli/core";import{z as D}from"zod";import{spawn as b0}from"child_process";var h0;var L0=x(()=>{h0=y0({name:"init",description:"Initialize a new Bunli CLI project",alias:"i",options:{name:C(D.string().optional(),{short:"n",description:"Project name"}),template:C(D.enum(["basic","advanced","monorepo"]).default("basic"),{short:"t",description:"Project template"}),dir:C(D.string().optional(),{short:"d",description:"Directory to create project in"}),git:C(D.boolean().default(!0),{short:"g",description:"Initialize git repository"}),install:C(D.boolean().default(!0),{description:"Install dependencies"}),"package-manager":C(D.enum(["bun","pnpm","yarn","npm"]).default("bun"),{short:"p",description:"Package manager to use"})},handler:async({flags:B,positional:L,colors:O})=>{console.log(O.cyan("\uD83D\uDE80 Creating new Bunli CLI project...")),console.log();let I=["create-bunli"];if(L[0])I.push(L[0]);else if(B.name)I.push(B.name);if(B.template!=="basic")I.push("--template",B.template);if(B.dir)I.push("--dir",B.dir);if(!B.git)I.push("--no-git");if(!B.install)I.push("--no-install");if(B["package-manager"]!=="bun")I.push("--package-manager",B["package-manager"]);console.log(O.dim(`> bunx ${I.join(" ")}`)),console.log();let q=b0("bunx",I,{stdio:"inherit",env:process.env});q.on("exit",(M)=>{if(M===0){console.log(),console.log(O.green("\uD83C\uDF89 Project created successfully!")),console.log(),console.log("Next steps:");let Q=L[0]||B.name||"your-project";console.log(O.gray(`  cd ${Q}`)),console.log(O.gray("  bunli dev"))}else console.error(O.red("Failed to create project")),process.exit(M||1)}),q.on("error",(M)=>{console.error(O.red("Failed to run create-bunli:"),M.message),console.log(),console.log("Make sure create-bunli is available:"),console.log(O.gray("  bunx create-bunli --help")),process.exit(1)})}})});T();import{createCLI as k0}from"@bunli/core";var O0=k0({name:"bunli",version:"0.1.0",description:"The Bunli CLI toolchain for developing, building, and distributing CLIs"}),GB=await J();await O0.load({dev:()=>Promise.resolve().then(() => (t(),f)),build:()=>Promise.resolve().then(() => (n(),i)),test:()=>Promise.resolve().then(() => (r(),a)),release:()=>Promise.resolve().then(() => (B0(),o)),init:()=>Promise.resolve().then(() => (L0(),I0))});await O0.run();

package/dist/commands/build.d.ts

@@ -0,0 +1,13 @@
+import { z } from 'zod';
+declare const _default: import("@bunli/core").Command<{
+    entry: import("@bunli/core").CLIOption<z.ZodOptional<z.ZodString>>;
+    outdir: import("@bunli/core").CLIOption<z.ZodOptional<z.ZodString>>;
+    outfile: import("@bunli/core").CLIOption<z.ZodOptional<z.ZodString>>;
+    minify: import("@bunli/core").CLIOption<z.ZodOptional<z.ZodBoolean>>;
+    sourcemap: import("@bunli/core").CLIOption<z.ZodOptional<z.ZodBoolean>>;
+    bytecode: import("@bunli/core").CLIOption<z.ZodDefault<z.ZodBoolean>>;
+    runtime: import("@bunli/core").CLIOption<z.ZodOptional<z.ZodEnum<["bun", "node"]>>>;
+    targets: import("@bunli/core").CLIOption<z.ZodEffects<z.ZodOptional<z.ZodString>, string[] | undefined, string | undefined>>;
+    watch: import("@bunli/core").CLIOption<z.ZodDefault<z.ZodBoolean>>;
+}>;
+export default _default;

package/dist/commands/dev.d.ts

@@ -0,0 +1,8 @@
+import { z } from 'zod';
+declare const _default: import("@bunli/core").Command<{
+    entry: import("@bunli/core").CLIOption<z.ZodOptional<z.ZodString>>;
+    watch: import("@bunli/core").CLIOption<z.ZodDefault<z.ZodBoolean>>;
+    inspect: import("@bunli/core").CLIOption<z.ZodDefault<z.ZodBoolean>>;
+    port: import("@bunli/core").CLIOption<z.ZodOptional<z.ZodNumber>>;
+}>;
+export default _default;

package/dist/commands/init.d.ts

@@ -0,0 +1,10 @@
+import { z } from 'zod';
+declare const _default: import("@bunli/core").Command<{
+    name: import("@bunli/core").CLIOption<z.ZodOptional<z.ZodString>>;
+    template: import("@bunli/core").CLIOption<z.ZodDefault<z.ZodEnum<["basic", "advanced", "monorepo"]>>>;
+    dir: import("@bunli/core").CLIOption<z.ZodOptional<z.ZodString>>;
+    git: import("@bunli/core").CLIOption<z.ZodDefault<z.ZodBoolean>>;
+    install: import("@bunli/core").CLIOption<z.ZodDefault<z.ZodBoolean>>;
+    'package-manager': import("@bunli/core").CLIOption<z.ZodDefault<z.ZodEnum<["bun", "pnpm", "yarn", "npm"]>>>;
+}>;
+export default _default;

package/dist/commands/release.d.ts

@@ -0,0 +1,10 @@
+import { z } from 'zod';
+declare const _default: import("@bunli/core").Command<{
+    version: import("@bunli/core").CLIOption<z.ZodOptional<z.ZodUnion<[z.ZodEnum<["patch", "minor", "major"]>, z.ZodString]>>>;
+    tag: import("@bunli/core").CLIOption<z.ZodOptional<z.ZodString>>;
+    npm: import("@bunli/core").CLIOption<z.ZodOptional<z.ZodBoolean>>;
+    github: import("@bunli/core").CLIOption<z.ZodOptional<z.ZodBoolean>>;
+    dry: import("@bunli/core").CLIOption<z.ZodDefault<z.ZodBoolean>>;
+    all: import("@bunli/core").CLIOption<z.ZodDefault<z.ZodBoolean>>;
+}>;
+export default _default;

package/dist/commands/test.d.ts

@@ -0,0 +1,10 @@
+import { z } from 'zod';
+declare const _default: import("@bunli/core").Command<{
+    pattern: import("@bunli/core").CLIOption<z.ZodOptional<z.ZodUnion<[z.ZodString, z.ZodArray<z.ZodString, "many">]>>>;
+    watch: import("@bunli/core").CLIOption<z.ZodDefault<z.ZodBoolean>>;
+    coverage: import("@bunli/core").CLIOption<z.ZodDefault<z.ZodBoolean>>;
+    bail: import("@bunli/core").CLIOption<z.ZodDefault<z.ZodBoolean>>;
+    timeout: import("@bunli/core").CLIOption<z.ZodOptional<z.ZodNumber>>;
+    all: import("@bunli/core").CLIOption<z.ZodDefault<z.ZodBoolean>>;
+}>;
+export default _default;

package/dist/config.d.ts

@@ -0,0 +1,175 @@
+import { z } from 'zod';
+export declare const bunliConfigSchema: z.ZodObject<{
+    name: z.ZodOptional<z.ZodString>;
+    version: z.ZodOptional<z.ZodString>;
+    description: z.ZodOptional<z.ZodString>;
+    commands: z.ZodOptional<z.ZodObject<{
+        manifest: z.ZodOptional<z.ZodString>;
+        directory: z.ZodOptional<z.ZodString>;
+    }, "strip", z.ZodTypeAny, {
+        manifest?: string | undefined;
+        directory?: string | undefined;
+    }, {
+        manifest?: string | undefined;
+        directory?: string | undefined;
+    }>>;
+    build: z.ZodOptional<z.ZodObject<{
+        entry: z.ZodOptional<z.ZodUnion<[z.ZodString, z.ZodArray<z.ZodString, "many">]>>;
+        outdir: z.ZodOptional<z.ZodString>;
+        targets: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+        compress: z.ZodOptional<z.ZodBoolean>;
+        external: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+        minify: z.ZodOptional<z.ZodBoolean>;
+        sourcemap: z.ZodOptional<z.ZodBoolean>;
+    }, "strip", z.ZodTypeAny, {
+        entry?: string | string[] | undefined;
+        outdir?: string | undefined;
+        targets?: string[] | undefined;
+        compress?: boolean | undefined;
+        external?: string[] | undefined;
+        minify?: boolean | undefined;
+        sourcemap?: boolean | undefined;
+    }, {
+        entry?: string | string[] | undefined;
+        outdir?: string | undefined;
+        targets?: string[] | undefined;
+        compress?: boolean | undefined;
+        external?: string[] | undefined;
+        minify?: boolean | undefined;
+        sourcemap?: boolean | undefined;
+    }>>;
+    dev: z.ZodOptional<z.ZodObject<{
+        watch: z.ZodOptional<z.ZodBoolean>;
+        inspect: z.ZodOptional<z.ZodBoolean>;
+        port: z.ZodOptional<z.ZodNumber>;
+    }, "strip", z.ZodTypeAny, {
+        watch?: boolean | undefined;
+        inspect?: boolean | undefined;
+        port?: number | undefined;
+    }, {
+        watch?: boolean | undefined;
+        inspect?: boolean | undefined;
+        port?: number | undefined;
+    }>>;
+    test: z.ZodOptional<z.ZodObject<{
+        pattern: z.ZodOptional<z.ZodUnion<[z.ZodString, z.ZodArray<z.ZodString, "many">]>>;
+        coverage: z.ZodOptional<z.ZodBoolean>;
+        watch: z.ZodOptional<z.ZodBoolean>;
+    }, "strip", z.ZodTypeAny, {
+        watch?: boolean | undefined;
+        pattern?: string | string[] | undefined;
+        coverage?: boolean | undefined;
+    }, {
+        watch?: boolean | undefined;
+        pattern?: string | string[] | undefined;
+        coverage?: boolean | undefined;
+    }>>;
+    release: z.ZodOptional<z.ZodObject<{
+        npm: z.ZodOptional<z.ZodBoolean>;
+        github: z.ZodOptional<z.ZodBoolean>;
+        tagFormat: z.ZodOptional<z.ZodString>;
+        conventionalCommits: z.ZodOptional<z.ZodBoolean>;
+    }, "strip", z.ZodTypeAny, {
+        npm?: boolean | undefined;
+        github?: boolean | undefined;
+        tagFormat?: string | undefined;
+        conventionalCommits?: boolean | undefined;
+    }, {
+        npm?: boolean | undefined;
+        github?: boolean | undefined;
+        tagFormat?: string | undefined;
+        conventionalCommits?: boolean | undefined;
+    }>>;
+    workspace: z.ZodOptional<z.ZodObject<{
+        packages: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+        shared: z.ZodOptional<z.ZodAny>;
+        versionStrategy: z.ZodOptional<z.ZodEnum<["fixed", "independent"]>>;
+    }, "strip", z.ZodTypeAny, {
+        packages?: string[] | undefined;
+        shared?: any;
+        versionStrategy?: "fixed" | "independent" | undefined;
+    }, {
+        packages?: string[] | undefined;
+        shared?: any;
+        versionStrategy?: "fixed" | "independent" | undefined;
+    }>>;
+}, "strip", z.ZodTypeAny, {
+    name?: string | undefined;
+    version?: string | undefined;
+    description?: string | undefined;
+    commands?: {
+        manifest?: string | undefined;
+        directory?: string | undefined;
+    } | undefined;
+    build?: {
+        entry?: string | string[] | undefined;
+        outdir?: string | undefined;
+        targets?: string[] | undefined;
+        compress?: boolean | undefined;
+        external?: string[] | undefined;
+        minify?: boolean | undefined;
+        sourcemap?: boolean | undefined;
+    } | undefined;
+    dev?: {
+        watch?: boolean | undefined;
+        inspect?: boolean | undefined;
+        port?: number | undefined;
+    } | undefined;
+    test?: {
+        watch?: boolean | undefined;
+        pattern?: string | string[] | undefined;
+        coverage?: boolean | undefined;
+    } | undefined;
+    release?: {
+        npm?: boolean | undefined;
+        github?: boolean | undefined;
+        tagFormat?: string | undefined;
+        conventionalCommits?: boolean | undefined;
+    } | undefined;
+    workspace?: {
+        packages?: string[] | undefined;
+        shared?: any;
+        versionStrategy?: "fixed" | "independent" | undefined;
+    } | undefined;
+}, {
+    name?: string | undefined;
+    version?: string | undefined;
+    description?: string | undefined;
+    commands?: {
+        manifest?: string | undefined;
+        directory?: string | undefined;
+    } | undefined;
+    build?: {
+        entry?: string | string[] | undefined;
+        outdir?: string | undefined;
+        targets?: string[] | undefined;
+        compress?: boolean | undefined;
+        external?: string[] | undefined;
+        minify?: boolean | undefined;
+        sourcemap?: boolean | undefined;
+    } | undefined;
+    dev?: {
+        watch?: boolean | undefined;
+        inspect?: boolean | undefined;
+        port?: number | undefined;
+    } | undefined;
+    test?: {
+        watch?: boolean | undefined;
+        pattern?: string | string[] | undefined;
+        coverage?: boolean | undefined;
+    } | undefined;
+    release?: {
+        npm?: boolean | undefined;
+        github?: boolean | undefined;
+        tagFormat?: string | undefined;
+        conventionalCommits?: boolean | undefined;
+    } | undefined;
+    workspace?: {
+        packages?: string[] | undefined;
+        shared?: any;
+        versionStrategy?: "fixed" | "independent" | undefined;
+    } | undefined;
+}>;
+export type BunliConfig = z.infer<typeof bunliConfigSchema>;
+export declare function loadConfig(cwd?: string): Promise<BunliConfig>;
+export declare function defineConfig(config: BunliConfig): BunliConfig;

package/dist/index.d.ts

@@ -0,0 +1,3 @@
+export { defineConfig, loadConfig, type BunliConfig } from './config.js';
+export { findEntry } from './utils/find-entry.js';
+export declare const version = "0.1.0";

package/dist/index.js

@@ -0,0 +1,119 @@
+// @bun
+// src/config.ts
+import { z } from "zod";
+import path from "path";
+import { existsSync } from "fs";
+var bunliConfigSchema = z.object({
+  name: z.string().optional(),
+  version: z.string().optional(),
+  description: z.string().optional(),
+  commands: z.object({
+    manifest: z.string().optional(),
+    directory: z.string().optional()
+  }).optional(),
+  build: z.object({
+    entry: z.string().or(z.array(z.string())).optional(),
+    outdir: z.string().optional(),
+    targets: z.array(z.string()).optional(),
+    compress: z.boolean().optional(),
+    external: z.array(z.string()).optional(),
+    minify: z.boolean().optional(),
+    sourcemap: z.boolean().optional()
+  }).optional(),
+  dev: z.object({
+    watch: z.boolean().optional(),
+    inspect: z.boolean().optional(),
+    port: z.number().optional()
+  }).optional(),
+  test: z.object({
+    pattern: z.string().or(z.array(z.string())).optional(),
+    coverage: z.boolean().optional(),
+    watch: z.boolean().optional()
+  }).optional(),
+  release: z.object({
+    npm: z.boolean().optional(),
+    github: z.boolean().optional(),
+    tagFormat: z.string().optional(),
+    conventionalCommits: z.boolean().optional()
+  }).optional(),
+  workspace: z.object({
+    packages: z.array(z.string()).optional(),
+    shared: z.any().optional(),
+    versionStrategy: z.enum(["fixed", "independent"]).optional()
+  }).optional()
+});
+var CONFIG_NAMES = [
+  "bunli.config.ts",
+  "bunli.config.js",
+  "bunli.config.mjs"
+];
+async function loadConfig(cwd = process.cwd()) {
+  for (const configName of CONFIG_NAMES) {
+    const configPath = path.join(cwd, configName);
+    if (existsSync(configPath)) {
+      try {
+        const module = await import(configPath);
+        const config = module.default || module;
+        return bunliConfigSchema.parse(config);
+      } catch (error) {
+        console.error(`Error loading config from ${configPath}:`, error);
+        throw error;
+      }
+    }
+  }
+  return {};
+}
+function defineConfig(config) {
+  return config;
+}
+// src/utils/find-entry.ts
+import { existsSync as existsSync2 } from "fs";
+import path2 from "path";
+var COMMON_ENTRIES = [
+  "src/cli.ts",
+  "src/index.ts",
+  "src/main.ts",
+  "cli.ts",
+  "index.ts",
+  "main.ts",
+  "src/cli.js",
+  "src/index.js",
+  "src/main.js",
+  "cli.js",
+  "index.js",
+  "main.js"
+];
+async function findEntry(cwd = process.cwd()) {
+  for (const entry of COMMON_ENTRIES) {
+    const fullPath = path2.join(cwd, entry);
+    if (existsSync2(fullPath)) {
+      return entry;
+    }
+  }
+  const pkgPath = path2.join(cwd, "package.json");
+  if (existsSync2(pkgPath)) {
+    try {
+      const pkg = await Bun.file(pkgPath).json();
+      if (pkg.bin) {
+        if (typeof pkg.bin === "string") {
+          return pkg.bin;
+        } else if (typeof pkg.bin === "object") {
+          const firstBin = Object.values(pkg.bin)[0];
+          if (typeof firstBin === "string") {
+            return firstBin;
+          }
+        }
+      }
+    } catch {}
+  }
+  return;
+}
+
+// src/index.ts
+var version = "0.1.0";
+export {
+  version,
+  loadConfig,
+  findEntry,
+  defineConfig
+};

package/dist/utils/find-entry.d.ts

@@ -0,0 +1 @@
+export declare function findEntry(cwd?: string): Promise<string | undefined>;

package/package.json

@@ -0,0 +1,60 @@
+{
+  "name": "bunli",
+  "version": "0.1.0",
+  "type": "module",
+  "description": "The Bunli CLI toolchain for developing, building, and distributing CLIs",
+  "bin": {
+    "bunli": "./dist/cli.js"
+  },
+  "module": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "exports": {
+    ".": {
+      "import": "./dist/index.js",
+      "types": "./dist/index.d.ts"
+    }
+  },
+  "files": [
+    "dist"
+  ],
+  "author": "Arya Labs, Inc.",
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/AryaLabsHQ/bunli.git",
+    "directory": "packages/cli"
+  },
+  "bugs": {
+    "url": "https://github.com/AryaLabsHQ/bunli/issues"
+  },
+  "homepage": "https://github.com/AryaLabsHQ/bunli#readme",
+  "keywords": [
+    "bunli",
+    "cli",
+    "toolchain",
+    "bun",
+    "typescript",
+    "build-tool",
+    "development"
+  ],
+  "scripts": {
+    "dev": "bun run src/cli.ts",
+    "build": "bun run scripts/build.ts && bun run tsc",
+    "build:standalone": "bun run scripts/build.ts --compile",
+    "build:binaries": "bun run scripts/release-binaries.ts",
+    "test": "bun test",
+    "type-check": "tsc --noEmit",
+    "prepublishOnly": "bun run build"
+  },
+  "dependencies": {
+    "@bunli/core": "0.1.0",
+    "@bunli/utils": "0.1.0",
+    "glob": "^11.0.0",
+    "zod": "^3.24.1"
+  },
+  "devDependencies": {
+    "@types/bun": "latest",
+    "bun-types": "latest",
+    "typescript": "^5.8.0"
+  }
+}