@reventlessdev/reventless-spec 3.0.0-alpha.143 → 3.0.0-alpha.145

package/src/generator/GraftTrait.res.mjs

@@ -3,11 +3,12 @@
 import * as Nodefs from "node:fs";
 import * as Nodeurl from "node:url";
 import * as Nodepath from "node:path";
-import * as Stdlib_Dict from "@rescript/runtime/lib/es6/Stdlib_Dict.js";
 import * as Stdlib_JSON from "@rescript/runtime/lib/es6/Stdlib_JSON.js";
 import * as Nodemodule from "node:module";
 import * as Stdlib_Array from "@rescript/runtime/lib/es6/Stdlib_Array.js";
 import * as Stdlib_Option from "@rescript/runtime/lib/es6/Stdlib_Option.js";
+import * as Stdlib_Result from "@rescript/runtime/lib/es6/Stdlib_Result.js";
+import * as CliArgs$Reventless from "../CliArgs.res.mjs";
 import * as Primitive_exceptions from "@rescript/runtime/lib/es6/Primitive_exceptions.js";
 import * as Util_Sury$Reventless from "../util/Util_Sury.res.mjs";
 
@@ -26,35 +27,6 @@ let usage = `Usage: graft-trait <trait-package> --into <srcDir> --tests <testsDi
   Every other --key value is a field of the trait's config. The trait validates
   them, so run it once to be told what it wants.`;
 
-function parseFlags(args) {
-  let out = {};
-  let go = _i => {
-    while (true) {
-      let i = _i;
-      let arg = args[i];
-      if (arg === undefined) {
-        return;
-      }
-      if (arg.startsWith("--")) {
-        let key = arg.slice(2, arg.length);
-        let value = args[i + 1 | 0];
-        if (value !== undefined && !value.startsWith("--")) {
-          out[key] = value;
-          _i = i + 2 | 0;
-          continue;
-        }
-        out[key] = true;
-        _i = i + 1 | 0;
-        continue;
-      }
-      _i = i + 1 | 0;
-      continue;
-    };
-  };
-  go(0);
-  return out;
-}
-
 function splitList(value) {
   return value.split(",").map(part => part.trim()).filter(part => part !== "").map(prim => prim);
 }
@@ -82,112 +54,143 @@ function arrayFieldNames(schema) {
   }
 }
 
