@forwardimpact/libutil 0.1.61 → 0.1.63

package/bin/fit-download-bundle.js

@@ -1,7 +1,9 @@
 #!/usr/bin/env node
 
+import { spawn } from "node:child_process";
 import { createScriptConfig } from "@forwardimpact/libconfig";
 import { createStorage } from "@forwardimpact/libstorage";
+import { createLogger } from "@forwardimpact/libtelemetry";
 import { createBundleDownloader, execLine } from "@forwardimpact/libutil";
 
 /**
@@ -11,11 +13,12 @@ import { createBundleDownloader, execLine } from "@forwardimpact/libutil";
  */
 async function main() {
   await createScriptConfig("download-bundle");
-  const downloader = await createBundleDownloader(createStorage);
+  const logger = createLogger("generated");
+  const downloader = createBundleDownloader(createStorage, logger);
   await downloader.download();
 
   // If additional arguments provided, execute them after download
-  execLine();
+  execLine(0, { spawn, process });
 }
 
 main().catch((error) => {

package/bin/fit-tiktoken.js

@@ -0,0 +1,33 @@
+#!/usr/bin/env node
+import { countTokens } from "@forwardimpact/libutil";
+
+/**
+ * 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(" ");
+
+  if (!text && !process.stdin.isTTY) {
+    const chunks = [];
+    for await (const chunk of process.stdin) {
+      chunks.push(chunk);
+    }
+    text = Buffer.concat(chunks).toString().trim();
+  }
+
+  if (!text) {
+    console.error("Usage: fit-tiktoken <text>");
+    console.error('       echo "text" | fit-tiktoken');
+    process.exit(1);
+  }
+
+  console.log(countTokens(text));
+}
+
+main().catch((error) => {
+  console.error(error.message);
+  process.exit(1);
+});

package/index.js

@@ -1,7 +1,6 @@
 import crypto from "crypto";
 import fs from "fs/promises";
 import path from "path";
-import { spawn } from "child_process";
 
 import { Tokenizer, ranks } from "./tokenizer.js";
 import { Finder } from "./finder.js";
@@ -10,16 +9,22 @@ import { TarExtractor } from "./extractor.js";
 
 /**
  * Updates or creates an environment variable in .env file
+ * @param {string} filePath - Path to .env file
  * @param {string} key - Environment variable name (e.g., "SERVICE_SECRET")
  * @param {string} value - Environment variable value
- * @param {string} [envPath] - Path to .env file (defaults to .env in current directory)
+ * @param {object} fsFns - File system functions
+ * @param {Function} fsFns.readFile - Async file read function
+ * @param {Function} fsFns.writeFile - Async file write function
  */
-export async function updateEnvFile(key, value, envPath = ".env") {
-  const fullPath = path.resolve(envPath);
+export async function updateEnvFile(filePath, key, value, fsFns) {
+  if (!fsFns?.readFile) throw new Error("fsFns.readFile is required");
+  if (!fsFns?.writeFile) throw new Error("fsFns.writeFile is required");
+
+  const fullPath = path.resolve(filePath);
   let content = "";
 
   try {
-    content = await fs.readFile(fullPath, "utf8");
+    content = await fsFns.readFile(fullPath, "utf8");
   } catch (error) {
     // It's ok if the file doesn't exist
     if (error.code !== "ENOENT") throw error;
@@ -47,7 +52,7 @@ export async function updateEnvFile(key, value, envPath = ".env") {
   }
 
   // Write back to file
-  await fs.writeFile(fullPath, lines.join("\n"));
+  await fsFns.writeFile(fullPath, lines.join("\n"));
 }
 
 /**
@@ -95,14 +100,13 @@ export function createTokenizer() {
  * Creates a BundleDownloader instance configured for generated code management.
  * Used in containerized deployments to download pre-generated code bundles.
  * @param {Function} createStorage - Storage factory function from libstorage
- * @returns {Promise<BundleDownloader>} Configured BundleDownloader instance
+ * @param {object} logger - Logger instance
+ * @returns {BundleDownloader} Configured BundleDownloader instance
  */
-export async function createBundleDownloader(createStorage) {
+export function createBundleDownloader(createStorage, logger) {
   if (!createStorage) throw new Error("createStorage is required");
+  if (!logger) throw new Error("logger is required");
 
-  // Dynamic import to avoid circular dependency with libtelemetry
-  const { createLogger } = await import("@forwardimpact/libtelemetry");
-  const logger = createLogger("generated");
   const finder = new Finder(fs, logger);
   const extractor = new TarExtractor(fs, path);
 
@@ -111,11 +115,18 @@ export async function createBundleDownloader(createStorage) {
 
 /**
  * Executes command line arguments as child process, similar to execv() in C
- * @param {number} [shift] - Number of arguments to skip from process.argv before extracting command
+ * @param {number} shift - Number of arguments to skip from process.argv before extracting command
+ * @param {object} deps - Required dependencies
+ * @param {Function} deps.spawn - Child process spawn function
+ * @param {object} deps.process - Process object (argv, env, on, exit)
  * @returns {void} Function does not return - exits parent process
  */
-export function execLine(shift = 0) {
-  const args = process.argv.slice(2 + shift);
+export function execLine(shift, deps) {
+  if (!deps?.spawn) throw new Error("deps.spawn is required");
+  if (!deps?.process) throw new Error("deps.process is required");
+
+  const { spawn: spawnFn, process: proc } = deps;
+  const args = proc.argv.slice(2 + (shift || 0));
   if (args.length === 0) return;
 
   // Look for '--' delimiter and use everything after it as the command
@@ -125,23 +136,23 @@ export function execLine(shift = 0) {
   if (line.length === 0) return;
 
   const [command, ...commandArgs] = line;
-  const child = spawn(command, commandArgs, {
+  const child = spawnFn(command, commandArgs, {
     stdio: "inherit",
-    env: process.env,
+    env: proc.env,
   });
 
   // Forward signals to child process
   ["SIGTERM", "SIGINT", "SIGQUIT"].forEach((signal) => {
-    process.on(signal, () => child.kill(signal));
+    proc.on(signal, () => child.kill(signal));
   });
 
   child.on("error", (error) => {
     console.error("Error:", error);
-    process.exit(1);
+    proc.exit(1);
   });
 
   child.on("exit", (code, signal) => {
-    process.exit(signal ? 1 : code || 0);
+    proc.exit(signal ? 1 : code || 0);
   });
 }
 

package/package.json

@@ -1,13 +1,14 @@
 {
   "name": "@forwardimpact/libutil",
-  "version": "0.1.61",
+  "version": "0.1.63",
   "description": "Utility functions and utilities for Guide",
   "license": "Apache-2.0",
   "author": "D. Olsson <hi@senzilla.io>",
   "type": "module",
   "main": "index.js",
   "bin": {
-    "fit-download-bundle": "./bin/fit-download-bundle.js"
+    "fit-download-bundle": "./bin/fit-download-bundle.js",
+    "fit-tiktoken": "./bin/fit-tiktoken.js"
   },
   "engines": {
     "node": ">=22.0.0"

package/test/libutil.test.js

@@ -4,35 +4,32 @@ import assert from "node:assert";
 // Module under test
 import { createBundleDownloader } from "../index.js";
 
+const noop = () => {};
+const mockLogger = { info: noop, debug: noop, warn: noop, error: noop };
+
 describe("libutil", () => {
   describe("createBundleDownloader", () => {
-    test("creates BundleDownloader instance with correct dependencies", async () => {
+    test("creates BundleDownloader instance with correct dependencies", () => {
       const mockStorageFactory = mock.fn();
-      const mockProcess = { env: { STORAGE_TYPE: "local" } };
 
-      const downloader = await createBundleDownloader(
-        mockStorageFactory,
-        mockProcess,
-      );
+      const downloader = createBundleDownloader(mockStorageFactory, mockLogger);
 
       assert.ok(downloader);
-      // Check that it's a BundleDownloader instance by checking if it has the expected methods
       assert.ok(typeof downloader.initialize === "function");
       assert.ok(typeof downloader.download === "function");
     });
 
-    test("validates storageFactory parameter", async () => {
-      await assert.rejects(() => createBundleDownloader(null), {
+    test("validates storageFactory parameter", () => {
+      assert.throws(() => createBundleDownloader(null, mockLogger), {
         message: /createStorage is required/,
       });
     });
 
-    test("uses global process when not provided", async () => {
+    test("validates logger parameter", () => {
       const mockStorageFactory = mock.fn();
-
-      const downloader = await createBundleDownloader(mockStorageFactory);
-
-      assert.ok(downloader);
+      assert.throws(() => createBundleDownloader(mockStorageFactory, null), {
+        message: /logger is required/,
+      });
     });
   });
 });

package/test/wait.test.js

@@ -3,13 +3,26 @@ import assert from "node:assert";
 
 import { waitFor } from "../wait.js";
 
+const delay = (ms) => new Promise((resolve) => setTimeout(resolve, ms));
+
 describe("waitFor", () => {
+  test("throws if delayFn is missing", async () => {
+    await assert.rejects(
+      () => waitFor(() => Promise.resolve(true), {}),
+      /delayFn is required/,
+    );
+  });
+
   test("resolves immediately when condition is true", async () => {
     let callCount = 0;
-    await waitFor(() => {
-      callCount++;
-      return Promise.resolve(true);
-    });
+    await waitFor(
+      () => {
+        callCount++;
+        return Promise.resolve(true);
+      },
+      {},
+      delay,
+    );
 
     assert.strictEqual(callCount, 1);
   });
@@ -22,6 +35,7 @@ describe("waitFor", () => {
         return Promise.resolve(callCount >= 3);
       },
       { interval: 10, timeout: 5000 },
+      delay,
     );
 
     assert.strictEqual(callCount, 3);
@@ -30,10 +44,11 @@ describe("waitFor", () => {
   test("throws error on timeout", async () => {
     await assert.rejects(
       () =>
-        waitFor(() => Promise.resolve(false), {
-          timeout: 50,
-          interval: 10,
-        }),
+        waitFor(
+          () => Promise.resolve(false),
+          { timeout: 50, interval: 10 },
+          delay,
+        ),
       { message: "Timeout waiting for condition after 50ms" },
     );
   });
@@ -49,18 +64,22 @@ describe("waitFor", () => {
         return Promise.resolve(true);
       },
       { interval: 10, timeout: 5000 },
+      delay,
     );
 
     assert.strictEqual(callCount, 3);
   });
 
   test("uses default options when not provided", async () => {
-    // Just verify it doesn't throw with defaults
     let called = false;
-    await waitFor(() => {
-      called = true;
-      return Promise.resolve(true);
-    });
+    await waitFor(
+      () => {
+        called = true;
+        return Promise.resolve(true);
+      },
+      {},
+      delay,
+    );
 
     assert.strictEqual(called, true);
   });
@@ -81,6 +100,7 @@ describe("waitFor", () => {
         return Promise.resolve(callCount >= 4);
       },
       { interval: 20, maxInterval: 100, timeout: 5000 },
+      delay,
     );
 
     // Intervals should generally increase (with some tolerance for timing)

package/wait.js

@@ -1,14 +1,17 @@
 /**
  * Poll until a condition returns true with exponential backoff
  * @param {() => Promise<boolean>} checkFn - Function that returns true when ready
- * @param {object} [options] - Configuration options
+ * @param {object} options - Configuration options
  * @param {number} [options.timeout] - Maximum time to wait in ms
  * @param {number} [options.interval] - Initial polling interval in ms
  * @param {number} [options.maxInterval] - Maximum polling interval in ms
+ * @param {(ms: number) => Promise<void>} delayFn - Function that returns a promise resolving after ms
  * @returns {Promise<void>}
  * @throws {Error} When timeout is reached
  */
-export async function waitFor(checkFn, options = {}) {
+export async function waitFor(checkFn, options, delayFn) {
+  if (!delayFn) throw new Error("delayFn is required");
+
   const { timeout = 30000, interval = 1000, maxInterval = 10000 } = options;
   const startTime = Date.now();
   let currentInterval = interval;
@@ -20,7 +23,7 @@ export async function waitFor(checkFn, options = {}) {
       // Ignore errors during polling - service may not be up yet
     }
 
-    await new Promise((resolve) => setTimeout(resolve, currentInterval));
+    await delayFn(currentInterval);
     currentInterval = Math.min(currentInterval * 1.5, maxInterval);
   }