@rse/ase 0.0.13 → 0.0.15

package/dst/ase-config.js

@@ -324,16 +324,18 @@ export class Config {
             if (sc.kind === "default") {
                 const doc = new Document();
                 doc.contents = doc.createNode({});
-                const preset = projectClassificationPresets.default;
-                for (const [k, val] of Object.entries(preset)) {
-                    const segments = k.split(".");
-                    for (let j = 1; j < segments.length; j++) {
-                        const prefix = segments.slice(0, j);
-                        const node = doc.getIn(prefix, true);
-                        if (node === undefined)
-                            doc.setIn(prefix, doc.createNode({}));
+                if (this.name === "config") {
+                    const preset = projectClassificationPresets.default;
+                    for (const [k, val] of Object.entries(preset)) {
+                        const segments = k.split(".");
+                        for (let j = 1; j < segments.length; j++) {
+                            const prefix = segments.slice(0, j);
+                            const node = doc.getIn(prefix, true);
+                            if (node === undefined)
+                                doc.setIn(prefix, doc.createNode({}));
+                        }
+                        doc.setIn(segments, doc.createNode(val));
                     }
-                    doc.setIn(segments, doc.createNode(val));
                 }
                 docs.push({ scope: sc, filename: "", doc });
                 continue;

package/dst/ase-diagram.js

@@ -0,0 +1,222 @@
+/*
+**  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 fs from "node:fs";
+import { InvalidArgumentError } from "commander";
+import { renderMermaidASCII } from "beautiful-mermaid";
+/*  custom argument parser for Commander: non-negative integer  */
+const parseInteger = (name) => (value) => {
+    const n = Number.parseInt(value, 10);
+    if (!Number.isFinite(n) || n < 0)
+        throw new InvalidArgumentError(`${name} must be a non-negative integer`);
+    return n;
+};
+/*  custom argument parser for Commander: color mode  */
+const parseColorMode = (name) => (value) => {
+    if (value !== "none" && value !== "ansi16" && value !== "ansi256")
+        throw new InvalidArgumentError(`${name} must be "none", "ansi16", or "ansi256"`);
+    return value;
+};
+/*  detect terminal column width  */
+const detectTermWidth = () => {
+    let width = 0;
+    /*  attempt 1: query environment variable  */
+    if (process.env.ASE_TERM_WIDTH !== undefined) {
+        const cols = Number.parseInt(process.env.ASE_TERM_WIDTH, 10);
+        if (Number.isFinite(cols) && cols > 0)
+            width = cols;
+    }
+    /*  attempt 2: query stdout  */
+    if (width === 0 && process.stdout.isTTY) {
+        const cols = process.stdout.columns;
+        if (typeof cols === "number" && cols > 0)
+            width = cols;
+    }
+    return width;
+};
+/*  detect terminal row height  */
+const detectTermHeight = () => {
+    let height = 0;
+    /*  attempt 1: query environment variable  */
+    if (process.env.ASE_TERM_HEIGHT !== undefined) {
+        const rows = Number.parseInt(process.env.ASE_TERM_HEIGHT, 10);
+        if (Number.isFinite(rows) && rows > 0)
+            height = rows;
+    }
+    /*  attempt 2: query stdout  */
+    if (height === 0 && process.stdout.isTTY) {
+        const rows = process.stdout.rows;
+        if (typeof rows === "number" && rows > 0)
+            height = rows;
+    }
+    return height;
+};
+/*  detect terminal color capability  */
+const detectColorMode = () => {
+    let mode = "none";
+    /*  attempt 1: query environment variable (explicitly)  */
+    if (process.env.ASE_TERM_COLORS !== undefined)
+        if (process.env.ASE_TERM_COLORS.match(/^(?:none|ansi16|ansi256)$/) !== null)
+            mode = process.env.ASE_TERM_COLORS;
+    /*  attempt 2: query stdout  */
+    if (mode === "none" && process.stdout.isTTY) {
+        const depth = process.stdout.getColorDepth();
+        if (depth >= 8)
+            mode = "ansi256";
+        else if (depth >= 4)
+            mode = "ansi16";
+    }
+    return mode;
+};
+/*  truncate a single rendered line to a maximum visible column,
+    preserving ANSI escape sequences (CSI ...m) and appending an ANSI
+    reset sequence if any styling was active at the truncation point  */
+const truncateAnsiLine = (line, budget) => {
+    if (budget <= 0)
+        return "";
+    let out = "";
+    let visible = 0;
+    let styled = false;
+    let i = 0;
+    while (i < line.length) {
+        const ch = line[i];
+        if (ch === "\x1b" && line[i + 1] === "[") {
+            let j = i + 2;
+            while (j < line.length && !/[A-Za-z]/.test(line[j]))
+                j++;
+            if (j < line.length) {
+                const seq = line.slice(i, j + 1);
+                out += seq;
+                if (seq.endsWith("m")) {
+                    const body = seq.slice(2, -1);
+                    if (body === "" || body === "0")
+                        styled = false;
+                    else
+                        styled = true;
+                }
+                i = j + 1;
+                continue;
+            }
+            i++;
+            continue;
+        }
+        if (visible >= budget)
+            break;
+        out += ch;
+        visible++;
+        i++;
+    }
+    if (styled)
+        out += "\x1b[0m";
+    return out;
+};
+/*  pure rendering helper: turn a Mermaid source string plus options into
+    a rendered Unicode/ASCII diagram string. Throws on render failure.  */
+export const renderDiagram = (src, opts) => {
+    /*  create diagram rendering  */
+    let out = renderMermaidASCII(src, {
+        useAscii: opts.ascii,
+        paddingX: opts.nodeMarginX,
+        paddingY: opts.nodeMarginY,
+        boxBorderPadding: opts.nodePadding,
+        colorMode: opts.colorMode,
+        theme: opts.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"
+        }
+    });
+    /*  optionally clip diagram rendering  */
+    const termWidth = opts.terminalWidth;
+    const termHeight = opts.terminalHeight;
+    if (termWidth > 0 || termHeight > 0) {
+        const maxWidth = termWidth > 0 ? termWidth - opts.diagramClipX : 0;
+        const maxHeight = termHeight > 0 ? termHeight - opts.diagramClipY : 0;
+        const trailingNL = out.endsWith("\n");
+        let lines = (trailingNL ? out.slice(0, -1) : out).split("\n");
+        if (maxWidth > 0)
+            lines = lines.map((l) => truncateAnsiLine(l, maxWidth));
+        if (maxHeight > 0 && lines.length > maxHeight)
+            lines = lines.slice(0, maxHeight);
+        out = lines.join("\n") + (trailingNL ? "\n" : "");
+    }
+    return out;
+};
+/*  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 diagram specification as Unicode/ASCII art")
+            .option("-i, --input <file>", "read Mermaid source from file instead of stdin")
+            .option("-a, --ascii", "emit plain ASCII (+-|) instead of Unicode box-drawing", false)
+            .option("-c, --color-mode <mode>", "force color mode (\"none\", \"ansi16\", or \"ansi256\")", parseColorMode("--color-mode"), detectColorMode())
+            .option("--node-margin-x <n>", "horizontal margin between nodes of <n> characters", parseInteger("--node-margin-x"), 3)
+            .option("--node-margin-y <n>", "vertical margin between nodes of <n> lines", parseInteger("--node-margin-y"), 3)
+            .option("--node-padding <n>", "horizontal and vertical inner node padding with <n> characters", parseInteger("--node-padding"), 1)
+            .option("--diagram-clip-x <n>", "extra horizontal clipping of diagram to terminal width minus <n> characters", parseInteger("--diagram-clip-x"), 0)
+            .option("--diagram-clip-y <n>", "extra vertical clipping of diagram to terminal height minus <n> lines", parseInteger("--diagram-clip-y"), 0)
+            .option("--terminal-width <n>", "width of terminal of <n> characters (for diagram clipping)", parseInteger("--terminal-width"), detectTermWidth())
+            .option("--terminal-height <n>", "height of terminal of <n> lines (for diagram clipping)", parseInteger("--terminal-height"), detectTermHeight())
+            .action(async (opts) => {
+            /*  fetch Mermaid diagram specification from stdin  */
+            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 diagram specification");
+                process.exit(1);
+            }
+            /*  create diagram rendering  */
+            let out;
+            try {
+                out = renderDiagram(src, {
+                    ascii: opts.ascii ?? false,
+                    colorMode: opts.colorMode,
+                    nodeMarginX: opts.nodeMarginX,
+                    nodeMarginY: opts.nodeMarginY,
+                    nodePadding: opts.nodePadding,
+                    diagramClipX: opts.diagramClipX,
+                    diagramClipY: opts.diagramClipY,
+                    terminalWidth: opts.terminalWidth,
+                    terminalHeight: opts.terminalHeight
+                });
+            }
+            catch (err) {
+                const message = err instanceof Error ? err.message : String(err);
+                this.log.write("error", `diagram: render failed: ${message}`);
+                process.exit(1);
+            }
+            /*  output diagram rendering  */
+            process.stdout.write(out);
+            if (!out.endsWith("\n"))
+                process.stdout.write("\n");
+        });
+    }
+}

