@forwardimpact/libutil 0.1.72 → 0.1.74

package/bin/fit-download-bundle.js

@@ -16,7 +16,7 @@ const definition = {
   name: "fit-download-bundle",
   version: VERSION,
   description: "Download generated code bundle from remote storage",
-  options: {
+  globalOptions: {
     help: { type: "boolean", short: "h", description: "Show this help" },
     version: { type: "boolean", description: "Show version" },
     json: { type: "boolean", description: "Output help as JSON" },

package/bin/fit-tiktoken.js

@@ -13,7 +13,7 @@ const definition = {
   version: VERSION,
   description: "Count tokens in text",
   usage: "fit-tiktoken <text>\n       echo 'text' | fit-tiktoken",
-  options: {
+  globalOptions: {
     help: { type: "boolean", short: "h", description: "Show this help" },
     version: { type: "boolean", description: "Show version" },
     json: { type: "boolean", description: "Output help as JSON" },

package/package.json

@@ -1,15 +1,25 @@
 {
   "name": "@forwardimpact/libutil",
-  "version": "0.1.72",
+  "version": "0.1.74",
   "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"

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);
-  });
-});

package/test/extractor.test.js

@@ -1,338 +0,0 @@
-import { test, describe, beforeEach, afterEach } from "node:test";
-import assert from "node:assert";
-import fs from "fs";
-import fsPromises from "fs/promises";
-import path from "path";
-import { fileURLToPath } from "url";
-
-// Module under test
-import { TarExtractor, ZipExtractor } from "../extractor.js";
-
-describe("TarExtractor", () => {
-  let extractor;
-  let tempDir;
-  let fixturesDir;
-
-  beforeEach(() => {
-    extractor = new TarExtractor(fsPromises, path);
-
-    // Setup directories
-    const __filename = fileURLToPath(import.meta.url);
-    const __dirname = path.dirname(__filename);
-    fixturesDir = path.join(__dirname, "fixtures");
-    tempDir = path.join(__dirname, ".tmp-extractor-test");
-
-    // Clean up any existing temp directory
-    if (fs.existsSync(tempDir)) {
-      fs.rmSync(tempDir, { recursive: true, force: true });
-    }
-    fs.mkdirSync(tempDir, { recursive: true });
-  });
-
-  afterEach(() => {
-    // Clean up temp directory
-    if (fs.existsSync(tempDir)) {
-      fs.rmSync(tempDir, { recursive: true, force: true });
-    }
-  });
-
-  describe("constructor", () => {
-    test("creates TarExtractor with fs and path", () => {
-      const extractor = new TarExtractor(fsPromises, path);
-
-      assert.ok(extractor instanceof TarExtractor);
-    });
-
-    test("validates fs parameter", () => {
-      assert.throws(() => new TarExtractor(), {
-        message: /fs dependency is required/,
-      });
-      assert.throws(() => new TarExtractor(null, path), {
-        message: /fs dependency is required/,
-      });
-    });
-
-    test("validates path parameter", () => {
-      assert.throws(() => new TarExtractor(fsPromises), {
-        message: /path dependency is required/,
-      });
-      assert.throws(() => new TarExtractor(fsPromises, null), {
-        message: /path dependency is required/,
-      });
-    });
-  });
-
-  describe("extract", () => {
-    test("extracts tar.gz archive to specified directory", async () => {
-      const tarPath = path.join(fixturesDir, "sample.tar.gz");
-      const outputDir = path.join(tempDir, "tar-output");
-
-      await extractor.extract(tarPath, outputDir);
-
-      // Verify extracted files exist
-      assert.ok(fs.existsSync(path.join(outputDir, "test.txt")));
-      assert.ok(fs.existsSync(path.join(outputDir, "nested.txt")));
-      assert.ok(fs.existsSync(path.join(outputDir, "subdir", "deep.txt")));
-    });
-
-    test("extracts files with correct content", async () => {
-      const tarPath = path.join(fixturesDir, "sample.tar.gz");
-      const outputDir = path.join(tempDir, "tar-content");
-
-      await extractor.extract(tarPath, outputDir);
-
-      // Verify file contents
-      const testContent = await fsPromises.readFile(
-        path.join(outputDir, "test.txt"),
-        "utf8",
-      );
-      assert.strictEqual(testContent.trim(), "Hello from root file");
-
-      const nestedContent = await fsPromises.readFile(
-        path.join(outputDir, "nested.txt"),
-        "utf8",
-      );
-      assert.strictEqual(nestedContent.trim(), "Nested content");
-
-      const deepContent = await fsPromises.readFile(
-        path.join(outputDir, "subdir", "deep.txt"),
-        "utf8",
-      );
-      assert.strictEqual(deepContent.trim(), "Deep file content");
-    });
-
-    test("creates nested directory structure", async () => {
-      const tarPath = path.join(fixturesDir, "sample.tar.gz");
-      const outputDir = path.join(tempDir, "tar-structure");
-
-      await extractor.extract(tarPath, outputDir);
-
-      // Verify directory structure
-      const subdirPath = path.join(outputDir, "subdir");
-      assert.ok(fs.existsSync(subdirPath));
-
-      const stats = await fsPromises.stat(subdirPath);
-      assert.ok(stats.isDirectory());
-    });
-
-    test("handles non-existent output directory", async () => {
-      const tarPath = path.join(fixturesDir, "sample.tar.gz");
-      const outputDir = path.join(tempDir, "deep", "nested", "tar-output");
-
-      // Should not throw - should create directory structure
-      await extractor.extract(tarPath, outputDir);
-
-      assert.ok(fs.existsSync(path.join(outputDir, "test.txt")));
-    });
-  });
-});
-
-describe("ZipExtractor", () => {
-  let extractor;
-  let tempDir;
-  let fixturesDir;
-
-  beforeEach(() => {
-    extractor = new ZipExtractor(fsPromises, path);
-
-    // Setup directories
-    const __filename = fileURLToPath(import.meta.url);
-    const __dirname = path.dirname(__filename);
-    fixturesDir = path.join(__dirname, "fixtures");
-    tempDir = path.join(__dirname, ".tmp-extractor-test");
-
-    // Clean up any existing temp directory
-    if (fs.existsSync(tempDir)) {
-      fs.rmSync(tempDir, { recursive: true, force: true });
-    }
-    fs.mkdirSync(tempDir, { recursive: true });
-  });
-
-  afterEach(() => {
-    // Clean up temp directory
-    if (fs.existsSync(tempDir)) {
-      fs.rmSync(tempDir, { recursive: true, force: true });
-    }
-  });
-
-  describe("constructor", () => {
-    test("creates ZipExtractor with fs and path", () => {
-      const extractor = new ZipExtractor(fsPromises, path);
-
-      assert.ok(extractor instanceof ZipExtractor);
-    });
-
-    test("validates fs parameter", () => {
-      assert.throws(() => new ZipExtractor(), {
-        message: /fs dependency is required/,
-      });
-      assert.throws(() => new ZipExtractor(null, path), {
-        message: /fs dependency is required/,
-      });
-    });
-
-    test("validates path parameter", () => {
-      assert.throws(() => new ZipExtractor(fsPromises), {
-        message: /path dependency is required/,
-      });
-      assert.throws(() => new ZipExtractor(fsPromises, null), {
-        message: /path dependency is required/,
-      });
-    });
-  });
-
-  describe("extract", () => {
-    test("extracts zip archive to specified directory", async () => {
-      const zipPath = path.join(fixturesDir, "sample.zip");
-      const outputDir = path.join(tempDir, "zip-output");
-
-      await extractor.extract(zipPath, outputDir);
-
-      // Verify extracted files exist
-      assert.ok(fs.existsSync(path.join(outputDir, "test.txt")));
-      assert.ok(fs.existsSync(path.join(outputDir, "nested.txt")));
-      assert.ok(fs.existsSync(path.join(outputDir, "subdir", "deep.txt")));
-    });
-
-    test("extracts files with correct content", async () => {
-      const zipPath = path.join(fixturesDir, "sample.zip");
-      const outputDir = path.join(tempDir, "zip-content");
-
-      await extractor.extract(zipPath, outputDir);
-
-      // Verify file contents
-      const testContent = await fsPromises.readFile(
-        path.join(outputDir, "test.txt"),
-        "utf8",
-      );
-      assert.strictEqual(testContent.trim(), "Hello from root file");
-
-      const nestedContent = await fsPromises.readFile(
-        path.join(outputDir, "nested.txt"),
-        "utf8",
-      );
-      assert.strictEqual(nestedContent.trim(), "Nested content");
-
-      const deepContent = await fsPromises.readFile(
-        path.join(outputDir, "subdir", "deep.txt"),
-        "utf8",
-      );
-      assert.strictEqual(deepContent.trim(), "Deep file content");
-    });
-
-    test("creates nested directory structure", async () => {
-      const zipPath = path.join(fixturesDir, "sample.zip");
-      const outputDir = path.join(tempDir, "zip-structure");
-
-      await extractor.extract(zipPath, outputDir);
-
-      // Verify directory structure
-      const subdirPath = path.join(outputDir, "subdir");
-      assert.ok(fs.existsSync(subdirPath));
-
-      const stats = await fsPromises.stat(subdirPath);
-      assert.ok(stats.isDirectory());
-    });
-
-    test("handles non-existent output directory", async () => {
-      const zipPath = path.join(fixturesDir, "sample.zip");
-      const outputDir = path.join(tempDir, "deep", "nested", "zip-output");
-
-      // Should not throw - should create directory structure
-      await extractor.extract(zipPath, outputDir);
-
-      assert.ok(fs.existsSync(path.join(outputDir, "test.txt")));
-    });
-
-    test("throws error for invalid zip file", async () => {
-      const invalidZipPath = path.join(tempDir, "invalid.zip");
-
-      // Create an invalid zip file (just some random bytes)
-      await fsPromises.writeFile(invalidZipPath, Buffer.from([0, 1, 2, 3, 4]));
-
-      const outputDir = path.join(tempDir, "invalid-output");
-
-      await assert.rejects(
-        async () => {
-          await extractor.extract(invalidZipPath, outputDir);
-        },
-        {
-          message: /Invalid ZIP file/,
-        },
-      );
-    });
-  });
-
-  describe("format comparison", () => {
-    test("both extractors produce identical file content", async () => {
-      const tarPath = path.join(fixturesDir, "sample.tar.gz");
-      const zipPath = path.join(fixturesDir, "sample.zip");
-      const tarOutput = path.join(tempDir, "tar-compare");
-      const zipOutput = path.join(tempDir, "zip-compare");
-
-      const tarExtractor = new TarExtractor(fsPromises, path);
-      const zipExtractor = new ZipExtractor(fsPromises, path);
-
-      await tarExtractor.extract(tarPath, tarOutput);
-      await zipExtractor.extract(zipPath, zipOutput);
-
-      // Compare file contents
-      const tarTest = await fsPromises.readFile(
-        path.join(tarOutput, "test.txt"),
-        "utf8",
-      );
-      const zipTest = await fsPromises.readFile(
-        path.join(zipOutput, "test.txt"),
-        "utf8",
-      );
-      assert.strictEqual(tarTest, zipTest);
-
-      const tarNested = await fsPromises.readFile(
-        path.join(tarOutput, "nested.txt"),
-        "utf8",
-      );
-      const zipNested = await fsPromises.readFile(
-        path.join(zipOutput, "nested.txt"),
-        "utf8",
-      );
-      assert.strictEqual(tarNested, zipNested);
-
-      const tarDeep = await fsPromises.readFile(
-        path.join(tarOutput, "subdir", "deep.txt"),
-        "utf8",
-      );
-      const zipDeep = await fsPromises.readFile(
-        path.join(zipOutput, "subdir", "deep.txt"),
-        "utf8",
-      );
-      assert.strictEqual(tarDeep, zipDeep);
-    });
-
-    test("both extractors create identical directory structure", async () => {
-      const tarPath = path.join(fixturesDir, "sample.tar.gz");
-      const zipPath = path.join(fixturesDir, "sample.zip");
-      const tarOutput = path.join(tempDir, "tar-struct");
-      const zipOutput = path.join(tempDir, "zip-struct");
-
-      const tarExtractor = new TarExtractor(fsPromises, path);
-      const zipExtractor = new ZipExtractor(fsPromises, path);
-
-      await tarExtractor.extract(tarPath, tarOutput);
-      await zipExtractor.extract(zipPath, zipOutput);
-
-      // Check that both have the subdir
-      assert.ok(fs.existsSync(path.join(tarOutput, "subdir")));
-      assert.ok(fs.existsSync(path.join(zipOutput, "subdir")));
-
-      // Check that both subdirs are directories
-      const tarSubdirStats = await fsPromises.stat(
-        path.join(tarOutput, "subdir"),
-      );
-      const zipSubdirStats = await fsPromises.stat(
-        path.join(zipOutput, "subdir"),
-      );
-      assert.ok(tarSubdirStats.isDirectory());
-      assert.ok(zipSubdirStats.isDirectory());
-    });
-  });
-});