@rse/ase 0.0.6 → 0.0.8

package/dst/ase-agent-base.js

@@ -7,37 +7,28 @@
 export const createAgentCommandModule = (category, description, subCommands) => {
     /*  create sub-command handler  */
     const createSubCommandHandler = (subCommand) => {
-        return (argv) => {
-            if (argv.debug)
+        return (_opts, cmd) => {
+            const opts = cmd.optsWithGlobals();
+            if (opts.debug)
                 console.log(`DEBUG: agent ${category} ${subCommand} command`);
-            if (argv.verbose)
+            if (opts.verbose)
                 console.log(`VERBOSE: executing agent ${category} ${subCommand}...`);
             console.log(`Executing agent ${category} ${subCommand}...`);
             /*  TODO: implement agent ${category} sub-command logic  */
         };
     };
-    return {
-        command: `${category} <subcommand>`,
-        describe: `Execute ${description} agent operations`,
-        builder: (yargs) => {
-            let builder = yargs
-                .option("verbose", {
-                alias: "v",
-                type: "boolean",
-                describe: "Enable verbose output",
-                default: false
-            })
-                .demandCommand(1, `You need to specify a ${category} subcommand`);
-            /*  register all sub-commands  */
-            for (const subCmd of subCommands) {
-                builder = builder.command(subCmd, `Execute agent ${category} ${subCmd} operation`, () => { }, createSubCommandHandler(subCmd));
-            }
-            return builder;
-        },
-        handler: (argv) => {
-            /*  this handler is not called when sub-commands are used  */
-            if (argv.debug)
-                console.log(`DEBUG: agent ${category} command (no subcommand)`);
+    return (parent) => {
+        const agent = parent
+            .command(`${category}`)
+            .description(`Execute ${description} agent operations`)
+            .option("-v, --verbose", "Enable verbose output", false);
+        /*  register all sub-commands  */
+        for (const subCmd of subCommands) {
+            agent
+                .command(subCmd)
+                .description(`Execute agent ${category} ${subCmd} operation`)
+                .action(createSubCommandHandler(subCmd));
         }
+        return agent;
     };
 };

package/dst/ase-agent-biz.js

@@ -12,38 +12,29 @@ const bizSubCommands = [
 ];
 /*  create sub-command handler  */
 const createSubCommandHandler = (subCommand) => {
-    return (argv) => {
-        if (argv.debug)
+    return (_opts, cmd) => {
+        const opts = cmd.optsWithGlobals();
+        if (opts.debug)
             console.log(`DEBUG: agent biz ${subCommand} command`);
-        if (argv.verbose)
+        if (opts.verbose)
             console.log(`VERBOSE: executing agent biz ${subCommand}...`);
         console.log(`Executing agent biz ${subCommand}...`);
         /*  TODO: implement agent biz sub-command logic  */
     };
 };
-/*  create and export biz command module  */
-const bizCommand = {
-    command: "biz <subcommand>",
-    describe: "Execute business agent operations",
-    builder: (yargs) => {
-        let builder = yargs
-            .option("verbose", {
-            alias: "v",
-            type: "boolean",
-            describe: "Enable verbose output",
-            default: false
-        })
-            .demandCommand(1, "You need to specify a biz subcommand");
-        /*  register all sub-commands  */
-        for (const subCmd of bizSubCommands) {
-            builder = builder.command(subCmd, `Execute agent biz ${subCmd} operation`, () => { }, createSubCommandHandler(subCmd));
-        }
-        return builder;
-    },
-    handler: (argv) => {
-        /*  this handler is not called when sub-commands are used  */
-        if (argv.debug)
-            console.log("DEBUG: agent biz command (no subcommand)");
+/*  register biz command on the given parent  */
+const registerBizCommand = (parent) => {
+    const biz = parent
+        .command("biz")
+        .description("Execute business agent operations")
+        .option("-v, --verbose", "Enable verbose output", false);
+    /*  register all sub-commands  */
+    for (const subCmd of bizSubCommands) {
+        biz
+            .command(subCmd)
+            .description(`Execute agent biz ${subCmd} operation`)
+            .action(createSubCommandHandler(subCmd));
     }
+    return biz;
 };
-export default bizCommand;
+export default registerBizCommand;

package/dst/ase-agent-dev.js

@@ -12,38 +12,29 @@ const devSubCommands = [
 ];
 /*  create sub-command handler  */
 const createSubCommandHandler = (subCommand) => {
-    return (argv) => {
-        if (argv.debug)
+    return (_opts, cmd) => {
+        const opts = cmd.optsWithGlobals();
+        if (opts.debug)
             console.log(`DEBUG: agent dev ${subCommand} command`);
-        if (argv.verbose)
+        if (opts.verbose)
             console.log(`VERBOSE: executing agent dev ${subCommand}...`);
         console.log(`Executing agent dev ${subCommand}...`);
         /*  TODO: implement agent dev sub-command logic  */
     };
 };
-/*  create and export dev command module  */
-const devCommand = {
-    command: "dev <subcommand>",
-    describe: "Execute development agent operations",
-    builder: (yargs) => {
-        let builder = yargs
-            .option("verbose", {
-            alias: "v",
-            type: "boolean",
-            describe: "Enable verbose output",
-            default: false
-        })
-            .demandCommand(1, "You need to specify a dev subcommand");
-        /*  register all sub-commands  */
-        for (const subCmd of devSubCommands) {
-            builder = builder.command(subCmd, `Execute agent dev ${subCmd} operation`, () => { }, createSubCommandHandler(subCmd));
-        }
-        return builder;
-    },
-    handler: (argv) => {
-        /*  this handler is not called when sub-commands are used  */
-        if (argv.debug)
-            console.log("DEBUG: agent dev command (no subcommand)");
+/*  register dev command on the given parent  */
+const registerDevCommand = (parent) => {
+    const dev = parent
+        .command("dev")
+        .description("Execute development agent operations")
+        .option("-v, --verbose", "Enable verbose output", false);
+    /*  register all sub-commands  */
+    for (const subCmd of devSubCommands) {
+        dev
+            .command(subCmd)
+            .description(`Execute agent dev ${subCmd} operation`)
+            .action(createSubCommandHandler(subCmd));
     }
+    return dev;
 };
-export default devCommand;
+export default registerDevCommand;

package/dst/ase-agent-ops.js

@@ -12,38 +12,29 @@ const opsSubCommands = [
 ];
 /*  create sub-command handler  */
 const createSubCommandHandler = (subCommand) => {
-    return (argv) => {
-        if (argv.debug)
+    return (_opts, cmd) => {
+        const opts = cmd.optsWithGlobals();
+        if (opts.debug)
             console.log(`DEBUG: agent ops ${subCommand} command`);
-        if (argv.verbose)
+        if (opts.verbose)
             console.log(`VERBOSE: executing agent ops ${subCommand}...`);
         console.log(`Executing agent ops ${subCommand}...`);
         /*  TODO: implement agent ops sub-command logic  */
     };
 };
-/*  create and export ops command module  */
-const opsCommand = {
-    command: "ops <subcommand>",
-    describe: "Execute operations agent operations",
-    builder: (yargs) => {
-        let builder = yargs
-            .option("verbose", {
-            alias: "v",
-            type: "boolean",
-            describe: "Enable verbose output",
-            default: false
-        })
-            .demandCommand(1, "You need to specify an ops subcommand");
-        /*  register all sub-commands  */
-        for (const subCmd of opsSubCommands) {
-            builder = builder.command(subCmd, `Execute agent ops ${subCmd} operation`, () => { }, createSubCommandHandler(subCmd));
-        }
-        return builder;
-    },
-    handler: (argv) => {
-        /*  this handler is not called when sub-commands are used  */
-        if (argv.debug)
-            console.log("DEBUG: agent ops command (no subcommand)");
+/*  register ops command on the given parent  */
+const registerOpsCommand = (parent) => {
+    const ops = parent
+        .command("ops")
+        .description("Execute operations agent operations")
+        .option("-v, --verbose", "Enable verbose output", false);
+    /*  register all sub-commands  */
+    for (const subCmd of opsSubCommands) {
+        ops
+            .command(subCmd)
+            .description(`Execute agent ops ${subCmd} operation`)
+            .action(createSubCommandHandler(subCmd));
     }
+    return ops;
 };
-export default opsCommand;
+export default registerOpsCommand;

package/dst/ase-agent-prd.js

@@ -12,38 +12,29 @@ const prdSubCommands = [
 ];
 /*  create sub-command handler  */
 const createSubCommandHandler = (subCommand) => {
-    return (argv) => {
-        if (argv.debug)
+    return (_opts, cmd) => {
+        const opts = cmd.optsWithGlobals();
+        if (opts.debug)
             console.log(`DEBUG: agent prd ${subCommand} command`);
-        if (argv.verbose)
+        if (opts.verbose)
             console.log(`VERBOSE: executing agent prd ${subCommand}...`);
         console.log(`Executing agent prd ${subCommand}...`);
         /*  TODO: implement agent prd sub-command logic  */
     };
 };
-/*  create and export prd command module  */
-const prdCommand = {
-    command: "prd <subcommand>",
-    describe: "Execute production agent operations",
-    builder: (yargs) => {
-        let builder = yargs
-            .option("verbose", {
-            alias: "v",
-            type: "boolean",
-            describe: "Enable verbose output",
-            default: false
-        })
-            .demandCommand(1, "You need to specify a prd subcommand");
-        /*  register all sub-commands  */
-        for (const subCmd of prdSubCommands) {
-            builder = builder.command(subCmd, `Execute agent prd ${subCmd} operation`, () => { }, createSubCommandHandler(subCmd));
-        }
-        return builder;
-    },
-    handler: (argv) => {
-        /*  this handler is not called when sub-commands are used  */
-        if (argv.debug)
-            console.log("DEBUG: agent prd command (no subcommand)");
+/*  register prd command on the given parent  */
+const registerPrdCommand = (parent) => {
+    const prd = parent
+        .command("prd")
+        .description("Execute production agent operations")
+        .option("-v, --verbose", "Enable verbose output", false);
+    /*  register all sub-commands  */
+    for (const subCmd of prdSubCommands) {
+        prd
+            .command(subCmd)
+            .description(`Execute agent prd ${subCmd} operation`)
+            .action(createSubCommandHandler(subCmd));
     }
+    return prd;
 };
-export default prdCommand;
+export default registerPrdCommand;

package/dst/ase-agent-prj.js

@@ -12,38 +12,29 @@ const prjSubCommands = [
 ];
 /*  create sub-command handler  */
 const createSubCommandHandler = (subCommand) => {
-    return (argv) => {
-        if (argv.debug)
+    return (_opts, cmd) => {
+        const opts = cmd.optsWithGlobals();
+        if (opts.debug)
             console.log(`DEBUG: agent prj ${subCommand} command`);
-        if (argv.verbose)
+        if (opts.verbose)
             console.log(`VERBOSE: executing agent prj ${subCommand}...`);
         console.log(`Executing agent prj ${subCommand}...`);
         /*  TODO: implement agent prj sub-command logic  */
     };
 };
-/*  create and export prj command module  */
-const prjCommand = {
-    command: "prj <subcommand>",
-    describe: "Execute project agent operations",
-    builder: (yargs) => {
-        let builder = yargs
-            .option("verbose", {
-            alias: "v",
-            type: "boolean",
-            describe: "Enable verbose output",
-            default: false
-        })
-            .demandCommand(1, "You need to specify a prj subcommand");
-        /*  register all sub-commands  */
-        for (const subCmd of prjSubCommands) {
-            builder = builder.command(subCmd, `Execute agent prj ${subCmd} operation`, () => { }, createSubCommandHandler(subCmd));
-        }
-        return builder;
-    },
-    handler: (argv) => {
-        /*  this handler is not called when sub-commands are used  */
-        if (argv.debug)
-            console.log("DEBUG: agent prj command (no subcommand)");
+/*  register prj command on the given parent  */
+const registerPrjCommand = (parent) => {
+    const prj = parent
+        .command("prj")
+        .description("Execute project agent operations")
+        .option("-v, --verbose", "Enable verbose output", false);
+    /*  register all sub-commands  */
+    for (const subCmd of prjSubCommands) {
+        prj
+            .command(subCmd)
+            .description(`Execute agent prj ${subCmd} operation`)
+            .action(createSubCommandHandler(subCmd));
     }
+    return prj;
 };
-export default prjCommand;
+export default registerPrjCommand;

package/dst/ase-agent.js

@@ -3,33 +3,23 @@
 **  Copyright (c) 2025-2026 Dr. Ralf S. Engelschall <rse@engelschall.com>
 **  Licensed under GPL 3.0 <https://spdx.org/licenses/GPL-3.0-only>
 */
-import bizCommand from "./ase-agent-biz.js";
-import devCommand from "./ase-agent-dev.js";
-import opsCommand from "./ase-agent-ops.js";
-import prdCommand from "./ase-agent-prd.js";
-import prjCommand from "./ase-agent-prj.js";
-const agentCommand = {
-    command: "agent <subcommand>",
-    describe: "Execute agent operations",
-    builder: (yargs) => {
-        return yargs
-            .option("verbose", {
-            alias: "v",
-            type: "boolean",
-            describe: "Enable verbose output",
-            default: false
-        })
-            .command(bizCommand)
-            .command(devCommand)
-            .command(opsCommand)
-            .command(prdCommand)
-            .command(prjCommand)
-            .demandCommand(1, "You need to specify an agent subcommand");
-    },
-    handler: (argv) => {
-        /*  this handler is not called when sub-commands are used  */
-        if (argv.debug)
-            console.log("DEBUG: agent command (no subcommand)");
-    }
+import registerBizCommand from "./ase-agent-biz.js";
+import registerDevCommand from "./ase-agent-dev.js";
+import registerOpsCommand from "./ase-agent-ops.js";
+import registerPrdCommand from "./ase-agent-prd.js";
+import registerPrjCommand from "./ase-agent-prj.js";
+/*  register agent command on the given program  */
+const registerAgentCommand = (program) => {
+    const agent = program
+        .command("agent")
+        .description("Execute agent operations")
+        .option("-v, --verbose", "Enable verbose output", false);
+    /*  register all agent sub-commands  */
+    registerBizCommand(agent);
+    registerDevCommand(agent);
+    registerOpsCommand(agent);
+    registerPrdCommand(agent);
+    registerPrjCommand(agent);
+    return agent;
 };
-export default agentCommand;
+export default registerAgentCommand;