@rse/ase 0.0.13 → 0.0.14

package/dst/ase-diagram.js

@@ -0,0 +1,130 @@
+/*
+**  Agentic Software Engineering (ASE)
+**  Copyright (c) 2025-2026 Dr. Ralf S. Engelschall <rse@engelschall.com>, Matthias Brusdeylins <matthias@brusdeylins.info>
+**  Licensed under GPL 3.0 <https://spdx.org/licenses/GPL-3.0-only>
+*/
+import fs from "node:fs";
+import tty from "node:tty";
+import { renderMermaidASCII } from "beautiful-mermaid";
+/*  detect terminal color capability via /dev/tty  */
+/*  (stdout is piped to capture diagram output, so query the controlling terminal directly)  */
+const detectColorMode = () => {
+    let fd = -1;
+    try {
+        fd = fs.openSync("/dev/tty", "r+");
+        const stream = new tty.WriteStream(fd);
+        const depth = stream.getColorDepth();
+        stream.destroy();
+        if (depth >= 8)
+            return "ansi256";
+        if (depth >= 4)
+            return "ansi16";
+        return "none";
+    }
+    catch {
+        if (fd >= 0) {
+            try {
+                fs.closeSync(fd);
+            }
+            catch { /*  ignore  */ }
+        }
+        return "none";
+    }
+};
+/*  read stdin into a single string  */
+const readStdin = async () => {
+    const chunks = [];
+    for await (const chunk of process.stdin)
+        chunks.push(typeof chunk === "string" ? Buffer.from(chunk) : chunk);
+    return Buffer.concat(chunks).toString("utf8");
+};
+/*  command-line handling  */
+export default class DiagramCommand {
+    log;
+    constructor(log) {
+        this.log = log;
+    }
+    /*  register commands  */
+    register(program) {
+        program
+            .command("diagram")
+            .description("Render Mermaid source (stdin or --input) to aligned Unicode/ASCII diagram")
+            .option("-a, --ascii", "emit plain ASCII (+-|) instead of Unicode box-drawing", false)
+            .option("-c, --color-mode <mode>", "force particular color mode to use (\"none\", \"ansi16\", or \"ansi256\")")
+            .option("-i, --input <file>", "read Mermaid source from file instead of stdin")
+            .option("-x, --pad-x <n>", "horizontal spacing between nodes", "3")
+            .option("-y, --pad-y <n>", "vertical spacing between nodes", "3")
+            .option("-b, --pad-box <n>", "inner node box spacing", "1")
+            .action(async (opts) => {
+            /*  load Mermaid source  */
+            let src;
+            if (opts.input !== undefined)
+                src = fs.readFileSync(opts.input, "utf8");
+            else
+                src = await readStdin();
+            if (src.trim() === "") {
+                this.log.write("error", "diagram: empty Mermaid source");
+                process.exit(1);
+            }
+            /*  parse spacing options  */
+            const paddingX = Number.parseInt(opts.padX ?? "3", 10);
+            if (!Number.isFinite(paddingX)) {
+                this.log.write("error", "diagram: --pad-x must be integer");
+                process.exit(1);
+            }
+            const paddingY = Number.parseInt(opts.padY ?? "3", 10);
+            if (!Number.isFinite(paddingY)) {
+                this.log.write("error", "diagram: --pad-y must be integer");
+                process.exit(1);
+            }
+            const boxBorderPadding = Number.parseInt(opts.padBox ?? "1", 10);
+            if (!Number.isFinite(boxBorderPadding)) {
+                this.log.write("error", "diagram: --pad-box must be integer");
+                process.exit(1);
+            }
+            /*  determine color mode (explicit option overrides auto-detection)  */
+            let colorMode;
+            if (opts.colorMode === "none" || opts.colorMode === "ansi16" || opts.colorMode === "ansi256")
+                colorMode = opts.colorMode;
+            else if (opts.colorMode === undefined)
+                colorMode = detectColorMode();
+            else {
+                this.log.write("error", "diagram: --color-mode must be \"none\", \"ansi16\", or \"ansi256\"");
+                process.exit(1);
+            }
+            /*  render to ASCII  */
+            try {
+                const out = renderMermaidASCII(src, {
+                    useAscii: opts.ascii ?? false,
+                    paddingX,
+                    paddingY,
+                    boxBorderPadding,
+                    colorMode,
+                    theme: colorMode !== "none" ? {
+                        fg: "#000000",
+                        border: "#a0a0a0",
+                        junction: "#a0a0a0",
+                        arrow: "#404040",
+                        line: "#707070",
+                        corner: "#707070"
+                    } : {
+                        fg: "#000000",
+                        border: "#000000",
+                        junction: "#000000",
+                        arrow: "#000000",
+                        line: "#000000",
+                        corner: "#000000"
+                    }
+                });
+                process.stdout.write(out);
+                if (!out.endsWith("\n"))
+                    process.stdout.write("\n");
+            }
+            catch (err) {
+                const message = err instanceof Error ? err.message : String(err);
+                this.log.write("error", `diagram: render failed: ${message}`);
+                process.exit(1);
+            }
+        });
+    }
+}