package/dst/ase-hook.js

@@ -62,6 +62,40 @@ 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";
+        }
+        else if (/^mcp__plugin_ase_ase__.+/.test(toolName)) {
+            approve = true;
+            reason = "ASE MCP tool 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 +113,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-mcp.js

@@ -0,0 +1,156 @@
+/*
+**  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 path from "node:path";
+import { fileURLToPath } from "node:url";
+import axios from "axios";
+import * as v from "valibot";
+import { execa } from "execa";
+import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
+import { StreamableHTTPClientTransport } from "@modelcontextprotocol/sdk/client/streamableHttp.js";
+import { Config, configSchema } from "./ase-config.js";
+const HOST = "127.0.0.1";
+/*  schema for ".ase/service.yaml" (same shape as in ase-service.ts)  */
+const serviceSchema = v.nullish(v.strictObject({
+    port: v.optional(v.pipe(v.number(), v.integer(), v.minValue(1024), v.maxValue(65535)))
+}));
+/*  distinguish ECONNREFUSED from other Axios transport errors  */
+const isConnRefused = (err) => {
+    const e = err;
+    return e?.code === "ECONNREFUSED" || e?.cause?.code === "ECONNREFUSED";
+};
+/*  probe the service and verify ASE identity banner  */
+const probe = async (port, projectId) => {
+    try {
+        const r = await axios.request({
+            method: "OPTIONS",
+            url: `http://${HOST}:${port}/`,
+            timeout: 2000,
+            validateStatus: () => true
+        });
+        if (r.status < 200 || r.status >= 300)
+            return false;
+        const d = r.data;
+        return d?.ase === true && d?.projectId === projectId;
+    }
+    catch (err) {
+        if (isConnRefused(err))
+            return null;
+        throw err;
+    }
+};
+/*  CLI command "ase mcp"  */
+export default class MCPCommand {
+    log;
+    constructor(log) {
+        this.log = log;
+    }
+    /*  load service identity context  */
+    loadContext() {
+        const cfg = new Config("config", configSchema, this.log);
+        cfg.read();
+        const svc = new Config("service", serviceSchema, this.log);
+        svc.read();
+        const rawId = cfg.get("project.id");
+        const projectId = rawId ?? path.basename(process.cwd());
+        const rawPort = svc.get("port");
+        const port = rawPort ?? null;
+        return { projectId, port, svc };
+    }
+    /*  spawn "ase service start" detached and wait for it to come up  */
+    async ensureService() {
+        let ctx = this.loadContext();
+        /*  fast path: already running  */
+        if (ctx.port !== null) {
+            const match = await probe(ctx.port, ctx.projectId);
+            if (match === true)
+                return { projectId: ctx.projectId, port: ctx.port };
+        }
+        /*  spawn "ase service start" using the same node entry point  */
+        const entry = fileURLToPath(new URL("./ase.js", import.meta.url));
+        await execa(process.execPath, [entry, "service", "start"], {
+            stdio: "ignore",
+            detached: false
+        });
+        /*  re-load context to pick up the freshly persisted port  */
+        ctx = this.loadContext();
+        if (ctx.port === null)
+            throw new Error("mcp: service did not register a port after start");
+        const match = await probe(ctx.port, ctx.projectId);
+        if (match !== true)
+            throw new Error(`mcp: service not responding on port ${ctx.port} after start`);
+        return { projectId: ctx.projectId, port: ctx.port };
+    }
+    /*  bridge stdio to a Streamable HTTP MCP endpoint on the local service  */
+    async runBridge() {
+        /*  ensure the service is running  */
+        const { port } = await this.ensureService();
+        /*  create MCP HTTP client  */
+        const url = new URL(`http://${HOST}:${port}/mcp`);
+        const client = new StreamableHTTPClientTransport(url);
+        /*  create MCP STDIO server  */
+        const server = new StdioServerTransport();
+        /*  handle shutdown  */
+        let closed = false;
+        const shutdown = async () => {
+            if (closed)
+                return;
+            closed = true;
+            await Promise.allSettled([
+                server.close(),
+                client.close()
+            ]);
+        };
+        /*  connect server to client (forward transport)  */
+        server.onmessage = (msg) => {
+            client.send(msg).catch((_err) => {
+                const err = _err instanceof Error ? _err : new Error(String(_err));
+                this.log.write("error", `mcp: http send: ${err.message}`);
+            });
+        };
+        server.onerror = (_err) => {
+            const err = _err instanceof Error ? _err : new Error(String(_err));
+            this.log.write("error", `mcp: stdio: ${err.message}`);
+        };
+        server.onclose = () => {
+            shutdown().catch(() => { });
+        };
+        /*  connect client to server (backward transport)  */
+        client.onmessage = (msg) => {
+            server.send(msg).catch((_err) => {
+                const err = _err instanceof Error ? _err : new Error(String(_err));
+                this.log.write("error", `mcp: stdout send: ${err.message}`);
+            });
+        };
+        client.onerror = (_err) => {
+            const err = _err instanceof Error ? _err : new Error(String(_err));
+            this.log.write("error", `mcp: http: ${err.message}`);
+        };
+        client.onclose = () => {
+            shutdown().catch(() => { });
+        };
+        /*  start server and client  */
+        await server.start();
+        await client.start();
+        /*  await stdio to be closed  */
+        await new Promise((resolve) => {
+            const done = () => resolve();
+            process.stdin.once("end", done);
+            process.stdin.once("close", done);
+        });
+        /*  shutdown services  */
+        await shutdown();
+        return 0;
+    }
+    /*  register commands  */
+    register(program) {
+        program
+            .command("mcp")
+            .description("Bridge stdio MCP to the per-project background service over Streamable HTTP")
+            .action(async () => {
+            process.exit(await this.runBridge());
+        });
+    }
+}

package/dst/ase-service.js

@@ -13,7 +13,12 @@ import axios from "axios";
 import { isMap } from "yaml";
 import * as v from "valibot";
 import prettyMs from "pretty-ms";
+import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+import { StreamableHTTPServerTransport } from "@modelcontextprotocol/sdk/server/streamableHttp.js";
+import { z } from "zod";
 import { Config, configSchema } from "./ase-config.js";
+import { renderDiagram } from "./ase-diagram.js";
+import pkg from "../package.json" with { type: "json" };
 const SERVE_ENV = "ASE_SERVICE_SERVE";
 const PORT_ENV = "ASE_SERVICE_PORT";
 const HOST = "127.0.0.1";
@@ -177,6 +182,86 @@ export default class ServiceCommand {
             lastActivity = Date.now();
             return h.continue;
         });
