@forwardimpact/libcli 0.1.12 → 0.1.13

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@forwardimpact/libcli",
-  "version": "0.1.12",
+  "version": "0.1.13",
   "description": "Agent-friendly CLIs — self-documenting entry points that humans and agents reach through the same interface.",
   "keywords": [
     "cli",

package/src/cli.js

@@ -1,6 +1,7 @@
 import { parseArgs } from "node:util";
 import { HelpRenderer } from "./help.js";
 import { freezeInvocationContext } from "./invocation-context.js";
+import { resolveVersion } from "./version.js";
 
 /** Command-line interface that parses argv against a definition of commands, options, and help. */
 export class Cli {
@@ -180,17 +181,25 @@ export class Cli {
 }
 
 /**
- * Create a Cli instance. When `runtime` is provided, error,
- * usage-error, and help output route through `runtime.proc` instead of the
- * global `process`. The zero-arg form keeps reading the global `process` as a
- * deprecated alias for one migration cycle.
+ * Create a Cli instance. Error, usage-error, and help output route through the
+ * injected `runtime.proc`.
  * @param {object} definition - The CLI definition.
- * @param {object} [options]
- * @param {import('@forwardimpact/libutil/runtime').Runtime} [options.runtime]
+ * @param {object} options
+ * @param {import('@forwardimpact/libutil/runtime').Runtime} options.runtime
+ * @param {URL|string} [options.packageJsonUrl] - When provided and the definition
+ *   carries no explicit `version`, resolve it via {@link resolveVersion} so every
+ *   bin shares one compile-time version literal. Explicit `definition.version` wins.
  * @returns {Cli}
  */
-export function createCli(definition, { runtime } = {}) {
-  const proc = runtime ? runtime.proc : process;
+export function createCli(definition, { runtime, packageJsonUrl } = {}) {
+  if (!runtime) throw new Error("runtime is required");
+  if (definition.version === undefined && packageJsonUrl !== undefined) {
+    definition = {
+      ...definition,
+      version: resolveVersion({ packageJsonUrl, runtime }),
+    };
+  }
+  const proc = runtime.proc;
   const helpRenderer = new HelpRenderer({ process: proc });
   return new Cli(definition, { process: proc, helpRenderer });
 }

package/src/index.js

@@ -1,4 +1,5 @@
 export { Cli, createCli } from "./cli.js";
+export { resolveVersion } from "./version.js";
 export { freezeInvocationContext } from "./invocation-context.js";
 export { HelpRenderer } from "./help.js";
 export { SummaryRenderer } from "./summary.js";

package/src/version.js

@@ -0,0 +1,23 @@
+/**
+ * Resolve a CLI's version string. In a `bun build --compile` binary,
+ * `process.env.LIBCLI_VERSION` is replaced at build time by `just build-binary`'s
+ * `--define`, so this returns the injected literal and the package.json read below
+ * is dead code (it never executes — and tree-shakes). In source/npx execution the
+ * env var is normally unset and the read supplies the version; setting LIBCLI_VERSION
+ * in the environment overrides it (used by bin-smoke integration tests).
+ *
+ * The read must be written as the literal member expression `process.env.LIBCLI_VERSION`
+ * — that is the token `bun build --define` substitutes across the whole bundle,
+ * including this bundled library. A dynamic `process.env[name]` would not be replaced.
+ *
+ * @param {object} args
+ * @param {URL|string} args.packageJsonUrl - `new URL("../package.json", import.meta.url)`
+ * @param {import('@forwardimpact/libutil/runtime').Runtime} args.runtime
+ * @returns {string}
+ */
+export function resolveVersion({ packageJsonUrl, runtime }) {
+  const injected = process.env.LIBCLI_VERSION; // literal — the --define target
+  if (injected) return injected;
+  const text = runtime.fsSync.readFileSync(packageJsonUrl, "utf8");
+  return JSON.parse(text).version;
+}