-async function main() {
-  let argv = process.argv.slice(2, process.argv.length);
-  let traitPackage = argv[0];
-  if (traitPackage !== undefined) {
-    switch (traitPackage) {
-      case "" :
-      case "--help" :
-      case "-h" :
-        break;
-      default:
-        let flags = parseFlags(argv.slice(1, argv.length));
-        let stringFlag = key => Stdlib_Option.flatMap(flags[key], Stdlib_JSON.Decode.string);
-        let into = stringFlag("into");
-        let tests = stringFlag("tests");
-        let dryRun = Stdlib_Option.isSome(flags["dry-run"]);
-        if (into === undefined) {
-          return fail("--into and --tests are both required.\n\n" + usage);
-        }
-        if (tests === undefined) {
-          return fail("--into and --tests are both required.\n\n" + usage);
-        }
-        let scaffoldModule = Stdlib_Option.getOr(Stdlib_Array.last(traitPackage.split("/")), "").replace("trait-", "").split("-").map(part => part.charAt(0).toUpperCase() + part.slice(1, part.length)).join("") + "_Scaffold";
-        let specifier = traitPackage + `/src/` + scaffoldModule + `.res.mjs`;
-        let modulePath;
-        try {
-          modulePath = Nodemodule.createRequire(process.cwd() + "/index.js").resolve(specifier);
-        } catch (exn) {
-          modulePath = specifier;
-        }
-        let scaffold;
-        try {
-          scaffold = await import(Nodeurl.pathToFileURL(modulePath).href);
-        } catch (exn$1) {
-          fail(traitPackage + ` ships no scaffold (looked for ` + specifier + `).\n  Not every trait has one — a trait whose graft is all patches has nothing to write.\n  Write the graft by hand instead; its README says what the host must declare.`);
-          scaffold = undefined;
-        }
-        let listFields = arrayFieldNames(scaffold.configSchema);
-        let raw = {};
-        Object.entries(flags).forEach(param => {
-          let value = param[1];
-          let key = param[0];
-          let match = listFields.includes(key);
-          let match$1 = Stdlib_JSON.Decode.string(value);
-          if (match && match$1 !== undefined) {
-            raw[key] = splitList(match$1);
-          } else {
-            raw[key] = value;
-          }
-        });
-        [
-          "into",
-          "tests",
-          "dry-run"
-        ].forEach(k => Stdlib_Dict.$$delete(raw, k));
-        let config;
-        try {
-          config = Util_Sury$Reventless.fromJson(raw, scaffold.configSchema);
-        } catch (raw_exn) {
-          let exn$2 = Primitive_exceptions.internalToException(raw_exn);
-          fail(traitPackage + ` refused this config: ` + Util_Sury$Reventless.exnMessage(exn$2, undefined) + `\n  Every --key is a field of the trait's own config; it decides what it needs.`);
-          config = undefined;
-        }
-        let match = scaffold.emit(config, into, tests);
-        let patches = match.patches;
-        match.files.forEach(param => {
-          let contents = param.contents;
-          let path = param.path;
-          if (dryRun) {
-            console.log(`Would write: ` + path + ` (` + contents.split("\n").length.toString() + ` lines)`);
-          } else if (Nodefs.existsSync(path)) {
-            console.log(`Skipped (exists): ` + path);
-          } else {
-            Nodefs.mkdirSync(Nodepath.dirname(path), {
-              recursive: true
-            });
-            Nodefs.writeFileSync(path, contents, "utf8");
-            console.log(`Wrote: ` + path);
-          }
-        });
-        if (patches.length !== 0) {
-          console.log("");
-          console.log("── Paste these; they go into files you already own ──────────────");
-          patches.forEach(param => {
-            console.log("");
-            console.log(`# ` + param.into + ` — ` + param.at);
-            console.log(param.contents);
-          });
-          console.log("");
-          console.log("Printed rather than written: placing an arm in an existing ordered `switch`\nis an AST operation, and a text splice into the wrong arm is a bug the\ncompiler cannot see.");
-        }
-        process.exit(0);
-        return;
+function parseArgs(argv) {
+  return Stdlib_Result.flatMap(Stdlib_Result.flatMap(CliArgs$Reventless.parse([
+    "into",
+    "tests"
+  ], ["dry-run"], undefined, true, argv), a => CliArgs$Reventless.atMost(a, 1)), a => {
+    let match = CliArgs$Reventless.positionals(a)[0];
+    let match$1 = CliArgs$Reventless.string(a, "into");
+    let match$2 = CliArgs$Reventless.string(a, "tests");
+    if (match === undefined) {
+      return {
+        TAG: "Error",
+        _0: "<trait-package> is required."
+      };
     }
-  }
-  console.log(usage);
-  process.exit(argv.length === 0 ? 1 : 0);
+    if (match === "") {
+      return {
+        TAG: "Error",
+        _0: "<trait-package> is required."
+      };
+    }
+    if (match$1 === undefined) {
+      return {
+        TAG: "Error",
+        _0: "--into and --tests are both required."
+      };
+    }
+    if (match$2 === undefined) {
+      return {
+        TAG: "Error",
+        _0: "--into and --tests are both required."
+      };
+    }
+    let fields = {};
+    CliArgs$Reventless.pairs(a).forEach(param => {
+      let value = param[1];
+      let tmp;
+      tmp = typeof value !== "object" ? true : value._0;
+      fields[param[0]] = tmp;
+    });
+    return {
+      TAG: "Ok",
+      _0: {
+        traitPackage: match,
+        into: match$1,
+        tests: match$2,
+        dryRun: CliArgs$Reventless.bool(a, "dry-run"),
+        fields: fields
+      }
+    };
+  });
 }
 
-await main();
+let cli = {
+  bin: "graft-trait",
+  usage: usage,
+  parse: parseArgs
+};
+
+function main() {
+  return CliArgs$Reventless.run(cli, undefined, undefined, async param => {
+    let dryRun = param.dryRun;
+    let traitPackage = param.traitPackage;
+    let scaffoldModule = Stdlib_Option.getOr(Stdlib_Array.last(traitPackage.split("/")), "").replace("trait-", "").split("-").map(part => part.charAt(0).toUpperCase() + part.slice(1, part.length)).join("") + "_Scaffold";
+    let specifier = traitPackage + `/src/` + scaffoldModule + `.res.mjs`;
+    let modulePath;
+    try {
+      modulePath = Nodemodule.createRequire(process.cwd() + "/index.js").resolve(specifier);
+    } catch (exn) {
+      modulePath = specifier;
+    }
+    let scaffold;
+    try {
+      scaffold = await import(Nodeurl.pathToFileURL(modulePath).href);
+    } catch (exn$1) {
+      fail(traitPackage + ` ships no scaffold (looked for ` + specifier + `).\n  Not every trait has one — a trait whose graft is all patches has nothing to write.\n  Write the graft by hand instead; its README says what the host must declare.`);
+      scaffold = undefined;
+    }
+    let listFields = arrayFieldNames(scaffold.configSchema);
+    let raw = {};
+    Object.entries(param.fields).forEach(param => {
+      let value = param[1];
+      let key = param[0];
+      let match = listFields.includes(key);
+      let match$1 = Stdlib_JSON.Decode.string(value);
+      if (match && match$1 !== undefined) {
+        raw[key] = splitList(match$1);
+      } else {
+        raw[key] = value;
+      }
+    });
+    let config;
+    try {
+      config = Util_Sury$Reventless.fromJson(raw, scaffold.configSchema);
+    } catch (raw_exn) {
+      let exn$2 = Primitive_exceptions.internalToException(raw_exn);
+      fail(traitPackage + ` refused this config: ` + Util_Sury$Reventless.exnMessage(exn$2, undefined) + `\n  Every --key is a field of the trait's own config; it decides what it needs.`);
+      config = undefined;
+    }
+    let match = scaffold.emit(config, param.into, param.tests);
+    let patches = match.patches;
+    match.files.forEach(param => {
+      let contents = param.contents;
+      let path = param.path;
+      if (dryRun) {
+        console.log(`Would write: ` + path + ` (` + contents.split("\n").length.toString() + ` lines)`);
+      } else if (Nodefs.existsSync(path)) {
+        console.log(`Skipped (exists): ` + path);
+      } else {
+        Nodefs.mkdirSync(Nodepath.dirname(path), {
+          recursive: true
+        });
+        Nodefs.writeFileSync(path, contents, "utf8");
+        console.log(`Wrote: ` + path);
+      }
+    });
+    if (patches.length !== 0) {
+      console.log("");
+      console.log("── Paste these; they go into files you already own ──────────────");
+      patches.forEach(param => {
+        console.log("");
+        console.log(`# ` + param.into + ` — ` + param.at);
+        console.log(param.contents);
+      });
+      console.log("");
+      console.log("Printed rather than written: placing an arm in an existing ordered `switch`\nis an AST operation, and a text splice into the wrong arm is a bug the\ncompiler cannot see.");
+    }
+    process.exit(0);
+  });
+}
 
 export {
   fail,
   usage,
-  parseFlags,
   splitList,
   arrayFieldNames,
+  parseArgs,
+  cli,
   main,
 }
-/*  Not a pure module */
+/* node:fs Not a pure module */

package/src/generator/PlatformGenerator.res

@@ -22,12 +22,28 @@ let asObject = (json: JSON.t): option<dict<JSON.t>> => json->JSON.Decode.object
 let stringAt = (obj: dict<JSON.t>, field: string): option<string> =>
   obj->Dict.get(field)->Option.flatMap(JSON.Decode.string)
 
-let () = {
-  let manifestArg = NodeProcess.argv->Array.get(2)->Option.getOr("")
-  if manifestArg == "" {
-    Console.error("Usage: generate-platform <deploy-manifest.yaml>")
-    NodeProcess.exit(1)
-  } else {
+let usage = `Usage: generate-platform <deploy-manifest.yaml>
+
+  Reads the plugins the deploy manifest lists, unions their committed
+  capabilities.json manifests, and writes the platform's
+  src/PlatformCapabilities.res.`
+
+type args = {manifest: string}
+
+let parseArgs = (argv: array<string>): result<args, string> =>
+  CliArgs.parse(argv)
+  ->Result.flatMap(a => a->CliArgs.atMost(1))
+  ->Result.flatMap(a =>
+    switch a->CliArgs.positionals->Array.get(0) {
+    | None | Some("") => Error("<deploy-manifest.yaml> is required.")
+    | Some(manifest) => Ok({manifest: manifest})
+    }
+  )
+
+let cli: CliArgs.cli<args> = {bin: "generate-platform", usage, parse: parseArgs}
+
+let main = () =>
+  CliArgs.run(cli, async ({manifest: manifestArg}) => {
     let manifestPath = NodePath.resolve([manifestArg])
     if !NodeFs.existsSync(manifestPath) {
       fail(`${manifestPath} not found`)
@@ -52,16 +68,18 @@ let () = {
       ->Option.flatMap(m => m->Dict.get("plugins"))
       ->Option.flatMap(JSON.Decode.array)
       ->Option.map(entries =>
-        entries->Array.filterMap(entry => {
-          let obj = entry->asObject
-          switch (
-            obj->Option.flatMap(o => o->stringAt("name")),
-            obj->Option.flatMap(o => o->stringAt("path")),
-          ) {
-          | (Some(name), Some(path)) => Some((name, path))
-          | _ => None
-          }
-        })
+        entries->Array.filterMap(
+          entry => {
+            let obj = entry->asObject
+            switch (
+              obj->Option.flatMap(o => o->stringAt("name")),
+              obj->Option.flatMap(o => o->stringAt("path")),
+            ) {
+            | (Some(name), Some(path)) => Some((name, path))
+            | _ => None
+            }
+          },
+        )
       )
 
     switch (platformPath, plugins) {
@@ -89,20 +107,22 @@ let () = {
               []
             }
           | Manifests(manifests) =>
-            manifests->Array.map(({path, via}) => {
-              Console.log(
-                `Read: ${pluginName} — ${path} (via ${PlatformManifests.describeVia(via)})`,
-              )
-              let manifest = try NodeFs.readFileSync(path)
-              ->JSON.parseOrThrow
-              ->S.parseOrThrow(~to=CapabilityManifest.schema) catch {
-              | _ => {
-                  fail(`could not parse ${path} as a capability manifest`)
-                  ({capabilities: []}: CapabilityManifest.t)
+            manifests->Array.map(
+              ({path, via}) => {
+                Console.log(
+                  `Read: ${pluginName} — ${path} (via ${PlatformManifests.describeVia(via)})`,
+                )
+                let manifest = try NodeFs.readFileSync(path)
+                ->JSON.parseOrThrow
+                ->S.parseOrThrow(~to=CapabilityManifest.schema) catch {
+                | _ => {
+                    fail(`could not parse ${path} as a capability manifest`)
+                    ({capabilities: []}: CapabilityManifest.t)
+                  }
                 }
-              }
-              ({pluginName, manifest}: PlatformCodegen.pluginManifest)
-            })
+                ({pluginName, manifest}: PlatformCodegen.pluginManifest)
+              },
+            )
           }
         })
 
@@ -122,5 +142,4 @@ let () = {
       }
     | _ => fail(`${manifestPath} needs a \`platform.path\` and a \`plugins\` list with name + path`)
     }
-  }
-}
+  })

package/src/generator/PlatformGenerator.res.mjs

@@ -7,6 +7,8 @@ import * as Nodepath from "node:path";
 import * as Stdlib_JSON from "@rescript/runtime/lib/es6/Stdlib_JSON.js";
 import * as Stdlib_Array from "@rescript/runtime/lib/es6/Stdlib_Array.js";
 import * as Stdlib_Option from "@rescript/runtime/lib/es6/Stdlib_Option.js";
+import * as Stdlib_Result from "@rescript/runtime/lib/es6/Stdlib_Result.js";
+import * as CliArgs$Reventless from "../CliArgs.res.mjs";
 import * as PlatformCodegen$Reventless from "./PlatformCodegen.res.mjs";
 import * as PlatformManifests$Reventless from "./PlatformManifests.res.mjs";
 import * as CapabilityManifest$Reventless from "../components/CapabilityManifest.res.mjs";
@@ -24,91 +26,120 @@ function stringAt(obj, field) {
   return Stdlib_Option.flatMap(obj[field], Stdlib_JSON.Decode.string);
 }
 
-let manifestArg = Stdlib_Option.getOr(process.argv[2], "");
+let usage = `Usage: generate-platform <deploy-manifest.yaml>
 
-if (manifestArg === "") {
-  console.error("Usage: generate-platform <deploy-manifest.yaml>");
-  process.exit(1);
-} else {
-  let manifestPath = Nodepath.resolve(manifestArg);
-  if (!Nodefs.existsSync(manifestPath)) {
-    fail(manifestPath + ` not found`);
-  }
-  let manifestDir = Nodepath.dirname(manifestPath);
-  let deployManifest;
-  try {
-    deployManifest = Yaml.parse(Nodefs.readFileSync(manifestPath, "utf8"));
-  } catch (exn) {
-    fail(`could not parse ` + manifestPath + ` as YAML`);
-    deployManifest = null;
-  }
-  let platformPath = Stdlib_Option.flatMap(Stdlib_Option.flatMap(Stdlib_Option.flatMap(Stdlib_JSON.Decode.object(deployManifest), m => m["platform"]), asObject), p => stringAt(p, "path"));
-  let plugins = Stdlib_Option.map(Stdlib_Option.flatMap(Stdlib_Option.flatMap(Stdlib_JSON.Decode.object(deployManifest), m => m["plugins"]), Stdlib_JSON.Decode.array), entries => Stdlib_Array.filterMap(entries, entry => {
-    let obj = Stdlib_JSON.Decode.object(entry);
-    let match = Stdlib_Option.flatMap(obj, o => stringAt(o, "name"));
-    let match$1 = Stdlib_Option.flatMap(obj, o => stringAt(o, "path"));
-    if (match !== undefined && match$1 !== undefined) {
-      return [
-        match,
-        match$1
-      ];
-    }
-  }));
-  if (platformPath !== undefined) {
-    if (plugins !== undefined) {
-      let pluginManifests = plugins.flatMap(param => {
-        let pluginName = param[0];
-        let pluginDir = Nodepath.resolve(manifestDir, param[1]);
-        if (!Nodefs.existsSync(pluginDir)) {
-          fail(`plugin "` + pluginName + `" points at ` + pluginDir + `, which does not exist`);
-        }
-        let manifests = PlatformManifests$Reventless.resolve(undefined, pluginDir);
-        if (typeof manifests !== "object") {
-          console.log(`Skipped: ` + pluginName + ` (` + pluginDir + `) — no plugin composition`);
-          return [];
-        }
-        if (manifests.TAG === "Manifests") {
-          return manifests._0.map(param => {
-            let path = param.path;
-            console.log(`Read: ` + pluginName + ` — ` + path + ` (via ` + PlatformManifests$Reventless.describeVia(param.via) + `)`);
-            let manifest;
-            try {
-              manifest = Sury.parseOrThrow(JSON.parse(Nodefs.readFileSync(path, "utf8")), CapabilityManifest$Reventless.schema);
-            } catch (exn) {
-              fail(`could not parse ` + path + ` as a capability manifest`);
-              manifest = {
-                capabilities: []
-              };
-            }
-            return {
-              pluginName: pluginName,
-              manifest: manifest
-            };
-          });
+  Reads the plugins the deploy manifest lists, unions their committed
+  capabilities.json manifests, and writes the platform's
+  src/PlatformCapabilities.res.`;
+
+function parseArgs(argv) {
+  return Stdlib_Result.flatMap(Stdlib_Result.flatMap(CliArgs$Reventless.parse(undefined, undefined, undefined, undefined, argv), a => CliArgs$Reventless.atMost(a, 1)), a => {
+    let manifest = CliArgs$Reventless.positionals(a)[0];
+    if (manifest !== undefined && manifest !== "") {
+      return {
+        TAG: "Ok",
+        _0: {
+          manifest: manifest
         }
-        let match = manifests._0;
-        fail(`no capabilities.json found for plugin "` + pluginName + `" (` + pluginDir + `) — build the plugin first; its build emits src/capabilities.json beside Plugin.res ` + (`(` + match.evidence + `; expected ` + match.expected + `)`));
+      };
+    } else {
+      return {
+        TAG: "Error",
+        _0: "<deploy-manifest.yaml> is required."
+      };
+    }
+  });
+}
+
+let cli = {
+  bin: "generate-platform",
+  usage: usage,
+  parse: parseArgs
+};
+
+function main() {
+  return CliArgs$Reventless.run(cli, undefined, undefined, async param => {
+    let manifestPath = Nodepath.resolve(param.manifest);
+    if (!Nodefs.existsSync(manifestPath)) {
+      fail(manifestPath + ` not found`);
+    }
+    let manifestDir = Nodepath.dirname(manifestPath);
+    let deployManifest;
+    try {
+      deployManifest = Yaml.parse(Nodefs.readFileSync(manifestPath, "utf8"));
+    } catch (exn) {
+      fail(`could not parse ` + manifestPath + ` as YAML`);
+      deployManifest = null;
+    }
+    let platformPath = Stdlib_Option.flatMap(Stdlib_Option.flatMap(Stdlib_Option.flatMap(Stdlib_JSON.Decode.object(deployManifest), m => m["platform"]), asObject), p => stringAt(p, "path"));
+    let plugins = Stdlib_Option.map(Stdlib_Option.flatMap(Stdlib_Option.flatMap(Stdlib_JSON.Decode.object(deployManifest), m => m["plugins"]), Stdlib_JSON.Decode.array), entries => Stdlib_Array.filterMap(entries, entry => {
+      let obj = Stdlib_JSON.Decode.object(entry);
+      let match = Stdlib_Option.flatMap(obj, o => stringAt(o, "name"));
+      let match$1 = Stdlib_Option.flatMap(obj, o => stringAt(o, "path"));
+      if (match !== undefined && match$1 !== undefined) {
+        return [
+          match,
+          match$1
+        ];
+      }
+    }));
+    if (platformPath === undefined) {
+      return fail(manifestPath + ` needs a \`platform.path\` and a \`plugins\` list with name + path`);
+    }
+    if (plugins === undefined) {
+      return fail(manifestPath + ` needs a \`platform.path\` and a \`plugins\` list with name + path`);
+    }
+    let pluginManifests = plugins.flatMap(param => {
+      let pluginName = param[0];
+      let pluginDir = Nodepath.resolve(manifestDir, param[1]);
+      if (!Nodefs.existsSync(pluginDir)) {
+        fail(`plugin "` + pluginName + `" points at ` + pluginDir + `, which does not exist`);
+      }
+      let manifests = PlatformManifests$Reventless.resolve(undefined, pluginDir);
+      if (typeof manifests !== "object") {
+        console.log(`Skipped: ` + pluginName + ` (` + pluginDir + `) — no plugin composition`);
         return [];
-      });
-      let message = PlatformCodegen$Reventless.render(pluginManifests);
-      if (message.TAG === "Ok") {
-        let outputPath = Nodepath.resolve(manifestDir, platformPath, "src", "PlatformCapabilities.res");
-        Nodefs.writeFileSync(outputPath, message._0, "utf8");
-        console.log("Generated: " + outputPath);
-      } else {
-        fail(message._0);
       }
-    } else {
-      fail(manifestPath + ` needs a \`platform.path\` and a \`plugins\` list with name + path`);
+      if (manifests.TAG === "Manifests") {
+        return manifests._0.map(param => {
+          let path = param.path;
+          console.log(`Read: ` + pluginName + ` — ` + path + ` (via ` + PlatformManifests$Reventless.describeVia(param.via) + `)`);
+          let manifest;
+          try {
+            manifest = Sury.parseOrThrow(JSON.parse(Nodefs.readFileSync(path, "utf8")), CapabilityManifest$Reventless.schema);
+          } catch (exn) {
+            fail(`could not parse ` + path + ` as a capability manifest`);
+            manifest = {
+              capabilities: []
+            };
+          }
+          return {
+            pluginName: pluginName,
+            manifest: manifest
+          };
+        });
+      }
+      let match = manifests._0;
+      fail(`no capabilities.json found for plugin "` + pluginName + `" (` + pluginDir + `) — build the plugin first; its build emits src/capabilities.json beside Plugin.res ` + (`(` + match.evidence + `; expected ` + match.expected + `)`));
+      return [];
+    });
+    let message = PlatformCodegen$Reventless.render(pluginManifests);
+    if (message.TAG !== "Ok") {
+      return fail(message._0);
     }
-  } else {
-    fail(manifestPath + ` needs a \`platform.path\` and a \`plugins\` list with name + path`);
-  }
+    let outputPath = Nodepath.resolve(manifestDir, platformPath, "src", "PlatformCapabilities.res");
+    Nodefs.writeFileSync(outputPath, message._0, "utf8");
+    console.log("Generated: " + outputPath);
+  });
 }
 
 export {
   fail,
   asObject,
   stringAt,
+  usage,
+  parseArgs,
+  cli,
+  main,
 }