+        /*  build a fresh MCP server instance with the demo "ping" tool  */
+        const buildMcpServer = () => {
+            const mcp = new McpServer({ name: "ase", version: pkg.version });
+            mcp.registerTool("ping", {
+                title: "ASE service ping",
+                description: "Return ASE service identity, port, and uptime.",
+                inputSchema: {}
+            }, async () => {
+                const status = {
+                    ok: true,
+                    projectId: ctx.projectId,
+                    port: ctx.port,
+                    uptimeMs: Date.now() - startTime
+                };
+                return {
+                    content: [{ type: "text", text: JSON.stringify(status) }]
+                };
+            });
+            mcp.registerTool("diagram", {
+                title: "ASE diagram render",
+                description: "Render a Mermaid diagram as Unicode/ASCII art. " +
+                    "Use for visualizing " +
+                    "structure/layout/components/dependencies as a Flowchart, " +
+                    "control-flow/branching/concurrency as a Flowchart, " +
+                    "state-machine/states/transitions as an UML State Diagram, " +
+                    "data-flow/actors/messages/protocols as an UML Sequence Diagram, " +
+                    "data-structure/classes/methods as an UML Class Diagram " +
+                    "data-model/entities/relationships as an ER Diagram, or " +
+                    "metrics/distributions/time-series as a XY-Charts. " +
+                    "Pass the Mermaid diagram specification as `diagram`. " +
+                    "Returns the rendered art as `text`.",
+                inputSchema: {
+                    diagram: z.string()
+                        .describe("Mermaid diagram specification"),
+                    ascii: z.boolean().default(false)
+                        .describe("emit plain ASCII (+-|) instead of Unicode box-drawing characters"),
+                    colorMode: z.enum(["none", "ansi16", "ansi256"]).default("none")
+                        .describe("color mode for ANSI escape sequences in the rendered output"),
+                    nodeMarginX: z.number().int().min(0).default(3)
+                        .describe("horizontal margin between nodes, in characters"),
+                    nodeMarginY: z.number().int().min(0).default(3)
+                        .describe("vertical margin between nodes, in lines"),
+                    nodePadding: z.number().int().min(0).default(1)
+                        .describe("inner horizontal and vertical padding within each node, in characters"),
+                    diagramClipX: z.number().int().min(0).default(0)
+                        .describe("extra horizontal clipping: subtract this many characters from `terminalWidth`"),
+                    diagramClipY: z.number().int().min(0).default(0)
+                        .describe("extra vertical clipping: subtract this many lines from `terminalHeight`"),
+                    terminalWidth: z.number().int().min(0).default(0)
+                        .describe("terminal width in characters; 0 disables horizontal clipping"),
+                    terminalHeight: z.number().int().min(0).default(0)
+                        .describe("terminal height in lines; 0 disables vertical clipping")
+                }
+            }, async (args) => {
+                try {
+                    const out = renderDiagram(args.diagram, {
+                        ascii: args.ascii,
+                        colorMode: args.colorMode,
+                        nodeMarginX: args.nodeMarginX,
+                        nodeMarginY: args.nodeMarginY,
+                        nodePadding: args.nodePadding,
+                        diagramClipX: args.diagramClipX,
+                        diagramClipY: args.diagramClipY,
+                        terminalWidth: args.terminalWidth,
+                        terminalHeight: args.terminalHeight
+                    });
+                    return {
+                        content: [{ type: "text", text: out }]
+                    };
+                }
+                catch (err) {
+                    const message = err instanceof Error ? err.message : String(err);
+                    return {
+                        isError: true,
+                        content: [{ type: "text", text: `diagram: render failed: ${message}` }]
+                    };
+                }
+            });
+            return mcp;
+        };
         /*  listen to HTTP/REST endpoints  */
         server.route({
             method: "OPTIONS",
@@ -196,6 +281,38 @@ export default class ServiceCommand {
                 return h.response({ ok: true }).code(200);
             }
         });