package/dst/ase-hook.js

@@ -62,6 +62,36 @@ export default class HookCommand {
         }));
         return 0;
     }
+    /*  handler for "ase hook pre-tool-use"  */
+    doPreToolUse() {
+        /*  read tool invocation information  */
+        const stdin = fs.readFileSync(0, "utf8");
+        const input = stdin.trim() !== "" ? JSON.parse(stdin) : {};
+        /*  determine whether to auto-approve the tool invocation  */
+        const toolName = input.tool_name ?? "";
+        const toolInput = input.tool_input ?? {};
+        let approve = false;
+        let reason = "";
+        if (toolName === "Bash" && /^ase(\s|$)/.test(toolInput.command ?? "")) {
+            approve = true;
+            reason = "ASE CLI invocation auto-approved";
+        }
+        else if (toolName === "Skill" && /^(?:ase:)?ase-.+/.test(toolInput.skill ?? "")) {
+            approve = true;
+            reason = "ASE skill invocation auto-approved";
+        }
+        /*  emit permission decision (or stay silent to defer to default flow)  */
+        if (approve) {
+            process.stdout.write(JSON.stringify({
+                "hookSpecificOutput": {
+                    "hookEventName": "PreToolUse",
+                    "permissionDecision": "allow",
+                    "permissionDecisionReason": reason
+                }
+            }));
+        }
+        return 0;
+    }
     /*  register commands  */
     register(program) {
         /*  register CLI top-level command "ase hook"  */
@@ -79,5 +109,12 @@ export default class HookCommand {
             .action(() => {
             process.exit(this.doSessionStart());
         });
+        /*  register CLI sub-command "ase hook pre-tool-use"  */
+        hookCmd
+            .command("pre-tool-use")
+            .description("handle Claude Code PreToolUse hook event")
+            .action(() => {
+            process.exit(this.doPreToolUse());
+        });
     }
 }

package/dst/ase.js

@@ -9,6 +9,7 @@ import Log from "./ase-log.js";
 import ConfigCommand from "./ase-config.js";
 import ServiceCommand from "./ase-service.js";
 import HookCommand from "./ase-hook.js";
+import DiagramCommand from "./ase-diagram.js";
 import pkg from "../package.json" with { type: "json" };
 /*  globally initialize logger  */
 const log = new Log("ase", "warning", "-");
@@ -40,6 +41,7 @@ const main = async () => {
     new ConfigCommand(log).register(program);
     new ServiceCommand(log).register(program);
     new HookCommand(log).register(program);
+    new DiagramCommand(log).register(program);
     /*  parse program arguments  */
     await program.parseAsync(process.argv);
     /*  gracefully terminate  */

package/package.json

@@ -6,7 +6,7 @@
     "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.13",
+    "version":                              "0.0.14",
     "license":                              "GPL-3.0-only",
     "author": {
         "name":                             "Dr. Ralf S. Engelschall",
@@ -18,10 +18,10 @@
     "devDependencies": {
         "eslint":                           "9.39.4",
         "@eslint/js":                       "9.39.4",
-        "@typescript-eslint/parser":        "8.58.2",
-        "@typescript-eslint/eslint-plugin": "8.58.2",
+        "@typescript-eslint/parser":        "8.59.1",
+        "@typescript-eslint/eslint-plugin": "8.59.1",
         "eslint-plugin-n":                  "17.24.0",
-        "eslint-plugin-promise":            "7.2.1",
+        "eslint-plugin-promise":            "7.3.0",
         "eslint-plugin-import":             "2.32.0",
         "neostandard":                      "0.13.0",
         "globals":                          "17.5.0",
@@ -41,7 +41,8 @@
         "execa":                            "9.6.1",
         "mkdirp":                           "3.0.1",
         "@hapi/hapi":                       "21.4.8",
-        "axios":                            "1.15.1",
+        "axios":                            "1.15.2",
+        "beautiful-mermaid":                "1.1.3",
         "cli-table3":                       "0.6.5",
         "chalk":                            "5.6.2",
         "pretty-ms":                        "9.3.0",