-/* manifestArg Not a pure module */
+/* sury Not a pure module */

package/src/generator/PluginGenerator.res

@@ -1,32 +1,33 @@
 // Entry point for the plugin generator.
-// Usage: generate-plugin <srcDir>
-//        generate-plugin --aws <Namespace> <srcDir>
-
-let () = {
-  let argv2 = NodeProcess.argv->Array.get(2)->Option.getOr("")
-  let argv3 = NodeProcess.argv->Array.get(3)->Option.getOr("")
-  let argv4 = NodeProcess.argv->Array.get(4)->Option.getOr("")
-
-  let (variant, srcDirArg) = if argv2 === "--aws" {
-    if argv3 !== "" && argv4 !== "" {
-      (Config.Aws({compositionNamespace: argv3}), argv4)
-    } else {
-      Console.error("Usage: generate-plugin --aws <Namespace> <srcDir>")
-      (Config.Composition, "")
-    }
-  } else {
-    (Config.Composition, argv2)
-  }
-
-  if srcDirArg === "" {
-    if argv2 !== "--aws" {
-      Console.error("Usage: generate-plugin <srcDir>")
-      Console.error("       generate-plugin --aws <Namespace> <srcDir>")
+
+let usage = `Usage: generate-plugin [--aws <Namespace>] <srcDir>
+
+  <srcDir>           the plugin's sources; Plugin.res is written into it
+  --aws <Namespace>  generate an -aws package instead: Plugin.res and Main.res
+                     are written into ./src, composing the plugin whose sources
+                     are <srcDir> under <Namespace>`
+
+type args = {variant: Config.variant, srcDir: string}
+
+let parseArgs = (argv: array<string>): result<args, string> =>
+  CliArgs.parse(~strings=["aws"], argv)
+  ->Result.flatMap(a => a->CliArgs.atMost(1))
+  ->Result.flatMap(a =>
+    switch (a->CliArgs.string("aws"), a->CliArgs.positionals->Array.get(0)) {
+    | (Some(""), _) => Error("--aws needs a value")
+    | (_, None | Some("")) => Error("<srcDir> is required.")
+    | (None, Some(srcDir)) => Ok({variant: Config.Composition, srcDir})
+    | (Some(compositionNamespace), Some(srcDir)) =>
+      Ok({variant: Config.Aws({compositionNamespace: compositionNamespace}), srcDir})
     }
-    // Exit non-zero on a usage error so `prebuild` (and CI) actually fail
-    // instead of continuing green with no Plugin.res generated.
-    NodeProcess.exit(1)
-  } else {
+  )
+
+let cli: CliArgs.cli<args> = {bin: "generate-plugin", usage, parse: parseArgs}
+
+// A usage mistake exits non-zero, so `prebuild` (and CI) fail instead of
+// continuing green with no Plugin.res generated.
+let main = () =>
+  CliArgs.run(cli, async ({variant, srcDir: srcDirArg}) => {
     // Resolve to absolute path (handles relative paths and trailing slashes)
     let srcDir = NodePath.resolve([srcDirArg])
 
@@ -55,5 +56,4 @@ let () = {
       NodeFs.writeFileSync(mainPath, mainSource)
       Console.log("Generated: " ++ mainPath)
     }
-  }
-}
+  })