@forwardimpact/libutil 0.1.70 → 0.1.73

package/bin/fit-download-bundle.js

@@ -1,19 +1,41 @@
 #!/usr/bin/env node
 
+import { readFileSync } from "node:fs";
 import { spawn } from "node:child_process";
+import { createCli } from "@forwardimpact/libcli";
 import { createScriptConfig } from "@forwardimpact/libconfig";
 import { createStorage } from "@forwardimpact/libstorage";
 import { createLogger } from "@forwardimpact/libtelemetry";
 import { createBundleDownloader, execLine } from "@forwardimpact/libutil";
 
+const { version: VERSION } = JSON.parse(
+  readFileSync(new URL("../package.json", import.meta.url), "utf8"),
+);
+
+const definition = {
+  name: "fit-download-bundle",
+  version: VERSION,
+  description: "Download generated code bundle from remote storage",
+  options: {
+    help: { type: "boolean", short: "h", description: "Show this help" },
+    version: { type: "boolean", description: "Show version" },
+    json: { type: "boolean", description: "Output help as JSON" },
+  },
+};
+
+const cli = createCli(definition);
+const logger = createLogger("generated");
+
 /**
  * Downloads generated code bundle from remote storage.
  * Used in containerized deployments to fetch pre-generated code.
  * @returns {Promise<void>}
  */
 async function main() {
+  const parsed = cli.parse(process.argv.slice(2));
+  if (!parsed) process.exit(0);
+
   await createScriptConfig("download-bundle");
-  const logger = createLogger("generated");
   const downloader = createBundleDownloader(createStorage, logger);
   await downloader.download();
 
@@ -22,6 +44,7 @@ async function main() {
 }
 
 main().catch((error) => {
-  console.error("Bundle download failed:", error);
+  logger.exception("main", error);
+  cli.error(error.message);
   process.exit(1);
 });

package/bin/fit-tiktoken.js

@@ -1,14 +1,38 @@
 #!/usr/bin/env node
+import { readFileSync } from "node:fs";
+import { createCli } from "@forwardimpact/libcli";
+import { createLogger } from "@forwardimpact/libtelemetry";
 import { countTokens } from "@forwardimpact/libutil";
 
+const { version: VERSION } = JSON.parse(
+  readFileSync(new URL("../package.json", import.meta.url), "utf8"),
+);
+
+const definition = {
+  name: "fit-tiktoken",
+  version: VERSION,
+  description: "Count tokens in text",
+  usage: "fit-tiktoken <text>\n       echo 'text' | fit-tiktoken",
+  options: {
+    help: { type: "boolean", short: "h", description: "Show this help" },
+    version: { type: "boolean", description: "Show version" },
+    json: { type: "boolean", description: "Output help as JSON" },
+  },
+  examples: ['fit-tiktoken "hello world"', "echo 'hello world' | fit-tiktoken"],
+};
+
+const cli = createCli(definition);
+const logger = createLogger("tiktoken");
+
 /**
  * Counts tokens in the provided text
- * Usage: fit-tiktoken <text>
- *        echo "text" | fit-tiktoken
  * @returns {Promise<void>}
  */
 async function main() {
-  let text = process.argv.slice(2).join(" ");
+  const parsed = cli.parse(process.argv.slice(2));
+  if (!parsed) process.exit(0);
+
+  let text = parsed.positionals.join(" ");
 
   if (!text && !process.stdin.isTTY) {
     const chunks = [];
@@ -19,15 +43,15 @@ async function main() {
   }
 
   if (!text) {
-    console.error("Usage: fit-tiktoken <text>");
-    console.error('       echo "text" | fit-tiktoken');
-    process.exit(1);
+    cli.usageError("expected text argument or stdin input");
+    process.exit(2);
   }
 
   console.log(countTokens(text));
 }
 
 main().catch((error) => {
-  console.error(error.message);
+  logger.exception("main", error);
+  cli.error(error.message);
   process.exit(1);
 });

package/package.json

@@ -1,15 +1,25 @@
 {
   "name": "@forwardimpact/libutil",
-  "version": "0.1.70",
+  "version": "0.1.73",
   "description": "Utility functions and utilities for Guide",
   "license": "Apache-2.0",
   "author": "D. Olsson <hi@senzilla.io>",
   "type": "module",
-  "main": "index.js",
+  "main": "./src/index.js",
+  "exports": {
+    ".": "./src/index.js",
+    "./bin/fit-download-bundle.js": "./bin/fit-download-bundle.js",
+    "./bin/fit-tiktoken.js": "./bin/fit-tiktoken.js"
+  },
   "bin": {
     "fit-download-bundle": "./bin/fit-download-bundle.js",
     "fit-tiktoken": "./bin/fit-tiktoken.js"
   },
+  "files": [
+    "src/**/*.js",
+    "bin/**/*.js",
+    "README.md"
+  ],
   "engines": {
     "bun": ">=1.2.0",
     "node": ">=18.0.0"
@@ -18,6 +28,7 @@
     "test": "bun run node --test test/*.test.js"
   },
   "dependencies": {
+    "@forwardimpact/libcli": "^0.1.0",
     "@forwardimpact/libtelemetry": "^0.1.22"
   },
   "devDependencies": {

package/{finder.js → src/finder.js}

@@ -114,7 +114,7 @@ export class Finder {
    */
   findGeneratedPath(projectRoot, packageName) {
     const packagePath = this.findPackagePath(projectRoot, packageName);
-    return path.join(packagePath, "generated");
+    return path.join(packagePath, "src", "generated");
   }
 
   /**
@@ -139,6 +139,9 @@ export class Finder {
       // Target doesn't exist, which is fine
     }
 
+    // Ensure the target's parent directory exists before symlinking
+    await fsAsync.mkdir(path.dirname(targetPath), { recursive: true });
+
     // Create the symlink
     await fsAsync.symlink(sourcePath, targetPath, "dir");
     this.#logger.debug("Finder", "Created symlink", {

package/test/downloader.test.js

@@ -1,223 +0,0 @@
-import { strict as assert } from "node:assert";
-import { test, describe, beforeEach, mock } from "node:test";
-
-import { createSilentLogger } from "@forwardimpact/libharness";
-
-import { BundleDownloader } from "../downloader.js";
-
-describe("BundleDownloader", () => {
-  let mockStorageFactory;
-  let mockExtractor;
-  let mockLogger;
-  let mockFinder;
-  let mockProcess;
-  let mockLocalStorage;
-  let mockRemoteStorage;
-
-  beforeEach(() => {
-    mockLocalStorage = {
-      ensureBucket: async () => {},
-      put: async () => {},
-      delete: async () => {},
-      path: (key = ".") => `/local/path/${key}`,
-    };
-
-    mockRemoteStorage = {
-      exists: async () => true,
-      get: async () => Buffer.from("bundle data"),
-    };
-
-    mockStorageFactory = (prefix, type) => {
-      return type === "local" ? mockLocalStorage : mockRemoteStorage;
-    };
-
-    mockExtractor = {
-      extract: mock.fn(async () => {}),
-    };
-    mockLogger = createSilentLogger();
-    mockFinder = {
-      createPackageSymlinks: mock.fn(async () => {}),
-    };
-    mockProcess = {
-      env: { STORAGE_TYPE: "s3" },
-    };
-  });
-
-  test("constructor validates required dependencies", () => {
-    assert.throws(
-      () =>
-        new BundleDownloader(
-          null,
-          mockFinder,
-          mockLogger,
-          mockExtractor,
-          mockProcess,
-        ),
-      /createStorageFn is required/,
-    );
-
-    assert.throws(
-      () =>
-        new BundleDownloader(
-          mockStorageFactory,
-          null,
-          mockLogger,
-          mockExtractor,
-          mockProcess,
-        ),
-      /finder is required/,
-    );
-
-    assert.throws(
-      () =>
-        new BundleDownloader(
-          mockStorageFactory,
-          mockFinder,
-          null,
-          mockExtractor,
-          mockProcess,
-        ),
-      /logger is required/,
-    );
-
-    assert.throws(
-      () =>
-        new BundleDownloader(
-          mockStorageFactory,
-          mockFinder,
-          mockLogger,
-          null,
-          mockProcess,
-        ),
-      /extractor is required/,
-    );
-
-    assert.throws(
-      () =>
-        new BundleDownloader(
-          mockStorageFactory,
-          mockFinder,
-          mockLogger,
-          mockExtractor,
-          null,
-        ),
-      /process is required/,
-    );
-  });
-
-  test("downloads and extracts bundle when it exists", async () => {
-    const operations = [];
-    mockLocalStorage.put = async (key, data) => {
-      operations.push({ op: "put", key, hasData: !!data });
-    };
-    mockLocalStorage.delete = async (key) => {
-      operations.push({ op: "delete", key });
-    };
-    mockExtractor.extract = async (sourcePath, targetPath) => {
-      operations.push({ op: "extract", sourcePath, targetPath });
-    };
-
-    const download = new BundleDownloader(
-      mockStorageFactory,
-      mockFinder,
-      mockLogger,
-      mockExtractor,
-      mockProcess,
-    );
-    await download.initialize();
-    await download.download();
-
-    assert.strictEqual(operations.length, 3);
-    assert.deepStrictEqual(operations[0], {
-      op: "put",
-      key: "bundle.tar.gz",
-      hasData: true,
-    });
-    assert.strictEqual(operations[1].op, "extract");
-    assert.strictEqual(operations[1].sourcePath, "/local/path/bundle.tar.gz");
-    assert.strictEqual(operations[1].targetPath, "/local/path/.");
-    assert.deepStrictEqual(operations[2], {
-      op: "delete",
-      key: "bundle.tar.gz",
-    });
-  });
-
-  test("throws error when bundle does not exist", async () => {
-    mockRemoteStorage.exists = async () => false;
-
-    const download = new BundleDownloader(
-      mockStorageFactory,
-      mockFinder,
-      mockLogger,
-      mockExtractor,
-      mockProcess,
-    );
-    await download.initialize();
-
-    await assert.rejects(() => download.download(), {
-      message: /Bundle not found/,
-    });
-  });
-
-  test("initializes storage instances correctly", async () => {
-    const ensureBucketCalls = [];
-    mockLocalStorage.ensureBucket = async () => {
-      ensureBucketCalls.push("generated");
-    };
-
-    const download = new BundleDownloader(
-      mockStorageFactory,
-      mockFinder,
-      mockLogger,
-      mockExtractor,
-      mockProcess,
-    );
-    await download.initialize();
-
-    assert.strictEqual(ensureBucketCalls.length, 1);
-    assert.strictEqual(ensureBucketCalls[0], "generated");
-
-    // Should have called createPackageSymlinks
-    assert.strictEqual(mockFinder.createPackageSymlinks.mock.calls.length, 1);
-    assert.strictEqual(
-      mockFinder.createPackageSymlinks.mock.calls[0].arguments[0],
-      "/local/path/.",
-    );
-  });
-
-  test("skips download when STORAGE_TYPE is local", async () => {
-    mockProcess.env.STORAGE_TYPE = "local";
-    mockRemoteStorage.exists = mock.fn(async () => true);
-
-    const download = new BundleDownloader(
-      mockStorageFactory,
-      mockFinder,
-      mockLogger,
-      mockExtractor,
-      mockProcess,
-    );
-    await download.initialize();
-    await download.download();
-
-    // Should not have called remote storage
-    assert.strictEqual(mockRemoteStorage.exists.mock.calls.length, 0);
-  });
-
-  test("downloads when STORAGE_TYPE is s3", async () => {
-    mockProcess.env.STORAGE_TYPE = "s3";
-    mockRemoteStorage.exists = mock.fn(async () => true);
-
-    const download = new BundleDownloader(
-      mockStorageFactory,
-      mockFinder,
-      mockLogger,
-      mockExtractor,
-      mockProcess,
-    );
-    await download.initialize();
-    await download.download();
-
-    // Should have called remote storage
-    assert.strictEqual(mockRemoteStorage.exists.mock.calls.length, 1);
-  });
-});