@zfadhli/koko-cli 0.1.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2025 Koko contributors
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,206 @@
+# koko
+
+**Composition-based CLI toolkit** — wraps [cac](https://github.com/egoist/cac), [picocolors](https://github.com/alexeyraspopov/picocolors), [cli-progress](https://github.com/nicejade/cli-progress), and [cli-spinners](https://github.com/sindresorhus/cli-spinners) into a cohesive, function-based API.
+
+## Design
+
+koko follows a **function-based Composition API** (inspired by Vue 3):
+
+- **Stateless utilities** (colors, CLI builder) are plain objects — no factory needed
+- **Stateful widgets** (spinner, progress) are factory functions — closures, not classes
+- **Progressive complexity** — `ctx.spinner()` is a one-liner; `import { createSpinner }` for standalone use
+- **Minimal API surface** — 4 imports cover everything
+
+## Install
+
+```bash
+bun add @zfadhli/koko-cli
+# or
+npm install @zfadhli/koko-cli
+```
+
+## Quick start
+
+```ts
+import { color, createSpinner, createProgress, createCLI } from "@zfadhli/koko-cli";
+
+// Colors
+console.log(color.red("error"));
+console.log(color.bold(color.green("success")));
+
+// Spinner
+const spin = createSpinner("Loading...");
+spin.start();
+await someWork();
+spin.succeed("Done!");
+
+// Progress bar
+const bar = createProgress({ total: 100 });
+bar.update(50);
+bar.stop();
+
+// CLI app
+const cli = createCLI("my-app", "1.0.0").description("My CLI");
+cli.command("build <input>", "Build project", (cmd) => {
+  cmd.option("--out <dir>", "Output dir", { default: "dist" });
+  cmd.action(async (options, ctx) => {
+    const spin = ctx.spinner("Building...");
+    spin.start();
+    // ...
+    spin.succeed("Built!");
+  });
+});
+cli.parse();
+```
+
+## API
+
+### `color`
+
+A plain object with all picocolors functions:
+
+```ts
+color.red("text")         // red text
+color.green("text")       // green text
+color.bold("text")        // bold text
+color.dim("text")         // dim text
+color.italic("text")      // italic
+color.underline("text")   // underline
+// ... and 18 more (all bright variants, bg variants omitted for brevity)
+
+// Nesting
+color.bold(color.red("bold red text"))
+```
+
+### `createSpinner(text?, options?)`
+
+Creates a terminal spinner with start/stop lifecycle.
+
+```ts
+const spin = createSpinner("Installing...");
+spin.start();
+// ... async work
+spin.succeed("Installed!");   // ✔ Installed!
+spin.fail("Failed!");         // ✘ Failed!
+spin.warn("Caution!");        // ⚠ Caution!
+spin.info("Note!");           // ℹ Note!
+
+// Custom style
+createSpinner("Loading", { style: "arc", color: "cyan" });
+```
+
+**Options:**
+
+| Option | Type | Default |
+|--------|------|---------|
+| `text` | `string` | `""` |
+| `style` | `SpinnerStyle` | `"dots"` |
+| `color` | `ColorName` | — (no color) |
+| `frames` | `string[]` | from style |
+| `interval` | `number` | from style |
+
+### `createProgress(options)`
+
+Creates a terminal progress bar.
+
+```ts
+const bar = createProgress({ total: 100 });
+bar.update(50);          // set exact value
+bar.increment(10);       // increment by delta
+bar.stop();
+
+// With custom format and payload
+const bar = createProgress({
+  total: 10,
+  format: "  {bar}  {percentage}%  |  Installing {package}",
+});
+bar.increment(1, { package: "koko" });
+```
+
+**Options:**
+
+| Option | Type | Default |
+|--------|------|---------|
+| `total` | `number` | **(required)** |
+| `start` | `number` | `0` |
+| `format` | `string` | rect preset |
+| `barsize` | `number` | terminal width |
+| `barCompleteChar` | `string` | `■` |
+| `barIncompleteChar` | `string` | ` ` (space) |
+| `clearOnComplete` | `boolean` | `false` |
+| `stopOnComplete` | `boolean` | `false` |
+
+### `createCLI(name, version?)`
+
+Creates an opinionated CLI application builder (wraps cac).
+
+- Auto-attaches `--help` and `--version`
+- Action handlers receive `(options, ctx)` with typed options
+- `ctx` provides `.spinner()`, `.progress()`, `.color`
+
+```ts
+const cli = createCLI("deploy", "1.0.0")
+  .description("Deployment tool");
+
+cli.command("build <input>", "Build project", (cmd) => {
+  cmd.option("--out <dir>", "Output dir", { default: "dist" });
+  cmd.option("--prod", "Production mode");
+  cmd.action(async (options, ctx) => {
+    // options: { input: string; out: string; prod: boolean }
+    // ctx:     { spinner, progress, color }
+    const spin = ctx.spinner("Compiling...");
+    spin.start();
+    await build(options.input);
+    spin.succeed("Built!");
+  });
+});
+
+cli.parse();
+```
+
+### Icons
+
+Standardized icon constants:
+
+```ts
+import { ICON_SUCCESS, ICON_ERROR, ICON_WARN, ICON_INFO } from "@zfadhli/koko-cli";
+```
+
+| Constant | Character | Description |
+|----------|-----------|-------------|
+| `ICON_SUCCESS` | `✔` | Success / complete |
+| `ICON_ERROR` | `✘` | Error / failure |
+| `ICON_WARN` | `⚠` | Warning |
+| `ICON_INFO` | `ℹ` | Info |
+
+### Errors
+
+```ts
+import { CliToolkitError } from "@zfadhli/koko-cli";
+
+try {
+  createProgress({ total: 0 });
+} catch (err) {
+  if (err instanceof CliToolkitError) {
+    console.error(err.message); // "total must be > 0, got 0"
+  }
+}
+```
+
+## Examples
+
+```bash
+# Run any example
+bun run examples/01-color.ts        # all color functions
+bun run examples/02-spinner.ts      # spinner lifecycle + styles
+bun run examples/03-progress.ts     # progress bars + payloads
+bun run examples/04-cli-app.ts      # full CLI app with ctx
+bun run examples/05-composition.ts  # real-world patterns
+
+# All at once
+bun run examples
+```
+
+## License
+
+MIT

package/dist/index.d.mts

@@ -0,0 +1,161 @@
+//#region src/color.d.ts
+type ColorName = "black" | "red" | "green" | "yellow" | "blue" | "magenta" | "cyan" | "white" | "gray" | "blackBright" | "redBright" | "greenBright" | "yellowBright" | "blueBright" | "magentaBright" | "cyanBright" | "whiteBright";
+type StyleName = "reset" | "bold" | "dim" | "italic" | "underline" | "inverse" | "hidden" | "strikethrough";
+type ColorFunctions = { [K in ColorName | StyleName]: (text: string) => string };
+/**
+ * Minimal color palette — a plain object wrapping picocolors.
+ *
+ * Stateless, no factory needed. Import and use:
+ *
+ * ```ts
+ * import { color } from 'koko'
+ * color.red('error')
+ * color.bold(color.green('success'))
+ * ```
+ */
+declare const color: ColorFunctions;
+//#endregion
+//#region src/types.d.ts
+interface ProgressOptions {
+  total: number;
+  start?: number;
+  format?: string;
+  barCompleteChar?: string;
+  barIncompleteChar?: string;
+  barsize?: number;
+  clearOnComplete?: boolean;
+  stopOnComplete?: boolean;
+}
+interface ProgressInstance {
+  update(current: number, payload?: Record<string, unknown>): void;
+  increment(delta?: number, payload?: Record<string, unknown>): void;
+  stop(): void;
+  readonly total: number;
+  readonly value: number;
+}
+type SpinnerStyle = "dots" | "dots2" | "line" | "arc" | "bouncingBar" | "clock" | "moon" | "toggle" | "arrow" | "shark";
+interface SpinnerOptions {
+  text?: string;
+  style?: SpinnerStyle;
+  color?: ColorName;
+  frames?: string[];
+  interval?: number;
+}
+interface SpinnerInstance {
+  start(text?: string): void;
+  stop(finalText?: string): void;
+  succeed(text?: string): void;
+  fail(text?: string): void;
+  warn(text?: string): void;
+  info(text?: string): void;
+  text: string;
+  isSpinning: boolean;
+}
+type CLIAction<T = Record<string, unknown>> = (options: T, ctx: CommandContext) => void | Promise<void>;
+interface CommandContext {
+  spinner(text?: string): SpinnerInstance;
+  progress(options: ProgressOptions): ProgressInstance;
+  color: { [K in ColorName | StyleName]: (text: string) => string };
+}
+interface OptionConfig {
+  default?: unknown;
+  required?: boolean;
+}
+interface CommandBuilder {
+  option(name: string, description?: string, config?: OptionConfig): CommandBuilder;
+  alias(name: string): CommandBuilder;
+  action<T>(handler: CLIAction<T>): void;
+}
+type CommandSetup = (cmd: CommandBuilder) => void;
+interface CLIBuilder {
+  command(name: string, description: string, setup: CommandSetup): CLIBuilder;
+  description(text: string): CLIBuilder;
+  parse(argv?: string[]): void;
+}
+//#endregion
+//#region src/cli.d.ts
+/**
+ * Create a CLI application with an opinionated builder API.
+ *
+ * Auto-attaches `--help` and `--version`. Each command's action handler
+ * receives a typed options object and a `ctx` with built-in access to
+ * spinner, progress bar, and colors.
+ *
+ * ```ts
+ * const cli = createCLI('my-app', '1.0.0').description('My CLI')
+ *
+ * cli.command('build <input>', 'Build the project', (cmd) => {
+ *   cmd.option('--out <dir>', 'Output dir', { default: 'dist' })
+ *   cmd.option('--prod', 'Production mode')
+ *   cmd.action(async (options, ctx) => {
+ *     const spin = ctx.spinner('Building...')
+ *     spin.start()
+ *     // ...
+ *     spin.succeed('Built!')
+ *   })
+ * })
+ *
+ * cli.parse()
+ * ```
+ */
+declare function createCLI(name: string, version?: string): CLIBuilder;
+//#endregion
+//#region src/errors.d.ts
+declare class CliToolkitError extends Error {
+  constructor(message: string);
+}
+//#endregion
+//#region src/icons.d.ts
+/**
+ * Standardized terminal icons.
+ *
+ * Single source of truth for all status symbols used across koko.
+ * Import these instead of hardcoding Unicode characters.
+ *
+ * ```ts
+ * import { ICON_SUCCESS, ICON_ERROR } from "koko"
+ * console.log(`${ICON_SUCCESS} Build complete`)
+ * ```
+ */
+/** ✔ — success / complete */
+declare const ICON_SUCCESS = "\u2714 ";
+/** ✘ — error / failure */
+declare const ICON_ERROR = "\u2718 ";
+/** ⚠ — warning */
+declare const ICON_WARN = "\u26A0 ";
+/** ℹ — info */
+declare const ICON_INFO = "\u2139 ";
+//#endregion
+//#region src/progress.d.ts
+/**
+ * Create a terminal progress bar.
+ *
+ * ```ts
+ * const bar = createProgress({ total: 100 })
+ * bar.update(50)
+ * // ...
+ * bar.stop()
+ * ```
+ *
+ * Returns a {@link ProgressInstance} wrapping cli-progress's `SingleBar`.
+ * Throws {@link CliToolkitError} if `total` is missing or <= 0.
+ */
+declare function createProgress(options: ProgressOptions): ProgressInstance;
+//#endregion
+//#region src/spinner.d.ts
+/**
+ * Create a terminal spinner.
+ *
+ * ```ts
+ * const spin = createSpinner('Installing...')
+ * spin.start()
+ * // ... async work
+ * spin.succeed('Installed!')
+ * ```
+ *
+ * Returns a {@link SpinnerInstance} with start/stop lifecycle
+ * and convenience methods (succeed, fail, warn, info).
+ */
+declare function createSpinner(text?: string, options?: SpinnerOptions): SpinnerInstance;
+//#endregion
+export { type CLIAction, type CLIBuilder, CliToolkitError, type ColorName, type CommandBuilder, type CommandContext, type CommandSetup, ICON_ERROR, ICON_INFO, ICON_SUCCESS, ICON_WARN, type OptionConfig, type ProgressInstance, type ProgressOptions, type SpinnerInstance, type SpinnerOptions, type SpinnerStyle, type StyleName, color, createCLI, createProgress, createSpinner };

package/dist/index.mjs

@@ -0,0 +1,329 @@
+import cac from "cac";
+import pc from "picocolors";
+import cliProgress from "cli-progress";
+import process$1 from "node:process";
+import spinners from "cli-spinners";
+//#region src/color.ts
+/**
+* Minimal color palette — a plain object wrapping picocolors.
+*
+* Stateless, no factory needed. Import and use:
+*
+* ```ts
+* import { color } from 'koko'
+* color.red('error')
+* color.bold(color.green('success'))
+* ```
+*/
+const color = {
+	reset: pc.reset,
+	bold: pc.bold,
+	dim: pc.dim,
+	italic: pc.italic,
+	underline: pc.underline,
+	inverse: pc.inverse,
+	hidden: pc.hidden,
+	strikethrough: pc.strikethrough,
+	black: pc.black,
+	red: pc.red,
+	green: pc.green,
+	yellow: pc.yellow,
+	blue: pc.blue,
+	magenta: pc.magenta,
+	cyan: pc.cyan,
+	white: pc.white,
+	gray: pc.gray,
+	blackBright: pc.blackBright,
+	redBright: pc.redBright,
+	greenBright: pc.greenBright,
+	yellowBright: pc.yellowBright,
+	blueBright: pc.blueBright,
+	magentaBright: pc.magentaBright,
+	cyanBright: pc.cyanBright,
+	whiteBright: pc.whiteBright
+};
+//#endregion
+//#region src/errors.ts
+var CliToolkitError = class extends Error {
+	constructor(message) {
+		super(message);
+		this.name = "CliToolkitError";
+	}
+};
+//#endregion
+//#region src/progress.ts
+/**
+* Create a terminal progress bar.
+*
+* ```ts
+* const bar = createProgress({ total: 100 })
+* bar.update(50)
+* // ...
+* bar.stop()
+* ```
+*
+* Returns a {@link ProgressInstance} wrapping cli-progress's `SingleBar`.
+* Throws {@link CliToolkitError} if `total` is missing or <= 0.
+*/
+function createProgress(options) {
+	if (options.total <= 0) throw new CliToolkitError(`Progress total must be > 0, got ${options.total}`);
+	const bar = new cliProgress.SingleBar({
+		format: options.format,
+		barCompleteChar: options.barCompleteChar,
+		barIncompleteChar: options.barIncompleteChar,
+		barsize: options.barsize,
+		clearOnComplete: options.clearOnComplete,
+		stopOnComplete: options.stopOnComplete
+	}, cliProgress.Presets.rect);
+	let started = false;
+	let currentValue = options.start ?? 0;
+	function ensureStarted() {
+		if (!started) {
+			bar.start(options.total, currentValue);
+			started = true;
+		}
+	}
+	return {
+		get total() {
+			return options.total;
+		},
+		get value() {
+			return currentValue;
+		},
+		update(current, payload) {
+			currentValue = current;
+			ensureStarted();
+			bar.update(current, payload);
+		},
+		increment(delta, payload) {
+			ensureStarted();
+			currentValue += delta ?? 1;
+			bar.update(currentValue, payload);
+		},
+		stop() {
+			if (started) {
+				bar.stop();
+				started = false;
+			}
+		}
+	};
+}
+//#endregion
+//#region src/icons.ts
+/**
+* Standardized terminal icons.
+*
+* Single source of truth for all status symbols used across koko.
+* Import these instead of hardcoding Unicode characters.
+*
+* ```ts
+* import { ICON_SUCCESS, ICON_ERROR } from "koko"
+* console.log(`${ICON_SUCCESS} Build complete`)
+* ```
+*/
+/** ✔ — success / complete */
+const ICON_SUCCESS = "✔ ";
+/** ✘ — error / failure */
+const ICON_ERROR = "✘ ";
+/** ⚠ — warning */
+const ICON_WARN = "⚠ ";
+/** ℹ — info */
+const ICON_INFO = "ℹ ";
+//#endregion
+//#region src/spinner.ts
+const frameSets = {
+	dots: spinners.dots,
+	dots2: spinners.dots2,
+	line: spinners.line,
+	arc: spinners.arc,
+	bouncingBar: spinners.bouncingBar,
+	clock: spinners.clock,
+	moon: spinners.moon,
+	toggle: spinners.toggle12,
+	arrow: spinners.arrow3,
+	shark: spinners.shark
+};
+const defaultStyle = "dots";
+/**
+* Create a terminal spinner.
+*
+* ```ts
+* const spin = createSpinner('Installing...')
+* spin.start()
+* // ... async work
+* spin.succeed('Installed!')
+* ```
+*
+* Returns a {@link SpinnerInstance} with start/stop lifecycle
+* and convenience methods (succeed, fail, warn, info).
+*/
+function createSpinner(text, options) {
+	const { text: initialText = text ?? "", style = defaultStyle, color: spinnerColor, frames: customFrames, interval: customInterval } = options ?? {};
+	const frameSet = frameSets[style];
+	if (!frameSet && !customFrames) throw new CliToolkitError(`Unknown spinner style: "${style}". Available styles: ${Object.keys(frameSets).join(", ")}`);
+	const frames = customFrames ?? frameSet.frames;
+	const interval = customInterval ?? frameSet.interval;
+	let timer = null;
+	let index = 0;
+	let currentText = initialText;
+	let spinning = false;
+	function write(frame) {
+		const coloredFrame = spinnerColor ? color[spinnerColor](frame) : frame;
+		const line = currentText ? `${coloredFrame} ${currentText}` : coloredFrame;
+		process$1.stdout.write(`\r${line}\x1b[K`);
+	}
+	function clear() {
+		process$1.stdout.write("\r\x1B[K");
+	}
+	function start(newText) {
+		if (spinning) return;
+		if (newText !== void 0) currentText = newText;
+		spinning = true;
+		index = 0;
+		clear();
+		write(frames[0]);
+		timer = setInterval(() => {
+			index = (index + 1) % frames.length;
+			write(frames[index]);
+		}, interval);
+	}
+	function stop(finalText) {
+		if (!spinning) return;
+		spinning = false;
+		if (timer) {
+			clearInterval(timer);
+			timer = null;
+		}
+		if (finalText !== void 0) {
+			clear();
+			process$1.stdout.write(`${finalText}\n`);
+		} else clear();
+	}
+	function succeed(text) {
+		const t = text ?? currentText;
+		stop(`${color.green(ICON_SUCCESS)} ${t}`);
+	}
+	function fail(text) {
+		const t = text ?? currentText;
+		stop(`${color.red(ICON_ERROR)} ${t}`);
+	}
+	function warn(text) {
+		const t = text ?? currentText;
+		stop(`${color.yellow(ICON_WARN)} ${t}`);
+	}
+	function info(text) {
+		const t = text ?? currentText;
+		stop(`${color.blue(ICON_INFO)} ${t}`);
+	}
+	return {
+		get text() {
+			return currentText;
+		},
+		set text(val) {
+			currentText = val;
+		},
+		get isSpinning() {
+			return spinning;
+		},
+		start,
+		stop,
+		succeed,
+		fail,
+		warn,
+		info
+	};
+}
+//#endregion
+//#region src/cli.ts
+/**
+* Parse positional argument names from a CAC command pattern.
+*
+* `'build <input> [output]'` → `['input', 'output']`
+*/
+function parsePositionalNames(rawName) {
+	const names = [];
+	const re = /[<[](\w+)[>\]]/g;
+	for (let match = re.exec(rawName); match; match = re.exec(rawName)) names.push(match[1]);
+	return names;
+}
+/**
+* Create a CLI application with an opinionated builder API.
+*
+* Auto-attaches `--help` and `--version`. Each command's action handler
+* receives a typed options object and a `ctx` with built-in access to
+* spinner, progress bar, and colors.
+*
+* ```ts
+* const cli = createCLI('my-app', '1.0.0').description('My CLI')
+*
+* cli.command('build <input>', 'Build the project', (cmd) => {
+*   cmd.option('--out <dir>', 'Output dir', { default: 'dist' })
+*   cmd.option('--prod', 'Production mode')
+*   cmd.action(async (options, ctx) => {
+*     const spin = ctx.spinner('Building...')
+*     spin.start()
+*     // ...
+*     spin.succeed('Built!')
+*   })
+* })
+*
+* cli.parse()
+* ```
+*/
+function createCLI(name, version) {
+	const cli = cac(name);
+	if (version) cli.version(version);
+	cli.help();
+	function createContext() {
+		return {
+			color,
+			spinner(text) {
+				return createSpinner(text);
+			},
+			progress(options) {
+				return createProgress(options);
+			}
+		};
+	}
+	const builder = {
+		description(text) {
+			cli.usage(text);
+			return builder;
+		},
+		command(rawName, description, setup) {
+			const positionalNames = parsePositionalNames(rawName);
+			const rawCmd = cli.command(rawName, description);
+			const cmdBuilder = {
+				option(name, desc, config) {
+					rawCmd.option(name, desc ?? "", config);
+					return cmdBuilder;
+				},
+				alias(name) {
+					rawCmd.alias(name);
+					return cmdBuilder;
+				},
+				action(handler) {
+					rawCmd.action((...args) => {
+						const options = args[args.length - 1];
+						for (let i = 0; i < positionalNames.length; i++) options[positionalNames[i]] = args[i];
+						return handler(options, createContext());
+					});
+				}
+			};
+			setup(cmdBuilder);
+			return builder;
+		},
+		parse(argv) {
+			try {
+				if (argv) cli.parse(argv);
+				else cli.parse(process.argv);
+			} catch (err) {
+				if (err instanceof Error && err.name === "CACError") throw new CliToolkitError(err.message);
+				throw err;
+			}
+		}
+	};
+	return builder;
+}
+//#endregion
+export { CliToolkitError, ICON_ERROR, ICON_INFO, ICON_SUCCESS, ICON_WARN, color, createCLI, createProgress, createSpinner };

package/package.json

@@ -0,0 +1,54 @@
+{
+  "name": "@zfadhli/koko-cli",
+  "type": "module",
+  "version": "0.1.0",
+  "description": "Composition-based CLI toolkit — wraps cac, picocolors, cli-progress, cli-spinners",
+  "license": "MIT",
+  "author": "Koko contributors",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/zfadhli/koko-cli.git"
+  },
+  "bugs": {
+    "url": "https://github.com/zfadhli/koko-cli/issues"
+  },
+  "homepage": "https://github.com/zfadhli/koko-cli#readme",
+  "engines": {
+    "node": ">=18"
+  },
+  "exports": {
+    ".": "./dist/index.mjs",
+    "./package.json": "./package.json"
+  },
+  "main": "./dist/index.mjs",
+  "types": "./dist/index.d.mts",
+  "files": [
+    "dist"
+  ],
+  "scripts": {
+    "build": "tsdown",
+    "test": "bun test",
+    "lint": "biome check src tests",
+    "format": "biome format --write src tests",
+    "typecheck": "tsc --noEmit",
+    "example:color": "bun run examples/01-color.ts",
+    "example:spinner": "bun run examples/02-spinner.ts",
+    "example:progress": "bun run examples/03-progress.ts",
+    "example:cli": "bun run examples/04-cli-app.ts",
+    "example:composition": "bun run examples/05-composition.ts",
+    "examples": "bun run examples/01-color.ts && bun run examples/02-spinner.ts && bun run examples/03-progress.ts && bun run examples/04-cli-app.ts --help && bun run examples/05-composition.ts"
+  },
+  "dependencies": {
+    "cac": "^7.0.0",
+    "cli-progress": "^3.12.0",
+    "cli-spinners": "^3.4.0",
+    "picocolors": "^1.1.1"
+  },
+  "devDependencies": {
+    "@biomejs/biome": "^2.4.16",
+    "@types/bun": "^1.3.14",
+    "@types/cli-progress": "^3.11.0",
+    "tsdown": "^0.22.2",
+    "typescript": "^6.0.3"
+  }
+}