@rse/ase 0.0.0

package/README.md

@@ -0,0 +1,37 @@
+
+$ npx @rse/ase init
+$ npx @rse/ase config agent.dev.llm.type=anthropic-claude-sonnet-4.5
+$ npx @rse/ase config agent.dev.llm.key=<foo>
+$ npx @rse/ase agent dev start
+
+Agents
+------
+
+- PRJ (Project)
+  Objective: Project Steering
+  Input: time, cost, scope
+  Output: tasks
+
+- PRD (Product)
+  Objective: Product Life-Cycle
+  Input: vision
+  Output: product roadmap
+
+- BIZ (Business)
+  Objective: Product Specification
+  Input: product roadmap
+  Output: requirements specification
+
+- ARC (Architecture)
+  Objective: Product Development
+  Input: requirements specification
+  Output: architecture description
+
+- DEV (Development)
+  Objective: Product Development
+  Input: requirements specification, architecture description
+  Output: source code, deployment units
+
+- OPS (Operations)
+  Objective: Solution Operations
+

package/bin/ase

@@ -0,0 +1,2 @@
+#!/usr/bin/env node
+import("../dst/ase.js")

package/dst/ase-agent-base.js

@@ -0,0 +1,43 @@
+/*
+**  Agentic Software Engineering (ASE)
+**  Copyright (c) 2025-2026 Dr. Ralf S. Engelschall <rse@engelschall.com>
+**  Licensed under GPL 3.0 <https://spdx.org/licenses/GPL-3.0-only>
+*/
+/*  create agent command module  */
+export const createAgentCommandModule = (category, description, subCommands) => {
+    /*  create sub-command handler  */
+    const createSubCommandHandler = (subCommand) => {
+        return (argv) => {
+            if (argv.debug)
+                console.log(`DEBUG: agent ${category} ${subCommand} command`);
+            if (argv.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)`);
+        }
+    };
+};

package/dst/ase-agent-biz.js

@@ -0,0 +1,49 @@
+/*
+**  Agentic Software Engineering (ASE)
+**  Copyright (c) 2025-2026 Dr. Ralf S. Engelschall <rse@engelschall.com>
+**  Licensed under GPL 3.0 <https://spdx.org/licenses/GPL-3.0-only>
+*/
+/*  biz sub-commands  */
+const bizSubCommands = [
+    "understand",
+    "ideate",
+    "explore",
+    "specify"
+];
+/*  create sub-command handler  */
+const createSubCommandHandler = (subCommand) => {
+    return (argv) => {
+        if (argv.debug)
+            console.log(`DEBUG: agent biz ${subCommand} command`);
+        if (argv.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)");
+    }
+};
+export default bizCommand;

package/dst/ase-agent-dev.js

@@ -0,0 +1,49 @@
+/*
+**  Agentic Software Engineering (ASE)
+**  Copyright (c) 2025-2026 Dr. Ralf S. Engelschall <rse@engelschall.com>
+**  Licensed under GPL 3.0 <https://spdx.org/licenses/GPL-3.0-only>
+*/
+/*  dev sub-commands  */
+const devSubCommands = [
+    "design",
+    "implement",
+    "build",
+    "verify"
+];
+/*  create sub-command handler  */
+const createSubCommandHandler = (subCommand) => {
+    return (argv) => {
+        if (argv.debug)
+            console.log(`DEBUG: agent dev ${subCommand} command`);
+        if (argv.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)");
+    }
+};
+export default devCommand;

package/dst/ase-agent-ops.js

@@ -0,0 +1,49 @@
+/*
+**  Agentic Software Engineering (ASE)
+**  Copyright (c) 2025-2026 Dr. Ralf S. Engelschall <rse@engelschall.com>
+**  Licensed under GPL 3.0 <https://spdx.org/licenses/GPL-3.0-only>
+*/
+/*  ops sub-commands  */
+const opsSubCommands = [
+    "deploy",
+    "integrate",
+    "operate",
+    "monitor"
+];
+/*  create sub-command handler  */
+const createSubCommandHandler = (subCommand) => {
+    return (argv) => {
+        if (argv.debug)
+            console.log(`DEBUG: agent ops ${subCommand} command`);
+        if (argv.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)");
+    }
+};
+export default opsCommand;

package/dst/ase-agent-prd.js

@@ -0,0 +1,49 @@
+/*
+**  Agentic Software Engineering (ASE)
+**  Copyright (c) 2025-2026 Dr. Ralf S. Engelschall <rse@engelschall.com>
+**  Licensed under GPL 3.0 <https://spdx.org/licenses/GPL-3.0-only>
+*/
+/*  prd sub-commands  */
+const prdSubCommands = [
+    "envision",
+    "configure",
+    "release",
+    "rollout"
+];
+/*  create sub-command handler  */
+const createSubCommandHandler = (subCommand) => {
+    return (argv) => {
+        if (argv.debug)
+            console.log(`DEBUG: agent prd ${subCommand} command`);
+        if (argv.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)");
+    }
+};
+export default prdCommand;

package/dst/ase-agent-prj.js

@@ -0,0 +1,49 @@
+/*
+**  Agentic Software Engineering (ASE)
+**  Copyright (c) 2025-2026 Dr. Ralf S. Engelschall <rse@engelschall.com>
+**  Licensed under GPL 3.0 <https://spdx.org/licenses/GPL-3.0-only>
+*/
+/*  prj sub-commands  */
+const prjSubCommands = [
+    "initiate",
+    "define",
+    "plan",
+    "steer"
+];
+/*  create sub-command handler  */
+const createSubCommandHandler = (subCommand) => {
+    return (argv) => {
+        if (argv.debug)
+            console.log(`DEBUG: agent prj ${subCommand} command`);
+        if (argv.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)");
+    }
+};
+export default prjCommand;

package/dst/ase-agent.js

@@ -0,0 +1,35 @@
+/*
+**  Agentic Software Engineering (ASE)
+**  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)");
+    }
+};
+export default agentCommand;

package/dst/ase-config.js

@@ -0,0 +1,36 @@
+/*
+**  Agentic Software Engineering (ASE)
+**  Copyright (c) 2025-2026 Dr. Ralf S. Engelschall <rse@engelschall.com>
+**  Licensed under GPL 3.0 <https://spdx.org/licenses/GPL-3.0-only>
+*/
+const configCommand = {
+    command: "config [assignment]",
+    describe: "Manage ASE configuration",
+    builder: (yargs) => {
+        return yargs
+            .positional("assignment", {
+            type: "string",
+            describe: "Configuration assignment (key=value) or key to query"
+        });
+    },
+    handler: (argv) => {
+        if (argv.debug)
+            console.log("DEBUG: config command", argv);
+        const assignment = argv.assignment;
+        if (!assignment) {
+            console.log("Listing all configuration...");
+            /*  TODO: implement configuration listing logic  */
+        }
+        else if (assignment.includes("=")) {
+            const [key, ...valueParts] = assignment.split("=");
+            const value = valueParts.join("=");
+            console.log(`Setting configuration: ${key} = ${value}`);
+            /*  TODO: implement configuration storage logic  */
+        }
+        else {
+            console.log(`Getting configuration: ${assignment}`);
+            /*  TODO: implement configuration retrieval logic  */
+        }
+    }
+};
+export default configCommand;

package/dst/ase-init.js

@@ -0,0 +1,19 @@
+/*
+**  Agentic Software Engineering (ASE)
+**  Copyright (c) 2025-2026 Dr. Ralf S. Engelschall <rse@engelschall.com>
+**  Licensed under GPL 3.0 <https://spdx.org/licenses/GPL-3.0-only>
+*/
+const initCommand = {
+    command: "init",
+    describe: "Initialize ASE configuration",
+    builder: (yargs) => {
+        return yargs;
+    },
+    handler: (argv) => {
+        if (argv.debug)
+            console.log("DEBUG: init command");
+        console.log("Initializing ASE configuration...");
+        /*  TODO: implement initialization logic  */
+    }
+};
+export default initCommand;

package/dst/ase.1

@@ -0,0 +1,25 @@
+.TH "ASE" "1" "April 2026" "" ""
+.SH "NAME"
+\fBase\fR - Agentic Software Engineering (ASE)
+.SH "SYNOPSIS"
+.P
+\fBase\fR \[lB]\fB-h\fR|\fB--help\fR\[rB] \[lB]\fB-V\fR|\fB--version\fR\[rB] \[lB]\fIcommand\fR \[lB]\fIoptions\fR \[lB]...\[rB]\[rB]\[rB] \[lB]\fIargs\fR \[lB]...\[rB]\[rB]\[rB]
+.SH "DESCRIPTION"
+.P
+\fBase\fR, \fIAgentic Software Engineeing (ASE)\fR, is a small command-line tool...
+.SH "OPTIONS"
+.P
+The following command-line options and arguments exist:
+.RS 0
+.IP \(bu 4
+\[lB]\fB-h\fR|\fB--help\fR\[rB]: Show program usage information only.
+.IP \(bu 4
+\[lB]\fB-V\fR|\fB--version\fR\[rB]: Show program version information only.
+.RE 0
+
+.SH "HISTORY"
+.P
+\fBase\fR was started to be developed in October 2025...
+.SH "AUTHOR"
+.P
+Dr. Ralf S. Engelschall \fI\(larse@engelschall.com\(ra\fR

package/dst/ase.js

@@ -0,0 +1,29 @@
+#!/usr/bin/env node
+/*
+**  Agentic Software Engineering (ASE)
+**  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 yargs from "yargs";
+import { hideBin } from "yargs/helpers";
+import initCommand from "./ase-init.js";
+import configCommand from "./ase-config.js";
+import agentCommand from "./ase-agent.js";
+/*  parse CLI arguments  */
+yargs(hideBin(process.argv))
+    .scriptName("ase")
+    .usage("Usage: $0 <command> [options]")
+    .option("debug", {
+    alias: "d",
+    type: "boolean",
+    describe: "Enable debug output",
+    default: false
+})
+    .command(initCommand)
+    .command(configCommand)
+    .command(agentCommand)
+    .demandCommand(1, "You need to specify a command")
+    .help()
+    .version()
+    .strict()
+    .parse();

package/package.json

@@ -0,0 +1,56 @@
+{
+    "name":                                 "@rse/ase",
+    "description":                          "Agentic Software Engineering (ASE)",
+    "publishConfig":                        { "access": "public" },
+    "keywords":                             [ "agentic", "ai", "coding", "tool", "cli", "software", "engineering" ],
+    "homepage":                             "http://github.com/rse/ase",
+    "repository":                           { "url": "git+https://github.com/rse/ase.git", "type": "git" },
+    "bugs":                                 { "url": "http://github.com/rse/ase/issues" },
+    "version":                              "0.0.0",
+    "license":                              "GPL-3.0-only",
+    "author": {
+        "name":                             "Dr. Ralf S. Engelschall",
+        "email":                            "rse@engelschall.com",
+        "url":                              "http://engelschall.com"
+    },
+    "type":                                 "module",
+    "bin":                                  { "ase": "bin/ase" },
+    "devDependencies": {
+        "eslint":                           "9.39.4",
+        "@eslint/js":                       "9.39.4",
+        "@typescript-eslint/parser":        "8.58.0",
+        "@typescript-eslint/eslint-plugin": "8.58.0",
+        "eslint-plugin-n":                  "17.24.0",
+        "eslint-plugin-promise":            "7.2.1",
+        "eslint-plugin-import":             "2.32.0",
+        "neostandard":                      "0.13.0",
+        "globals":                          "17.4.0",
+        "typescript":                       "6.0.2",
+
+        "@rse/stx":                         "1.1.4",
+        "nodemon":                          "3.1.14",
+        "shx":                              "0.4.0",
+        "remark-cli":                       "12.0.1",
+        "remark":                           "15.0.1",
+        "remark-man":                       "9.0.0",
+
+        "@types/node":                      "25.5.2",
+        "@types/yargs":                     "17.0.35"
+    },
+    "dependencies": {
+        "yargs":                            "18.0.0"
+    },
+    "engines": {
+        "npm":                              ">=10.0.0",
+        "node":                             ">=20.0.0"
+    },
+    "upd":                                  [ "!eslint", "!@eslint/js" ],
+    "files": [
+        "dst/**/*",
+        "bin/**/*",
+        "README.md"
+    ],
+    "scripts": {
+        "start":                            "stx -v4 -l warning -c etc/stx.conf"
+    }
+}