@forwardimpact/libcodegen 0.1.37 → 0.1.41

package/bin/fit-codegen.js

@@ -1,14 +1,14 @@
 #!/usr/bin/env node
 
-import fs from "node:fs";
+import fs, { readFileSync } from "node:fs";
 import fsAsync from "node:fs/promises";
 import path from "node:path";
 import { execFileSync } from "node:child_process";
-import { parseArgs } from "node:util";
 
 import protoLoader from "@grpc/proto-loader";
 import mustache from "mustache";
 
+import { createCli, SummaryRenderer } from "@forwardimpact/libcli";
 import { Finder } from "@forwardimpact/libutil";
 import { Logger } from "@forwardimpact/libtelemetry";
 import {
@@ -19,6 +19,39 @@ import {
 } from "@forwardimpact/libcodegen";
 import { createStorage } from "@forwardimpact/libstorage";
 
+const { version: VERSION } = JSON.parse(
+  readFileSync(new URL("../package.json", import.meta.url), "utf8"),
+);
+
+const definition = {
+  name: "fit-codegen",
+  version: VERSION,
+  description: "Generate protobuf types, service clients, and definitions",
+  options: {
+    all: { type: "boolean", description: "Generate all code" },
+    type: { type: "boolean", description: "Generate protobuf types only" },
+    service: {
+      type: "boolean",
+      description: "Generate service bases only",
+    },
+    client: { type: "boolean", description: "Generate clients only" },
+    definition: {
+      type: "boolean",
+      description: "Generate service definitions only",
+    },
+    help: { type: "boolean", short: "h", description: "Show this help" },
+    version: { type: "boolean", description: "Show version" },
+    json: { type: "boolean", description: "Output help as JSON" },
+  },
+  examples: [
+    "npx fit-codegen --all",
+    "npx fit-codegen --type",
+    "npx fit-codegen --service",
+  ],
+};
+
+const cli = createCli(definition);
+
 /**
  * Create tar.gz bundle of all directories inside sourcePath
  * @param {string} sourcePath - Path containing directories to bundle
@@ -53,51 +86,16 @@ async function createBundle(sourcePath) {
 }
 
 /**
- * Print CLI usage help
- */
-function printUsage() {
-  process.stdout.write(
-    [
-      "Usage:",
-      `  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",
-  );
-}
-
-/**
- * Parse command line flags
+ * Parse command line flags using libcli
  * @returns {object} Parsed flags with convenience methods
  */
 function parseFlags() {
-  const { values } = parseArgs({
-    options: {
-      all: {
-        type: "boolean",
-        default: false,
-      },
-      type: {
-        type: "boolean",
-        default: false,
-      },
-      service: {
-        type: "boolean",
-        default: false,
-      },
-      client: {
-        type: "boolean",
-        default: false,
-      },
-      definition: {
-        type: "boolean",
-        default: false,
-      },
-    },
-  });
+  const parsed = cli.parse(process.argv.slice(2));
+  if (!parsed) {
+    process.exit(0);
+  }
 
+  const { values } = parsed;
   const doAll = values.all;
   return {
     doTypes: doAll || values.type,
@@ -179,6 +177,72 @@ function createCodegen(
   };
 }
 
+/**
+ * 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 dirLabels = {
+    types: "Protocol Buffer types",
+    proto: "Proto source files",
+    services: "Service bases and clients",
+    definitions: "Service definitions",
+  };
+
+  const items = [];
+  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) items.push({ label: `${dir.name}/`, description: label });
+    }
+  }
+
+  const summary = new SummaryRenderer({ process });
+  summary.render(
+    {
+      title: `Generated ${totalFiles} files in ./${relPath}/`,
+      items,
+    },
+    process.stdout,
+  );
+
+  const generated = [
+    flags.doTypes && "types",
+    flags.doServices && "services",
+    flags.doClients && "clients",
+    flags.doDefinitions && "definitions",
+  ].filter(Boolean);
+  process.stdout.write(
+    `\nCode generation complete (${generated.join(", ")}).\n`,
+  );
+}
+
 /**
  * Execute code generation tasks
  * @param {object} codegens - Codegen instances
@@ -229,9 +293,10 @@ async function runCodegen(protoDirs, projectRoot, finder) {
   const parsedFlags = parseFlags();
 
   if (!parsedFlags.hasGenerationFlags()) {
-    printUsage();
-    process.exitCode = 1;
-    return;
+    cli.usageError(
+      "no generation flags specified (use --all, --type, --service, --client, or --definition)",
+    );
+    process.exit(2);
   }
 
   const generatedStorage = createStorage("generated", "local");
@@ -239,6 +304,16 @@ async function runCodegen(protoDirs, projectRoot, finder) {
 
   await generatedStorage.ensureBucket();
 
+  // 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,
@@ -251,6 +326,8 @@ async function runCodegen(protoDirs, projectRoot, finder) {
 
   await finder.createPackageSymlinks(sourcePath);
   await createBundle(sourcePath);
+
+  printSummary(sourcePath, parsedFlags);
 }
 
 /**
@@ -273,12 +350,14 @@ async function main() {
 
     await runCodegen(protoDirs, projectRoot, finder);
   } catch (err) {
-    process.stderr.write(`Error: ${err.message}\n`);
+    const logger = new Logger("codegen");
+    logger.exception("main", err);
+    cli.error(err.message);
     process.exit(1);
   }
 }
 
 main().catch((err) => {
-  process.stderr.write(`Unexpected error: ${err.message}\n`);
+  cli.error(err.message);
   process.exit(1);
 });

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@forwardimpact/libcodegen",
-  "version": "0.1.37",
+  "version": "0.1.41",
   "description": "Protocol Buffer code generation utilities for Guide",
   "license": "Apache-2.0",
   "author": "D. Olsson <hi@senzilla.io>",
@@ -17,13 +17,14 @@
     "test": "bun run node --test test/*.test.js"
   },
   "dependencies": {
+    "@forwardimpact/libcli": "^0.1.0",
     "@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",
     "protobufjs": "^7.5.4",
-    "protobufjs-cli": "^2.0.0"
+    "protobufjs-cli": "^2.0.1"
   },
   "devDependencies": {
     "@forwardimpact/libharness": "^0.1.5"