@forwardimpact/libcodegen 0.1.47 → 0.1.49

package/bin/fit-codegen.js

@@ -238,6 +238,7 @@ function printSummary(sourcePath, flags) {
   summary.render(
     {
       title: `Generated ${totalFiles} files in ./${relPath}/`,
+      ok: true,
       items,
     },
     process.stdout,

package/package.json

@@ -1,9 +1,27 @@
 {
   "name": "@forwardimpact/libcodegen",
-  "version": "0.1.47",
-  "description": "Protocol Buffer code generation utilities for Guide",
+  "version": "0.1.49",
+  "description": "Protobuf code generation — produces the types and clients consumed by `libtype` and `librpc`.",
+  "keywords": [
+    "codegen",
+    "protobuf",
+    "build-tool",
+    "agent"
+  ],
+  "homepage": "https://www.forwardimpact.team",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/forwardimpact/monorepo.git",
+    "directory": "libraries/libcodegen"
+  },
   "license": "Apache-2.0",
   "author": "D. Olsson <hi@senzilla.io>",
+  "forwardimpact": {
+    "capability": "agent-infrastructure",
+    "needs": [
+      "Generate code from .proto files"
+    ]
+  },
   "type": "module",
   "main": "./src/index.js",
   "exports": {
@@ -19,10 +37,6 @@
     "templates/**",
     "README.md"
   ],
-  "engines": {
-    "bun": ">=1.2.0",
-    "node": ">=18.0.0"
-  },
   "scripts": {
     "test": "bun test test/*.test.js"
   },
@@ -33,12 +47,16 @@
     "@forwardimpact/libutil": "^0.1.64",
     "@grpc/proto-loader": "^0.8.0",
     "mustache": "^4.2.0",
-    "protobufjs": "^7.5.4",
+    "protobufjs": "^7.5.6",
     "protobufjs-cli": "2.0.1"
   },
   "devDependencies": {
     "@forwardimpact/libharness": "^0.1.5"
   },
+  "engines": {
+    "bun": ">=1.2.0",
+    "node": ">=18.0.0"
+  },
   "publishConfig": {
     "access": "public"
   }

package/src/base.js

@@ -27,6 +27,29 @@ const PBJS_TYPE_MAP = {
   bytes: "bytes",
 };
 
+/**
+ * Extract field metadata from a protobufjs Type
+ * @param {protobuf.Type} pbjsType - Resolved protobufjs type
+ * @returns {object} Map of snake_case field names to metadata
+ */
+function extractFields(pbjsType) {
+  const fields = {};
+  for (const [camelName, field] of Object.entries(pbjsType.fields)) {
+    const name = camelToSnake(camelName);
+    const typeName = field.resolvedType
+      ? "message"
+      : PBJS_TYPE_MAP[field.type] || field.type;
+    const hasOptionalKeyword = pbjsType.oneofs?.[`_${camelName}`] !== undefined;
+    fields[name] = {
+      type: typeName,
+      optional: hasOptionalKeyword,
+      repeated: field.repeated || false,
+      description: field.comment || null,
+    };
+  }
+  return fields;
+}
+
 /**
  * Base class for code generation utilities providing shared functionality
  * Implements dependency injection pattern with explicit validation
@@ -279,10 +302,29 @@ export class CodegenBase {
     if (!parsed) return null;
 
     const { packageName, serviceName, methods: parsedMethods } = parsed;
+    const root = this.#loadProtobufRoot(protoPath);
+
+    const methods = {};
+    for (const method of parsedMethods) {
+      const pbjsType = this.#resolveRequestType(root, method);
+      const fields = pbjsType ? extractFields(pbjsType) : {};
+      methods[method.name] = {
+        requestType: `${method.requestTypeNamespace}.${method.requestType}`,
+        fields,
+      };
+    }
 
-    // Load with protobufjs for field types, optionality, and comments
+    return { packageName, serviceName, methods };
+  }
+
+  /**
+   * Load a protobufjs Root with include-path resolution
+   * @param {string} protoPath - Absolute path to .proto file
+   * @returns {protobuf.Root}
+   */
+  #loadProtobufRoot(protoPath) {
     const root = new protobuf.Root();
-    root.resolvePath = (origin, target) => {
+    root.resolvePath = (_origin, target) => {
       for (const dir of this.includeDirs) {
         const candidate = this.#path.join(dir, target);
         if (this.#fs.existsSync(candidate)) return candidate;
@@ -291,50 +333,26 @@ export class CodegenBase {
     };
     root.loadSync(protoPath, { alternateCommentMode: true });
     root.resolveAll();
+    return root;
+  }
 
-    const methods = {};
-    for (const method of parsedMethods) {
-      const reqTypeName = `${method.requestTypeNamespace}.${method.requestType}`;
-      let pbjsType = null;
+  /**
+   * Resolve the request type for a method from the protobufjs Root
+   * @param {protobuf.Root} root - Loaded protobufjs root
+   * @param {object} method - Parsed method descriptor
+   * @returns {protobuf.Type|null}
+   */
+  #resolveRequestType(root, method) {
+    const qualified = `${method.requestTypeNamespace}.${method.requestType}`;
+    try {
+      return root.lookupType(qualified);
+    } catch {
       try {
-        pbjsType = root.lookupType(reqTypeName);
+        return root.lookupType(method.requestType);
       } catch {
-        try {
-          pbjsType = root.lookupType(method.requestType);
-        } catch {
-          // no type found
-        }
-      }
-
-      const fields = {};
-      if (pbjsType) {
-        for (const [camelName, field] of Object.entries(pbjsType.fields)) {
-          const name = camelToSnake(camelName);
-          // Map protobufjs type to simple type name
-          const typeName = field.resolvedType
-            ? "message"
-            : PBJS_TYPE_MAP[field.type] || field.type;
-
-          // proto3 optional uses synthetic oneofs named _fieldname
-          const hasOptionalKeyword =
-            pbjsType.oneofs?.[`_${camelName}`] !== undefined;
-
-          fields[name] = {
-            type: typeName,
-            optional: hasOptionalKeyword,
-            repeated: field.repeated || false,
-            description: field.comment || null,
-          };
-        }
+        return null;
       }
-
-      methods[method.name] = {
-        requestType: `${method.requestTypeNamespace}.${method.requestType}`,
-        fields,
-      };
     }
-
-    return { packageName, serviceName, methods };
   }
 
   /**