@forwardimpact/libcodegen 0.1.36 → 0.1.39

package/base.js

@@ -6,6 +6,7 @@ import { fileURLToPath } from "node:url";
  * Implements dependency injection pattern with explicit validation
  */
 export class CodegenBase {
+  #protoDirs;
   #projectRoot;
   #path;
   #mustache;
@@ -14,19 +15,24 @@ export class CodegenBase {
 
   /**
    * Creates a new codegen base instance with dependency injection
-   * @param {string} projectRoot - Project root directory path
+   * @param {string[]} protoDirs - Array of proto directory paths to scan
+   * @param {string} projectRoot - Project root directory path (for tools/ discovery)
    * @param {object} path - Path module for file operations
    * @param {object} mustache - Mustache template rendering module
    * @param {object} protoLoader - Protocol buffer loader module
    * @param {object} fs - File system module (sync operations only)
    */
-  constructor(projectRoot, path, mustache, protoLoader, fs) {
+  constructor(protoDirs, projectRoot, path, mustache, protoLoader, fs) {
+    if (!protoDirs || !Array.isArray(protoDirs) || protoDirs.length === 0) {
+      throw new Error("protoDirs must be a non-empty array");
+    }
     if (!projectRoot) throw new Error("projectRoot is required");
     if (!path) throw new Error("path module is required");
     if (!mustache) throw new Error("mustache module is required");
     if (!protoLoader) throw new Error("protoLoader module is required");
     if (!fs) throw new Error("fs module is required");
 
+    this.#protoDirs = protoDirs;
     this.#projectRoot = projectRoot;
     this.#path = path;
     this.#mustache = mustache;
@@ -35,36 +41,46 @@ export class CodegenBase {
   }
 
   /**
-   * Collect all proto files from project proto directory and tools directory
+   * Collect all proto files from discovered proto directories and tools directory.
+   * Deduplicates by filename (last occurrence wins), maintains common.proto-first
+   * ordering, and includes all discovered directories as proto include paths.
    * @param {object} opts - Collection options
    * @param {boolean} opts.includeTools - Whether to include tool proto files
    * @returns {string[]} Array of absolute proto file paths
    */
   collectProtoFiles(opts = {}) {
     const { includeTools = true } = opts;
-    const protoDir = this.#path.join(this.#projectRoot, "proto");
 
-    const discovered = this.#fs
-      .readdirSync(protoDir)
-      .filter((f) => f.endsWith(".proto"))
-      .sort();
+    // Collect from all proto directories, dedup by filename (last wins)
+    const byName = new Map();
+    for (const dir of this.#protoDirs) {
+      if (!this.#fs.existsSync(dir)) continue;
+      for (const file of this.#fs.readdirSync(dir)) {
+        if (file.endsWith(".proto")) {
+          byName.set(file, this.#path.join(dir, file));
+        }
+      }
+    }
 
-    const ordered = discovered.includes("common.proto")
+    // Sort and ensure common.proto comes first
+    const sorted = Array.from(byName.keys()).sort();
+    const ordered = sorted.includes("common.proto")
       ? [
-          this.#path.join(protoDir, "common.proto"),
-          ...discovered
+          byName.get("common.proto"),
+          ...sorted
             .filter((f) => f !== "common.proto")
-            .map((f) => this.#path.join(protoDir, f)),
+            .map((f) => byName.get(f)),
         ]
-      : discovered.map((f) => this.#path.join(protoDir, f));
+      : sorted.map((f) => byName.get(f));
 
     if (includeTools) {
       try {
+        const toolsDir = this.#path.join(this.#projectRoot, "tools");
         ordered.push(
           ...this.#fs
-            .readdirSync(this.#path.join(this.#projectRoot, "tools"))
+            .readdirSync(toolsDir)
             .filter((f) => f.endsWith(".proto"))
-            .map((f) => this.#path.join(this.#projectRoot, "tools", f)),
+            .map((f) => this.#path.join(toolsDir, f)),
         );
       } catch {
         // tools directory may not exist; ignore
@@ -74,6 +90,14 @@ export class CodegenBase {
     return ordered;
   }
 
+  /**
+   * Get all proto include directories for cross-file import resolution
+   * @returns {string[]} Array of absolute paths to proto directories
+   */
+  get includeDirs() {
+    return this.#protoDirs.filter((dir) => this.#fs.existsSync(dir));
+  }
+
   /**
    * Load mustache template for given kind
    * @param {"service"|"client"|"exports"|"definition"|"definitions-exports"|"services-exports"} kind - Template kind
@@ -145,7 +169,7 @@ export class CodegenBase {
    */
   parseProtoFile(protoPath) {
     const def = this.#protoLoader.loadSync(protoPath, {
-      includeDirs: [this.#path.dirname(protoPath)],
+      includeDirs: this.includeDirs,
       keepCase: true,
     });
 

package/bin/fit-codegen.js

@@ -3,7 +3,6 @@
 import fs from "node:fs";
 import fsAsync from "node:fs/promises";
 import path from "node:path";
-import { fileURLToPath } from "node:url";
 import { execFileSync } from "node:child_process";
 import { parseArgs } from "node:util";
 
@@ -20,9 +19,6 @@ import {
 } from "@forwardimpact/libcodegen";
 import { createStorage } from "@forwardimpact/libstorage";
 
-const __filename = fileURLToPath(import.meta.url);
-const __dirname = path.dirname(__filename);
-
 /**
  * Create tar.gz bundle of all directories inside sourcePath
  * @param {string} sourcePath - Path containing directories to bundle
@@ -63,11 +59,11 @@ function printUsage() {
   process.stdout.write(
     [
       "Usage:",
-      `  bunx fit-codegen --all                              # Generate all code`,
-      `  bunx fit-codegen --type                             # Generate protobuf types only`,
-      `  bunx fit-codegen --service                          # Generate service bases only`,
-      `  bunx fit-codegen --client                           # Generate clients only`,
-      `  bunx fit-codegen --definition                       # Generate service definitions only`,
+      `  npx fit-codegen --all                              # Generate all code`,
+      `  npx fit-codegen --type                             # Generate protobuf types only`,
+      `  npx fit-codegen --service                          # Generate service bases only`,
+      `  npx fit-codegen --client                           # Generate clients only`,
+      `  npx fit-codegen --definition                       # Generate service definitions only`,
     ].join("\n") + "\n",
   );
 }
@@ -117,16 +113,65 @@ function parseFlags() {
 }
 
 /**
- * Create codegen instances
+ * Discover proto directories from installed @forwardimpact/* packages
+ * and the project root. Scans node_modules for packages that include
+ * a proto/ subdirectory, plus the project's own proto/ if present.
  * @param {string} projectRoot - Project root directory path
+ * @returns {string[]} Array of absolute paths to proto directories
+ */
+function discoverProtoDirs(projectRoot) {
+  const protoDirs = [];
+
+  // Scan node_modules/@forwardimpact/*/proto/ for package-owned protos
+  // Use fs.statSync to follow workspace symlinks (entry.isDirectory() is false for symlinks)
+  const scopeDir = path.join(projectRoot, "node_modules", "@forwardimpact");
+  if (fs.existsSync(scopeDir)) {
+    for (const name of fs.readdirSync(scopeDir)) {
+      const protoDir = path.join(scopeDir, name, "proto");
+      if (fs.existsSync(protoDir) && fs.statSync(protoDir).isDirectory()) {
+        protoDirs.push(fs.realpathSync(protoDir));
+      }
+    }
+  }
+
+  // Also check workspace-linked packages (monorepo with symlinked node_modules)
+  // The loop above handles this since workspace packages appear in node_modules
+
+  // Include the project's own proto/ directory for custom protos
+  const projectProtoDir = path.join(projectRoot, "proto");
+  if (fs.existsSync(projectProtoDir)) {
+    protoDirs.push(projectProtoDir);
+  }
+
+  return protoDirs;
+}
+
+/**
+ * Create codegen instances
+ * @param {string[]} protoDirs - Array of proto directory paths
+ * @param {string} projectRoot - Project root for tools/ discovery
  * @param {object} path - Path module
  * @param {object} mustache - Mustache module
  * @param {object} protoLoader - Proto loader module
  * @param {object} fs - File system module
  * @returns {object} Codegen instances
  */
-function createCodegen(projectRoot, path, mustache, protoLoader, fs) {
-  const base = new CodegenBase(projectRoot, path, mustache, protoLoader, fs);
+function createCodegen(
+  protoDirs,
+  projectRoot,
+  path,
+  mustache,
+  protoLoader,
+  fs,
+) {
+  const base = new CodegenBase(
+    protoDirs,
+    projectRoot,
+    path,
+    mustache,
+    protoLoader,
+    fs,
+  );
   return {
     types: new CodegenTypes(base),
     services: new CodegenServices(base),
@@ -134,6 +179,63 @@ function createCodegen(projectRoot, path, mustache, protoLoader, fs) {
   };
 }
 
+/**
+ * Count files recursively in a directory
+ * @param {string} dirPath - Directory to count files in
+ * @returns {number} Total file count
+ */
+function countFiles(dirPath) {
+  let count = 0;
+  if (!fs.existsSync(dirPath)) return count;
+  for (const entry of fs.readdirSync(dirPath, { withFileTypes: true })) {
+    if (entry.isDirectory()) {
+      count += countFiles(path.join(dirPath, entry.name));
+    } else if (!entry.name.endsWith(".tar.gz")) {
+      count++;
+    }
+  }
+  return count;
+}
+
+/**
+ * Print a summary of generated code
+ * @param {string} sourcePath - Path to generated directory
+ * @param {object} flags - Parsed generation flags
+ */
+function printSummary(sourcePath, flags) {
+  const totalFiles = countFiles(sourcePath);
+  const relPath = path.relative(process.cwd(), sourcePath);
+  const lines = [`Generated ${totalFiles} files in ./${relPath}/`];
+
+  const dirLabels = {
+    types: "Protocol Buffer types",
+    proto: "Proto source files",
+    services: "Service bases and clients",
+    definitions: "Service definitions",
+  };
+
+  if (fs.existsSync(sourcePath)) {
+    const dirs = fs
+      .readdirSync(sourcePath, { withFileTypes: true })
+      .filter((e) => e.isDirectory());
+
+    for (const dir of dirs) {
+      const label = dirLabels[dir.name];
+      if (label) lines.push(`  ${dir.name}/  — ${label}`);
+    }
+  }
+
+  const generated = [
+    flags.doTypes && "types",
+    flags.doServices && "services",
+    flags.doClients && "clients",
+    flags.doDefinitions && "definitions",
+  ].filter(Boolean);
+  lines.push(`\nCode generation complete (${generated.join(", ")}).`);
+
+  process.stdout.write(lines.join("\n") + "\n");
+}
+
 /**
  * Execute code generation tasks
  * @param {object} codegens - Codegen instances
@@ -175,11 +277,12 @@ async function executeGeneration(codegens, sourcePath, flags) {
 }
 
 /**
- * Simplified main function
+ * Run code generation pipeline
+ * @param {string[]} protoDirs - Discovered proto directories
  * @param {string} projectRoot - Project root directory path
  * @param {object} finder - Finder instance for path management
  */
-async function runCodegen(projectRoot, finder) {
+async function runCodegen(protoDirs, projectRoot, finder) {
   const parsedFlags = parseFlags();
 
   if (!parsedFlags.hasGenerationFlags()) {
@@ -193,34 +296,30 @@ async function runCodegen(projectRoot, finder) {
 
   await generatedStorage.ensureBucket();
 
-  const codegens = createCodegen(projectRoot, path, mustache, protoLoader, fs);
+  // Write package.json with "type": "module" so Node.js treats generated
+  // ES module files correctly and avoids MODULE_TYPELESS_PACKAGE_JSON warnings.
+  const generatedPkgPath = path.join(sourcePath, "package.json");
+  if (!fs.existsSync(generatedPkgPath)) {
+    fs.writeFileSync(
+      generatedPkgPath,
+      JSON.stringify({ type: "module" }, null, 2) + "\n",
+    );
+  }
+
+  const codegens = createCodegen(
+    protoDirs,
+    projectRoot,
+    path,
+    mustache,
+    protoLoader,
+    fs,
+  );
   await executeGeneration(codegens, sourcePath, parsedFlags);
 
   await finder.createPackageSymlinks(sourcePath);
   await createBundle(sourcePath);
-}
 
-/**
- * Find the monorepo root directory (the one with workspaces)
- * @param {string} startPath - Starting directory path
- * @returns {string} Project root directory path
- */
-function findMonorepoRoot(startPath) {
-  let current = startPath;
-  for (let depth = 0; depth < 10; depth++) {
-    const packageJsonPath = path.join(current, "package.json");
-    if (fs.existsSync(packageJsonPath)) {
-      const packageJson = JSON.parse(fs.readFileSync(packageJsonPath, "utf8"));
-      // Check if this package.json has workspaces (indicates monorepo root)
-      if (packageJson.workspaces) {
-        return current;
-      }
-    }
-    const parent = path.dirname(current);
-    if (parent === current) break;
-    current = parent;
-  }
-  throw new Error("Could not find monorepo root");
+  printSummary(sourcePath, parsedFlags);
 }
 
 /**
@@ -230,9 +329,18 @@ async function main() {
   try {
     const logger = new Logger("codegen");
     const finder = new Finder(fsAsync, logger, process);
-    const projectRoot = findMonorepoRoot(__dirname);
+    const projectRoot = finder.findProjectRoot(process.cwd());
+
+    const protoDirs = discoverProtoDirs(projectRoot);
+    if (protoDirs.length === 0) {
+      throw new Error(
+        "No proto directories found. Ensure @forwardimpact packages " +
+          "with proto/ directories are installed, or add proto files " +
+          "to your project's proto/ directory.",
+      );
+    }
 
-    await runCodegen(projectRoot, finder);
+    await runCodegen(protoDirs, projectRoot, finder);
   } catch (err) {
     process.stderr.write(`Error: ${err.message}\n`);
     process.exit(1);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@forwardimpact/libcodegen",
-  "version": "0.1.36",
+  "version": "0.1.39",
   "description": "Protocol Buffer code generation utilities for Guide",
   "license": "Apache-2.0",
   "author": "D. Olsson <hi@senzilla.io>",
@@ -17,14 +17,17 @@
     "test": "bun run node --test test/*.test.js"
   },
   "dependencies": {
+    "@forwardimpact/libstorage": "^0.1.53",
+    "@forwardimpact/libtelemetry": "^0.1.22",
+    "@forwardimpact/libutil": "^0.1.64",
     "@grpc/proto-loader": "^0.8.0",
-    "mustache": "^4.2.0"
-  },
-  "devDependencies": {
-    "@forwardimpact/libharness": "^0.1.5",
+    "mustache": "^4.2.0",
     "protobufjs": "^7.5.4",
     "protobufjs-cli": "^2.0.0"
   },
+  "devDependencies": {
+    "@forwardimpact/libharness": "^0.1.5"
+  },
   "publishConfig": {
     "access": "public"
   }

package/types.js

@@ -1,3 +1,5 @@
+import { createRequire } from "node:module";
+
 /**
  * Handles JavaScript type generation from protobuf files
  * Specializes in Protocol Buffer to JavaScript type conversion
@@ -70,7 +72,15 @@ export class CodegenTypes {
    * @returns {Promise<void>}
    */
   async generateJavaScriptTypes(protoFiles, outFile) {
+    // Resolve pbjs binary from protobufjs-cli package — works in both Bun and Node
+    const require = createRequire(import.meta.url);
+    const pbjsBin = require.resolve("protobufjs-cli/bin/pbjs");
+
+    // Pass all proto directories as include paths so cross-file imports resolve
+    const includePaths = this.#base.includeDirs.flatMap((dir) => ["-p", dir]);
+
     const args = [
+      pbjsBin,
       "-t",
       "static-module",
       "-w",
@@ -80,12 +90,13 @@ export class CodegenTypes {
       "--no-service",
       "--force-message",
       "--keep-case",
+      ...includePaths,
       "-o",
       outFile,
       ...protoFiles,
     ];
 
-    await this.#base.run("bunx", ["pbjs", ...args], {
+    await this.#base.run(process.execPath, args, {
       cwd: this.#base.projectRoot,
     });
   }