@jango-blockchained/hoox-cli 0.9.1 → 0.9.5

package/README.md

@@ -6,7 +6,7 @@
 
 > **Runtime requirement:** Bun ≥ 1.2. The bin shebang and bundle target are Bun-only; `npm install -g` will install the package but the CLI will not run under Node.js.
 
-**v0.9.1** — 411 unit tests, 25 command groups, 60+ subcommands. Modern-minimal visual refresh, completion footer, did-you-mean suggestions, custom help. **v0.9.0** had a banner version-lookup bug in global installs — fixed in 0.9.1.
+**v0.9.3** — 28 top-level command groups, 800+ unit tests. Modern-minimal visual refresh, completion footer, did-you-mean suggestions, custom help, hop-level `perf fastpath` observability. **v0.9.0** had a banner version-lookup bug in global installs — fixed in 0.9.1.
 
 ## Features
 
@@ -44,9 +44,14 @@ bun add -g @jango-blockchained/hoox-cli
 ```bash
 cd packages/cli
 bun install
-bun run build
+bun run build   # produces dist/index.js — required for `hoox` after global install
 ```
 
+> `bin/hoox.js` resolves `dist/index.js` first and falls back to `src/index.ts`
+> when `dist/` is missing, so contributors who skip the build step can still
+> run the CLI via `bun bin/hoox.js …` or a `bun link`-based install. Production
+> releases and the `prepublishOnly` script always build first.
+
 ## Quick Start
 
 ```bash

package/bin/hoox.js

@@ -2,10 +2,53 @@
 /**
  * Hoox CLI binary entry point.
  *
- * Bun's bin-symlink resolves here. Uses the pre-built dist bundle
- * (self-contained — includes hoox-shared). Run `bun run build` to regenerate.
+ * Resolution order (first match wins):
+ *   1. `../dist/index.js`  — bundled output from `bun run build`
+ *   2. `../src/index.ts`   — dev mode (run from a fresh `bun install` without
+ *                            running the build first; Bun compiles TS on import)
+ *   3. Clear error message instructing the user to run `bun run build`
+ *
+ * The dev fallback lets contributors and CI jobs that haven't yet run
+ * `bun run build` still execute the CLI directly via `bun bin/hoox.js` or
+ * `hoox` after a `bun link`.
+ *
+ * `main` is exported from `src/index.ts` so we can call it explicitly —
+ * the `import.meta.main` guard inside that file would otherwise be false
+ * when the module is loaded as a side effect from here.
  */
 
-import { main } from "../dist/index.js";
+import { existsSync } from "node:fs";
+import { fileURLToPath } from "node:url";
+import { dirname, resolve } from "node:path";
+
+const here = dirname(fileURLToPath(import.meta.url));
+const distEntry = resolve(here, "..", "dist", "index.js");
+const srcEntry = resolve(here, "..", "src", "index.ts");
+
+async function loadAndRun(entry) {
+  // Bun caches imports; the first import wins for the lifetime of the
+  // process. The dist build and the source file are the same module
+  // logically, so a second entry would be a no-op.
+  const mod = await import(entry);
+  if (typeof mod.main === "function") {
+    await mod.main();
+  }
+}
 
-await main();
+if (existsSync(distEntry)) {
+  // Production path — bundled and self-contained.
+  await loadAndRun(distEntry);
+} else if (existsSync(srcEntry)) {
+  // Dev path — Bun transpiles on the fly. Useful for `bun link` and CI
+  // smoke tests that run before the build step.
+  await loadAndRun(srcEntry);
+} else {
+  console.error(
+    `hoox: could not find an entry point. Looked for:\n` +
+      `  - ${distEntry}\n` +
+      `  - ${srcEntry}\n\n` +
+      `Run \`bun run build\` in packages/cli/ to produce the bundled dist/, ` +
+      `or install from source so src/index.ts is present.`
+  );
+  process.exit(1);
+}