+        const mcpHandler = async (request, h, body) => {
+            const transport = new StreamableHTTPServerTransport({ sessionIdGenerator: undefined });
+            const mcp = buildMcpServer();
+            request.raw.res.on("close", () => {
+                transport.close().catch(() => { });
+                mcp.close().catch(() => { });
+            });
+            try {
+                await mcp.connect(transport);
+                await transport.handleRequest(request.raw.req, request.raw.res, body);
+            }
+            catch (_err) {
+                const err = _err instanceof Error ? _err : new Error(String(_err));
+                this.log.write("error", `mcp: ${err.message}`);
+                if (!request.raw.res.headersSent) {
+                    request.raw.res.statusCode = 500;
+                    request.raw.res.end();
+                }
+            }
+            return h.abandon;
+        };
+        server.route({
+            method: "POST",
+            path: "/mcp",
+            options: { payload: { parse: true, allow: "application/json" } },
+            handler: (request, h) => mcpHandler(request, h, request.payload)
+        });
+        server.route({
+            method: ["GET", "DELETE"],
+            path: "/mcp",
+            handler: (request, h) => mcpHandler(request, h)
+        });
         server.route({
             method: "POST",
             path: "/command",

package/dst/ase.js

@@ -8,7 +8,9 @@ import { Command, CommanderError, Option } from "commander";
 import Log from "./ase-log.js";
 import ConfigCommand from "./ase-config.js";
 import ServiceCommand from "./ase-service.js";
+import MCPCommand from "./ase-mcp.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", "-");
@@ -39,7 +41,9 @@ const main = async () => {
     /*  register top-level commands  */
     new ConfigCommand(log).register(program);
     new ServiceCommand(log).register(program);
+    new MCPCommand(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.15",
     "license":                              "GPL-3.0-only",
     "author": {
         "name":                             "Dr. Ralf S. Engelschall",
@@ -18,13 +18,13 @@
     "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",
+        "globals":                          "17.6.0",
         "typescript":                       "6.0.3",
 
         "@rse/stx":                         "1.1.5",
@@ -41,11 +41,14 @@
         "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",
-        "luxon":                            "3.7.2"
+        "luxon":                            "3.7.2",
+        "@modelcontextprotocol/sdk":        "1.29.0",
+        "zod":                              "4.4.2"
     },
     "engines": {
         "npm":                              ">=10.0.0",