@forwardimpact/libcli 0.1.0 → 0.1.1

package/package.json

@@ -1,11 +1,18 @@
 {
   "name": "@forwardimpact/libcli",
-  "version": "0.1.0",
+  "version": "0.1.1",
   "description": "Shared CLI infrastructure for the Forward Impact monorepo",
   "license": "Apache-2.0",
   "author": "D. Olsson <hi@senzilla.io>",
   "type": "module",
-  "main": "index.js",
+  "main": "./src/index.js",
+  "exports": {
+    ".": "./src/index.js"
+  },
+  "files": [
+    "src/**/*.js",
+    "README.md"
+  ],
   "engines": {
     "bun": ">=1.2.0",
     "node": ">=18.0.0"

package/test/cli.test.js

@@ -1,138 +0,0 @@
-import { test, describe } from "node:test";
-import assert from "node:assert";
-
-import { Cli } from "../cli.js";
-import { HelpRenderer } from "../help.js";
-
-function createProc() {
-  return {
-    env: {},
-    stdout: {
-      isTTY: false,
-      output: "",
-      write(data) {
-        this.output += data;
-      },
-    },
-    stderr: {
-      output: "",
-      write(data) {
-        this.output += data;
-      },
-    },
-    exitCode: 0,
-  };
-}
-
-const definition = {
-  name: "fit-test",
-  version: "1.0.0",
-  description: "Test CLI",
-  options: {
-    output: { type: "string", description: "Output path" },
-    json: { type: "boolean", description: "JSON output" },
-    help: { type: "boolean", short: "h", description: "Show help" },
-    version: { type: "boolean", description: "Show version" },
-  },
-};
-
-function createCli(proc) {
-  const helpRenderer = new HelpRenderer({ process: proc });
-  return new Cli(definition, { process: proc, helpRenderer });
-}
-
-describe("Cli", () => {
-  describe("parse", () => {
-    test("returns values and positionals for normal input", () => {
-      const proc = createProc();
-      const cli = createCli(proc);
-      const result = cli.parse(["run", "--output=out.txt"]);
-      assert.deepStrictEqual(result.positionals, ["run"]);
-      assert.strictEqual(result.values.output, "out.txt");
-    });
-
-    test("returns null and writes help when --help is passed", () => {
-      const proc = createProc();
-      const cli = createCli(proc);
-      const result = cli.parse(["--help"]);
-      assert.strictEqual(result, null);
-      assert.ok(proc.stdout.output.includes("fit-test"));
-      assert.ok(proc.stdout.output.includes("Test CLI"));
-    });
-
-    test("returns null and writes JSON when --help --json is passed", () => {
-      const proc = createProc();
-      const cli = createCli(proc);
-      const result = cli.parse(["--help", "--json"]);
-      assert.strictEqual(result, null);
-      const parsed = JSON.parse(proc.stdout.output);
-      assert.strictEqual(parsed.name, "fit-test");
-    });
-
-    test("returns null and writes version when --version is passed", () => {
-      const proc = createProc();
-      const cli = createCli(proc);
-      const result = cli.parse(["--version"]);
-      assert.strictEqual(result, null);
-      assert.strictEqual(proc.stdout.output.trim(), "1.0.0");
-    });
-
-    test("throws on unknown flags", () => {
-      const proc = createProc();
-      const cli = createCli(proc);
-      assert.throws(() => cli.parse(["--unknown"]), {
-        code: "ERR_PARSE_ARGS_UNKNOWN_OPTION",
-      });
-    });
-  });
-
-  describe("showHelp", () => {
-    test("writes help to stdout without re-parsing", () => {
-      const proc = createProc();
-      const cli = createCli(proc);
-      cli.showHelp();
-      assert.ok(proc.stdout.output.includes("fit-test"));
-      assert.ok(proc.stdout.output.includes("Test CLI"));
-    });
-  });
-
-  describe("parse with multiple option", () => {
-    test("collects repeated flags into an array", () => {
-      const proc = createProc();
-      const multiDef = {
-        name: "fit-multi",
-        options: {
-          tag: { type: "string", multiple: true, description: "Tags" },
-          help: { type: "boolean", short: "h", description: "Show help" },
-        },
-      };
-      const helpRenderer = new HelpRenderer({ process: proc });
-      const cli = new Cli(multiDef, { process: proc, helpRenderer });
-      const result = cli.parse(["--tag=a", "--tag=b"]);
-      assert.deepStrictEqual(result.values.tag, ["a", "b"]);
-    });
-  });
-
-  describe("error", () => {
-    test("writes prefixed message to stderr and sets exitCode to 1", () => {
-      const proc = createProc();
-      const cli = createCli(proc);
-      cli.error("something broke");
-      assert.strictEqual(
-        proc.stderr.output,
-        "fit-test: error: something broke\n",
-      );
-      assert.strictEqual(proc.exitCode, 1);
-    });
-  });
-
-  describe("usageError", () => {
-    test("writes prefixed message to stderr and sets exitCode to 2", () => {
-      const proc = createProc();
-      const cli = createCli(proc);
-      cli.usageError("bad argument");
-      assert.strictEqual(proc.stderr.output, "fit-test: error: bad argument\n");
-      assert.strictEqual(proc.exitCode, 2);
-    });
-  });
-});

package/test/color.test.js

@@ -1,45 +0,0 @@
-import { test, describe } from "node:test";
-import assert from "node:assert";
-
-import { colors, supportsColor, colorize } from "../color.js";
-
-describe("supportsColor", () => {
-  test("returns false when NO_COLOR is set", () => {
-    const proc = { env: { NO_COLOR: "1" }, stdout: { isTTY: true } };
-    assert.strictEqual(supportsColor(proc), false);
-  });
-
-  test("returns true when FORCE_COLOR is set", () => {
-    const proc = { env: { FORCE_COLOR: "1" }, stdout: { isTTY: false } };
-    assert.strictEqual(supportsColor(proc), true);
-  });
-
-  test("returns true when stdout is a TTY", () => {
-    const proc = { env: {}, stdout: { isTTY: true } };
-    assert.strictEqual(supportsColor(proc), true);
-  });
-
-  test("returns false when stdout is not a TTY", () => {
-    const proc = { env: {}, stdout: { isTTY: false } };
-    assert.strictEqual(supportsColor(proc), false);
-  });
-
-  test("returns false when stdout is undefined", () => {
-    const proc = { env: {} };
-    assert.strictEqual(supportsColor(proc), false);
-  });
-});
-
-describe("colorize", () => {
-  test("wraps text with ANSI codes when color is supported", () => {
-    const proc = { env: { FORCE_COLOR: "1" }, stdout: { isTTY: true } };
-    const result = colorize("hello", colors.red, proc);
-    assert.strictEqual(result, `${colors.red}hello${colors.reset}`);
-  });
-
-  test("returns plain text when color is not supported", () => {
-    const proc = { env: {}, stdout: { isTTY: false } };
-    const result = colorize("hello", colors.red, proc);
-    assert.strictEqual(result, "hello");
-  });
-});

package/test/format.test.js

@@ -1,90 +0,0 @@
-import { test, describe } from "node:test";
-import assert from "node:assert";
-
-import {
-  formatTable,
-  formatHeader,
-  formatError,
-  indent,
-  horizontalRule,
-} from "../format.js";
-import { colors } from "../color.js";
-
-const noColor = { env: {}, stdout: { isTTY: false } };
-const withColor = { env: { FORCE_COLOR: "1" }, stdout: { isTTY: true } };
-
-describe("formatTable", () => {
-  test("aligns columns correctly", () => {
-    const result = formatTable(
-      ["Name", "Value"],
-      [
-        ["short", "1"],
-        ["longer name", "2"],
-      ],
-      {},
-      noColor,
-    );
-    const lines = result.split("\n");
-    assert.strictEqual(lines.length, 4); // header, separator, 2 rows
-    assert.ok(lines[0].startsWith("Name"));
-    assert.ok(lines[2].startsWith("short"));
-    assert.ok(lines[3].startsWith("longer name"));
-  });
-
-  test("compact option omits separator", () => {
-    const result = formatTable(
-      ["A", "B"],
-      [["1", "2"]],
-      { compact: true },
-      noColor,
-    );
-    const lines = result.split("\n");
-    assert.strictEqual(lines.length, 2); // header + 1 row, no separator
-  });
-});
-
-describe("formatHeader", () => {
-  test("returns bold+cyan text when color supported", () => {
-    const result = formatHeader("Title", withColor);
-    assert.ok(result.includes(colors.bold));
-    assert.ok(result.includes(colors.cyan));
-    assert.ok(result.includes("Title"));
-  });
-
-  test("returns plain text when color not supported", () => {
-    const result = formatHeader("Title", noColor);
-    assert.strictEqual(result, "Title");
-  });
-});
-
-describe("formatError", () => {
-  test("returns red Error text when color supported", () => {
-    const result = formatError("bad thing", withColor);
-    assert.ok(result.includes(colors.red));
-    assert.ok(result.includes("Error: bad thing"));
-  });
-
-  test("returns plain text when color not supported", () => {
-    const result = formatError("bad thing", noColor);
-    assert.strictEqual(result, "Error: bad thing");
-  });
-});
-
-describe("indent", () => {
-  test("adds correct padding to all lines", () => {
-    const result = indent("line1\nline2", 4);
-    assert.strictEqual(result, "    line1\n    line2");
-  });
-
-  test("defaults to 2 spaces", () => {
-    const result = indent("a\nb");
-    assert.strictEqual(result, "  a\n  b");
-  });
-});
-
-describe("horizontalRule", () => {
-  test("returns correct-width dashed line", () => {
-    const result = horizontalRule(10, noColor);
-    assert.strictEqual(result, "\u2500".repeat(10));
-  });
-});

package/test/help.test.js

@@ -1,98 +0,0 @@
-import { test, describe } from "node:test";
-import assert from "node:assert";
-
-import { HelpRenderer } from "../help.js";
-
-function createStream() {
-  return {
-    output: "",
-    write(data) {
-      this.output += data;
-    },
-  };
-}
-
-const proc = { env: {}, stdout: { isTTY: false, write() {} } };
-
-function createRenderer() {
-  return new HelpRenderer({ process: proc });
-}
-
-const fullDefinition = {
-  name: "fit-test",
-  version: "1.0.0",
-  description: "A test CLI",
-  commands: [
-    { name: "run", args: "<file>", description: "Run a file" },
-    { name: "check", description: "Check syntax" },
-  ],
-  options: {
-    output: { type: "string", description: "Output path" },
-    verbose: { type: "boolean", short: "v", description: "Verbose output" },
-    help: { type: "boolean", short: "h", description: "Show this help" },
-  },
-  examples: ["fit-test run main.js", "fit-test check --verbose"],
-};
-
-describe("HelpRenderer", () => {
-  describe("render", () => {
-    test("includes header line with name, version, description", () => {
-      const stream = createStream();
-      createRenderer().render(fullDefinition, stream);
-      assert.ok(stream.output.includes("fit-test 1.0.0"));
-      assert.ok(stream.output.includes("A test CLI"));
-    });
-
-    test("includes one-line-per-command with aligned descriptions", () => {
-      const stream = createStream();
-      createRenderer().render(fullDefinition, stream);
-      assert.ok(stream.output.includes("run <file>"));
-      assert.ok(stream.output.includes("Run a file"));
-      assert.ok(stream.output.includes("check"));
-      assert.ok(stream.output.includes("Check syntax"));
-    });
-
-    test("includes options with type hints and descriptions", () => {
-      const stream = createStream();
-      createRenderer().render(fullDefinition, stream);
-      assert.ok(stream.output.includes("--output=<string>"));
-      assert.ok(stream.output.includes("--verbose, -v"));
-      assert.ok(stream.output.includes("--help, -h"));
-    });
-
-    test("includes examples section", () => {
-      const stream = createStream();
-      createRenderer().render(fullDefinition, stream);
-      assert.ok(stream.output.includes("fit-test run main.js"));
-      assert.ok(stream.output.includes("fit-test check --verbose"));
-    });
-
-    test("omits commands section when definition has no commands", () => {
-      const stream = createStream();
-      const def = {
-        name: "fit-simple",
-        options: { help: { type: "boolean", description: "Help" } },
-      };
-      createRenderer().render(def, stream);
-      assert.ok(!stream.output.includes("Commands:"));
-    });
-
-    test("uses custom usage string when provided", () => {
-      const stream = createStream();
-      const def = { name: "fit-query", usage: "fit-query <s> <p> <o>" };
-      createRenderer().render(def, stream);
-      assert.ok(stream.output.includes("Usage: fit-query <s> <p> <o>"));
-    });
-  });
-
-  describe("renderJson", () => {
-    test("produces valid JSON matching the definition", () => {
-      const stream = createStream();
-      createRenderer().renderJson(fullDefinition, stream);
-      const parsed = JSON.parse(stream.output);
-      assert.strictEqual(parsed.name, "fit-test");
-      assert.strictEqual(parsed.commands.length, 2);
-      assert.strictEqual(parsed.commands[0].name, "run");
-    });
-  });
-});

package/test/summary.test.js

@@ -1,65 +0,0 @@
-import { test, describe } from "node:test";
-import assert from "node:assert";
-
-import { SummaryRenderer } from "../summary.js";
-
-function createStream() {
-  return {
-    output: "",
-    write(data) {
-      this.output += data;
-    },
-  };
-}
-
-const proc = { stdout: { write() {} } };
-
-describe("SummaryRenderer", () => {
-  test("writes title and aligned items", () => {
-    const stream = createStream();
-    const renderer = new SummaryRenderer({ process: proc });
-    renderer.render(
-      {
-        title: "Generated 38 files",
-        items: [
-          { label: "definitions/", description: "Service definitions" },
-          { label: "proto/", description: "Proto source files" },
-        ],
-      },
-      stream,
-    );
-    assert.ok(stream.output.includes("Generated 38 files\n"));
-    assert.ok(stream.output.includes("definitions/"));
-    assert.ok(stream.output.includes("proto/"));
-    // Labels should be aligned
-    const lines = stream.output.split("\n").filter((l) => l.startsWith("  "));
-    const firstDash = lines[0].indexOf("\u2014");
-    const secondDash = lines[1].indexOf("\u2014");
-    assert.strictEqual(firstDash, secondDash);
-  });
-
-  test("writes only title when items is empty", () => {
-    const stream = createStream();
-    const renderer = new SummaryRenderer({ process: proc });
-    renderer.render({ title: "Done", items: [] }, stream);
-    assert.strictEqual(stream.output, "Done\n");
-  });
-
-  test("right-pads labels to the longest label width", () => {
-    const stream = createStream();
-    const renderer = new SummaryRenderer({ process: proc });
-    renderer.render(
-      {
-        title: "Title",
-        items: [
-          { label: "ab", description: "short" },
-          { label: "abcdef", description: "long" },
-        ],
-      },
-      stream,
-    );
-    const lines = stream.output.split("\n").filter((l) => l.startsWith("  "));
-    // "ab" should be padded to 6 chars to match "abcdef"
-    assert.ok(lines[0].includes("ab    "));
-  });
-});