@crustjs/crust 0.0.1

package/README.md

@@ -0,0 +1,131 @@
+# @crustjs/crust
+
+The all-in-one package for the [Crust](https://crust.cyanlabs.co) CLI framework.
+
+Re-exports everything from `@crustjs/core` and `@crustjs/plugins`, plus provides CLI tooling for building Crust-powered CLIs.
+
+## Install
+
+```sh
+bun add @crustjs/crust
+```
+
+## Framework API
+
+The `@crustjs/crust` package gives you the full framework API in a single import:
+
+```ts
+import {
+  defineCommand,
+  runMain,
+  helpPlugin,
+  versionPlugin,
+} from "@crustjs/crust";
+
+const main = defineCommand({
+  meta: { name: "my-cli", description: "My CLI tool" },
+  run() {
+    console.log("Hello!");
+  },
+});
+
+runMain(main, {
+  plugins: [versionPlugin("1.0.0"), helpPlugin()],
+});
+```
+
+> For granular control, you can install `@crustjs/core` and `@crustjs/plugins` separately.
+
+## CLI Commands
+
+When installed, the `crust` binary provides tooling for your project:
+
+| Command       | Description                                      |
+| ------------- | ------------------------------------------------ |
+| `crust build` | Compile your CLI to standalone Bun executable(s) |
+
+### `crust build`
+
+Compiles your CLI entry file to standalone Bun executables using `bun build --compile`.
+
+**By default, builds for all 5 supported platforms** and generates a JS resolver script that detects the host platform at runtime and runs the correct binary. This makes it easy to distribute your CLI as a single npm package that works everywhere.
+
+```sh
+crust build                          # All platforms + JS resolver (default)
+crust build --entry src/main.ts      # Custom entry point
+crust build --name my-tool           # Set base binary name
+crust build --no-minify              # Disable minification
+```
+
+To build for specific platform(s) only, use `--target`:
+
+```sh
+crust build --target linux-x64                          # Single platform
+crust build --target linux-x64 --target darwin-arm64    # Multiple platforms
+crust build --target linux-x64 --outfile ./my-cli       # Custom output (single target only)
+```
+
+#### Supported Targets
+
+| Alias          | Bun Target                 | Platform            |
+| -------------- | -------------------------- | ------------------- |
+| `linux-x64`    | `bun-linux-x64-baseline`   | Linux x86_64        |
+| `linux-arm64`  | `bun-linux-arm64`          | Linux ARM64         |
+| `darwin-x64`   | `bun-darwin-x64`           | macOS Intel         |
+| `darwin-arm64` | `bun-darwin-arm64`         | macOS Apple Silicon |
+| `windows-x64`  | `bun-windows-x64-baseline` | Windows x86_64      |
+
+#### Flags
+
+| Flag        | Alias | Type      | Default             | Description                                  |
+| ----------- | ----- | --------- | ------------------- | -------------------------------------------- |
+| `--entry`   | `-e`  | `String`  | `src/cli.ts`        | Entry file path                              |
+| `--outfile` | `-o`  | `String`  | —                   | Output file path (single-target builds only) |
+| `--name`    | `-n`  | `String`  | package.json `name` | Base binary name                             |
+| `--minify`  | —     | `Boolean` | `true`              | Minify the output                            |
+| `--target`  | `-t`  | `String`  | _(all platforms)_   | Target platform(s); repeatable               |
+
+#### Output
+
+**All-platform build** (default, no `--target`):
+
+```
+dist/
+  my-cli.js                         # JS resolver (entry point for npm bin)
+  my-cli-bun-linux-x64-baseline     # Linux x64 binary
+  my-cli-bun-linux-arm64            # Linux ARM64 binary
+  my-cli-bun-darwin-x64             # macOS Intel binary
+  my-cli-bun-darwin-arm64           # macOS Apple Silicon binary
+  my-cli-bun-windows-x64-baseline.exe  # Windows x64 binary
+```
+
+**Single-target build** (`--target <alias>`):
+
+```
+dist/
+  my-cli                            # Single binary (no resolver)
+```
+
+#### Distributing via npm
+
+After building for all platforms, configure your `package.json` to use the JS resolver as the bin entry:
+
+```json
+{
+  "name": "my-cli",
+  "bin": {
+    "my-cli": "dist/my-cli.js"
+  },
+  "files": ["dist"]
+}
+```
+
+The resolver uses `#!/usr/bin/env node` for maximum compatibility when installed globally via npm (works even when Bun is not installed on the end user's machine).
+
+## Documentation
+
+See the full docs at [crust.cyanlabs.co](https://crust.cyanlabs.co).
+
+## License
+
+MIT

package/dist/cli.d.ts

@@ -0,0 +1,12 @@
+import { Command } from "@crustjs/core";
+/**
+* The root `crust` CLI command.
+*
+* Built entirely with `@crustjs/core`.
+* When invoked without a subcommand, displays help listing available commands.
+*
+* Subcommands:
+* - `crust build` - Compile your CLI to a standalone Bun executable
+*/
+declare const crustCommand: Command;
+export { crustCommand };

package/dist/cli.js

@@ -0,0 +1,346 @@
+#!/usr/bin/env bun
+// @bun
+
+// src/cli.ts
+import { defineCommand as defineCommand2, runMain } from "@crustjs/core";
+import {
+  autoCompletePlugin,
+  helpPlugin,
+  versionPlugin
+} from "@crustjs/plugins";
+// package.json
+var package_default = {
+  name: "@crustjs/crust",
+  version: "0.0.1",
+  description: "A Bun-native, TypeScript-first CLI framework with a composable package ecosystem.",
+  type: "module",
+  license: "MIT",
+  author: "chenxin-yan",
+  repository: {
+    type: "git",
+    url: "git+https://github.com/chenxin-yan/crust.git",
+    directory: "packages/crust"
+  },
+  homepage: "https://crust.cyanlabs.co",
+  bugs: {
+    url: "https://github.com/chenxin-yan/crust/issues"
+  },
+  keywords: [
+    "cli",
+    "command",
+    "framework",
+    "parser",
+    "bun",
+    "typescript",
+    "plugin"
+  ],
+  files: [
+    "dist"
+  ],
+  exports: {
+    ".": {
+      import: "./dist/index.js",
+      types: "./dist/index.d.ts"
+    }
+  },
+  publishConfig: {
+    access: "public"
+  },
+  bin: {
+    crust: "dist/cli.js"
+  },
+  scripts: {
+    build: "bunup",
+    dev: "bun ./src/cli.ts",
+    "check:types": "tsc --noEmit",
+    test: "bun test"
+  },
+  dependencies: {
+    "@crustjs/core": "workspace:*",
+    "@crustjs/plugins": "workspace:*"
+  },
+  devDependencies: {
+    "@crustjs/config": "workspace:*",
+    bunup: "catalog:"
+  },
+  peerDependencies: {
+    typescript: "catalog:"
+  }
+};
+
+// src/commands/build.ts
+import { existsSync, readFileSync, writeFileSync } from "fs";
+import { basename, join, resolve } from "path";
+import { defineCommand } from "@crustjs/core";
+var SUPPORTED_TARGETS = [
+  "bun-linux-x64-baseline",
+  "bun-linux-arm64",
+  "bun-darwin-x64",
+  "bun-darwin-arm64",
+  "bun-windows-x64-baseline"
+];
+var TARGET_ALIASES = {
+  "linux-x64": "bun-linux-x64-baseline",
+  "linux-arm64": "bun-linux-arm64",
+  "darwin-x64": "bun-darwin-x64",
+  "darwin-arm64": "bun-darwin-arm64",
+  "windows-x64": "bun-windows-x64-baseline"
+};
+var TARGET_PLATFORM_MAP = {
+  "bun-linux-x64-baseline": "linux-x64",
+  "bun-linux-arm64": "linux-arm64",
+  "bun-darwin-x64": "darwin-x64",
+  "bun-darwin-arm64": "darwin-arm64",
+  "bun-windows-x64-baseline": "win32-x64"
+};
+function resolveTarget(input) {
+  if (SUPPORTED_TARGETS.includes(input)) {
+    return input;
+  }
+  const aliased = TARGET_ALIASES[input];
+  if (aliased) {
+    return aliased;
+  }
+  const validTargets = [
+    ...Object.keys(TARGET_ALIASES),
+    ...SUPPORTED_TARGETS
+  ].join(", ");
+  throw new Error(`Unknown target "${input}"
+  Valid targets: ${validTargets}`);
+}
+function resolveBaseName(name, entry, cwd) {
+  if (name) {
+    return name;
+  }
+  const pkgPath = join(cwd, "package.json");
+  if (existsSync(pkgPath)) {
+    try {
+      const pkgJson = JSON.parse(readFileSync(pkgPath, "utf-8"));
+      if (pkgJson?.name && typeof pkgJson.name === "string") {
+        return pkgJson.name.replace(/^@[^/]+\//, "");
+      }
+    } catch {}
+  }
+  return basename(entry).replace(/\.[^.]+$/, "");
+}
+function resolveOutfile(outfile, name, entry, cwd) {
+  if (outfile) {
+    return resolve(cwd, outfile);
+  }
+  const baseName = resolveBaseName(name, entry, cwd);
+  return resolve(cwd, "dist", baseName);
+}
+function resolveTargetOutfile(baseName, target, cwd) {
+  const isWindows = target.startsWith("bun-windows");
+  const ext = isWindows ? ".exe" : "";
+  return resolve(cwd, "dist", `${baseName}-${target}${ext}`);
+}
+function getBinaryFilename(baseName, target) {
+  const isWindows = target.startsWith("bun-windows");
+  const ext = isWindows ? ".exe" : "";
+  return `${baseName}-${target}${ext}`;
+}
+function generateResolver(baseName, targets) {
+  const entries = [];
+  for (const target of targets) {
+    const platformKey = TARGET_PLATFORM_MAP[target];
+    const filename = getBinaryFilename(baseName, target);
+    entries.push(`	"${platformKey}": "${filename}"`);
+  }
+  const mapBody = entries.join(`,
+`);
+  return `#!/usr/bin/env node
+"use strict";
+
+const { execFileSync } = require("node:child_process");
+const { chmodSync, statSync } = require("node:fs");
+const path = require("node:path");
+
+const PLATFORM_ARCH = \`\${process.platform}-\${process.arch}\`;
+
+const TARGET_MAP = {
+${mapBody}
+};
+
+const binaryName = TARGET_MAP[PLATFORM_ARCH];
+
+if (!binaryName) {
+	console.error(
+		\`[${baseName}] Unsupported platform: \${PLATFORM_ARCH}. \` +
+			"Please open an issue with your OS/CPU details."
+	);
+	process.exit(1);
+}
+
+const binPath = path.join(__dirname, binaryName);
+
+try {
+	statSync(binPath);
+} catch {
+	console.error(\`[${baseName}] Prebuilt binary not found: \${binPath}\`);
+	console.error(\`[${baseName}] Expected binary for \${PLATFORM_ARCH}: \${binaryName}\`);
+	console.error(\`[${baseName}] Try reinstalling the package.\`);
+	process.exit(1);
+}
+
+// Ensure binary is executable on Unix
+if (process.platform !== "win32") {
+	try {
+		const stats = statSync(binPath);
+		if ((stats.mode & 0o111) === 0) {
+			chmodSync(binPath, stats.mode | 0o111);
+		}
+	} catch {
+		try {
+			chmodSync(binPath, 0o755);
+		} catch {
+			// If chmod fails, continue and let execFileSync report the error
+		}
+	}
+}
+
+try {
+	execFileSync(binPath, process.argv.slice(2), { stdio: "inherit" });
+} catch (error) {
+	if (error && typeof error === "object" && "status" in error && typeof error.status === "number") {
+		process.exit(error.status);
+	}
+	process.exit(1);
+}
+`;
+}
+function writeResolver(resolverPath, baseName, targets) {
+  const content = generateResolver(baseName, targets);
+  writeFileSync(resolverPath, content, { mode: 493 });
+}
+function buildBunArgs(entryPath, outfilePath, minify, target) {
+  const args = [
+    "build",
+    "--compile",
+    entryPath,
+    "--outfile",
+    outfilePath
+  ];
+  if (target) {
+    args.push("--target", target);
+  }
+  if (minify) {
+    args.push("--minify");
+  }
+  return args;
+}
+async function execBuild(args, cwd, outfilePath) {
+  const proc = Bun.spawn(["bun", ...args], {
+    cwd,
+    stdout: "pipe",
+    stderr: "pipe"
+  });
+  const exitCode = await proc.exited;
+  if (exitCode !== 0) {
+    const stderr = await new Response(proc.stderr).text();
+    throw new Error(`Build failed for ${outfilePath} (exit code ${exitCode})${stderr ? `:
+${stderr.trim()}` : ""}`);
+  }
+}
+var buildCommand = defineCommand({
+  meta: {
+    name: "build",
+    description: "Compile your CLI to a standalone executable"
+  },
+  flags: {
+    entry: {
+      type: String,
+      description: "Entry file path",
+      default: "src/cli.ts",
+      alias: "e"
+    },
+    outfile: {
+      type: String,
+      description: "Output file path (single-target builds only)",
+      alias: "o"
+    },
+    name: {
+      type: String,
+      description: "Binary name (defaults to package.json name or entry filename)",
+      alias: "n"
+    },
+    minify: {
+      type: Boolean,
+      description: "Minify the output",
+      default: true
+    },
+    target: {
+      type: String,
+      multiple: true,
+      description: "Target platform(s) to compile for (e.g. linux-x64, darwin-arm64). Omit to build all.",
+      alias: "t"
+    }
+  },
+  async run({ flags }) {
+    const cwd = process.cwd();
+    const entryPath = resolve(cwd, flags.entry);
+    if (!existsSync(entryPath)) {
+      throw new Error(`Entry file not found: ${entryPath}
+  Specify a valid entry file with --entry <path>`);
+    }
+    const targets = resolveTargets(flags.target);
+    if (flags.outfile && targets.length > 1) {
+      throw new Error(`--outfile cannot be used when building for multiple targets.
+  Use --name to set the base binary name instead.`);
+    }
+    if (targets.length === 1) {
+      const outfilePath = resolveOutfile(flags.outfile, flags.name, entryPath, cwd);
+      const args = buildBunArgs(entryPath, outfilePath, flags.minify, targets[0]);
+      console.log(`Building ${entryPath} \u2192 ${outfilePath}...`);
+      await execBuild(args, cwd, outfilePath);
+      console.log(`Built successfully: ${outfilePath}`);
+    } else {
+      const baseName = resolveBaseName(flags.name, entryPath, cwd);
+      console.log(`Building ${entryPath} for ${targets.length} target(s)...`);
+      const results = [];
+      for (const target of targets) {
+        const targetOutfile = resolveTargetOutfile(baseName, target, cwd);
+        const args = buildBunArgs(entryPath, targetOutfile, flags.minify, target);
+        console.log(`  \u2192 ${target}: ${targetOutfile}`);
+        await execBuild(args, cwd, targetOutfile);
+        results.push(targetOutfile);
+      }
+      const resolverPath = resolve(cwd, "dist", `${baseName}.js`);
+      writeResolver(resolverPath, baseName, targets);
+      console.log(`
+Built ${results.length} target(s) successfully:`);
+      for (const r of results) {
+        console.log(`  ${r}`);
+      }
+      console.log(`
+Resolver: ${resolverPath}`);
+    }
+  }
+});
+function resolveTargets(targetFlags) {
+  if (!targetFlags || targetFlags.length === 0) {
+    return [...SUPPORTED_TARGETS];
+  }
+  return targetFlags.map(resolveTarget);
+}
+
+// src/cli.ts
+var crustCommand = defineCommand2({
+  meta: {
+    name: package_default.name,
+    description: package_default.description
+  },
+  subCommands: {
+    build: buildCommand
+  }
+});
+runMain(crustCommand, {
+  plugins: [
+    versionPlugin(package_default.version),
+    autoCompletePlugin({ mode: "help" }),
+    helpPlugin()
+  ]
+});
+export {
+  crustCommand
+};

package/dist/index.d.ts

@@ -0,0 +1,2 @@
+export * from "@crustjs/core";
+export * from "@crustjs/plugins";

package/dist/index.js

@@ -0,0 +1,4 @@
+// @bun
+// src/index.ts
+export * from "@crustjs/core";
+export * from "@crustjs/plugins";

package/package.json

@@ -0,0 +1,58 @@
+{
+	"name": "@crustjs/crust",
+	"version": "0.0.1",
+	"description": "A Bun-native, TypeScript-first CLI framework with a composable package ecosystem.",
+	"type": "module",
+	"license": "MIT",
+	"author": "chenxin-yan",
+	"repository": {
+		"type": "git",
+		"url": "git+https://github.com/chenxin-yan/crust.git",
+		"directory": "packages/crust"
+	},
+	"homepage": "https://crust.cyanlabs.co",
+	"bugs": {
+		"url": "https://github.com/chenxin-yan/crust/issues"
+	},
+	"keywords": [
+		"cli",
+		"command",
+		"framework",
+		"parser",
+		"bun",
+		"typescript",
+		"plugin"
+	],
+	"files": [
+		"dist"
+	],
+	"exports": {
+		".": {
+			"import": "./dist/index.js",
+			"types": "./dist/index.d.ts"
+		}
+	},
+	"publishConfig": {
+		"access": "public"
+	},
+	"bin": {
+		"crust": "dist/cli.js"
+	},
+	"scripts": {
+		"build": "bunup",
+		"dev": "bun ./src/cli.ts",
+		"check:types": "tsc --noEmit",
+		"test": "bun test"
+	},
+	"dependencies": {
+		"@crustjs/core": "workspace:*",
+		"@crustjs/plugins": "workspace:*"
+	},
+	"devDependencies": {
+		"@crustjs/config": "workspace:*",
+		"bunup": "catalog:"
+	},
+	"peerDependencies": {
+		"typescript": "catalog:"
+	}
+}