@rse/ase 0.9.43 → 0.9.45

package/dst/ase-kv.js

@@ -95,7 +95,7 @@ export class KVMCP {
             }
             catch (err) {
                 const message = err instanceof Error ? err.message : String(err);
-                return { isError: true, content: [{ type: "text", text: `kv_get: ERROR: ${message}` }] };
+                return { isError: true, content: [{ type: "text", text: `ERROR: ${message}` }] };
             }
         });
         /*  key/value set  */
@@ -107,17 +107,17 @@ export class KVMCP {
             inputSchema: {
                 key: z.string()
                     .describe("key identifier (non-empty, no whitespace-only, no control characters, up to 1024 characters)"),
-                val: z.union([z.string(), z.number(), z.boolean(), z.null(), z.array(z.any()), z.record(z.string(), z.any())])
+                val: z.union([z.string(), z.number(), z.boolean(), z.null(), z.array(z.unknown()), z.record(z.string(), z.unknown())])
                     .describe("arbitrary JSON-compatible value to store under `key`")
             }
         }, async (args) => {
             try {
                 KV.set(args.key, args.val);
-                return { content: [{ type: "text", text: `kv_set: OK: stored key "${args.key}"` }] };
+                return { content: [{ type: "text", text: `OK: stored key "${args.key}"` }] };
             }
             catch (err) {
                 const message = err instanceof Error ? err.message : String(err);
-                return { isError: true, content: [{ type: "text", text: `kv_set: ERROR: ${message}` }] };
+                return { isError: true, content: [{ type: "text", text: `ERROR: ${message}` }] };
             }
         });
         /*  key/value clear  */
@@ -134,11 +134,11 @@ export class KVMCP {
         }, async (args) => {
             try {
                 const n = KV.clear(args.prefix);
-                return { content: [{ type: "text", text: `kv_clear: OK: removed ${n} key(s)` }] };
+                return { content: [{ type: "text", text: `OK: removed ${n} key(s)` }] };
             }
             catch (err) {
                 const message = err instanceof Error ? err.message : String(err);
-                return { isError: true, content: [{ type: "text", text: `kv_clear: ERROR: ${message}` }] };
+                return { isError: true, content: [{ type: "text", text: `ERROR: ${message}` }] };
             }
         });
         /*  key/value delete  */
@@ -154,13 +154,13 @@ export class KVMCP {
             try {
                 const removed = KV.delete(args.key);
                 const msg = removed ?
-                    `kv_delete: OK: removed key "${args.key}"` :
-                    `kv_delete: WARNING: no key "${args.key}" to remove`;
+                    `OK: removed key "${args.key}"` :
+                    `WARNING: no key "${args.key}" to remove`;
                 return { content: [{ type: "text", text: msg }] };
             }
             catch (err) {
                 const message = err instanceof Error ? err.message : String(err);
-                return { isError: true, content: [{ type: "text", text: `kv_delete: ERROR: ${message}` }] };
+                return { isError: true, content: [{ type: "text", text: `ERROR: ${message}` }] };
             }
         });
         /*  key/value batch  */
@@ -174,17 +174,17 @@ export class KVMCP {
                 "first per-command error (remaining commands are skipped); otherwise per-command errors " +
                 "are recorded and execution continues. " +
                 "Returns a single `text` payload containing a JSON array of per-command result strings " +
-                "in the same format emitted by `kv_clear`/`kv_set`/`kv_get`/`kv_delete`. " +
+                "positionally matching the `commands` array. " +
                 "On transactional rollback, prior per-command result strings are rewritten to " +
-                "`kv_<cmd>: ROLLED-BACK` to truthfully reflect the post-rollback state, and the " +
-                "final entry remains `kv_batch: ERROR: <message>`.",
+                "`ROLLED-BACK` to truthfully reflect the post-rollback state, and the " +
+                "final entry remains `ERROR: <message>`.",
             inputSchema: {
                 commands: z.array(z.object({
                     command: z.enum(["clear", "set", "get", "delete"])
                         .describe("the KV sub-command to execute"),
                     key: z.string().optional()
                         .describe("key identifier (required for `set`/`get`/`delete`)"),
-                    val: z.union([z.string(), z.number(), z.boolean(), z.null(), z.array(z.any()), z.record(z.string(), z.any())]).optional()
+                    val: z.union([z.string(), z.number(), z.boolean(), z.null(), z.array(z.unknown()), z.record(z.string(), z.unknown())]).optional()
                         .describe("value to store (required for `set`)"),
                     prefix: z.string().optional()
                         .describe("if given for `clear`, only remove keys starting with this prefix (otherwise remove all keys)")
@@ -195,44 +195,39 @@ export class KVMCP {
             }
         }, async (args) => {
             const results = [];
-            const cmdNames = [];
             const tx = args.transactional === true;
             const snapshot = tx ? KV.snapshot() : null;
             for (const c of args.commands) {
                 try {
                     if (c.command === "clear") {
                         const n = KV.clear(c.prefix);
-                        results.push(`kv_clear: OK: removed ${n} key(s)`);
-                        cmdNames.push("clear");
+                        results.push(`OK: removed ${n} key(s)`);
                     }
                     else if (c.command === "set") {
                         if (c.key === undefined)
-                            throw new Error("kv_set: missing `key`");
+                            throw new Error("missing `key`");
                         if (c.val === undefined)
-                            throw new Error("kv_set: missing `val`");
+                            throw new Error("missing `val`");
                         KV.set(c.key, c.val);
-                        results.push(`kv_set: OK: stored key "${c.key}"`);
-                        cmdNames.push("set");
+                        results.push(`OK: stored key "${c.key}"`);
                     }
                     else if (c.command === "get") {
                         if (c.key === undefined)
-                            throw new Error("kv_get: missing `key`");
+                            throw new Error("missing `key`");
                         if (!KV.has(c.key))
                             results.push("");
                         else {
                             const val = KV.get(c.key);
                             results.push(val === undefined ? "" : JSON.stringify(val));
                         }
-                        cmdNames.push("get");
                     }
                     else if (c.command === "delete") {
                         if (c.key === undefined)
-                            throw new Error("kv_delete: missing `key`");
+                            throw new Error("missing `key`");
                         const removed = KV.delete(c.key);
                         results.push(removed ?
-                            `kv_delete: OK: removed key "${c.key}"` :
-                            `kv_delete: WARNING: no key "${c.key}" to remove`);
-                        cmdNames.push("delete");
+                            `OK: removed key "${c.key}"` :
+                            `WARNING: no key "${c.key}" to remove`);
                     }
                 }
                 catch (err) {
@@ -241,11 +236,11 @@ export class KVMCP {
                         if (snapshot !== null)
                             KV.restore(snapshot);
                         for (let i = 0; i < results.length; i++)
-                            results[i] = `kv_${cmdNames[i]}: ROLLED-BACK`;
-                        results.push(`kv_batch: ERROR: ${message}`);
+                            results[i] = "ROLLED-BACK";
+                        results.push(`ERROR: ${message}`);
                         return { isError: true, content: [{ type: "text", text: JSON.stringify(results) }] };
                     }
-                    results.push(`kv_${c.command}: ERROR: ${message}`);
+                    results.push(`ERROR: ${message}`);
                 }
             }
             return { content: [{ type: "text", text: JSON.stringify(results) }] };

package/dst/ase-log.js

@@ -30,7 +30,14 @@ export default class Log {
             throw new RangeError(`invalid log level "${this._logLevel}" (expected one of: ${levels.map((l) => l.name).join(", ")})`);
         this.logLevelIdx = idx;
         if (this._logFile !== "-")
-            this.stream = fs.createWriteStream(this._logFile, { flags: "a", encoding: "utf8" });
+            this.stream = this.openStream(this._logFile);
+    }
+    openStream(file) {
+        const stream = fs.createWriteStream(file, { flags: "a", encoding: "utf8" });
+        stream.on("error", (err) => {
+            process.stderr.write(`${this._program}: ERROR: cannot write log file "${file}": ${err.message}\n`);
+        });
+        return stream;
     }
     logLevel(level) {
         const idx = levels.findIndex((l) => l.name === level);
@@ -48,14 +55,14 @@ export default class Log {
             this.stream = null;
         }
         if (file !== "-")
-            this.stream = fs.createWriteStream(file, { flags: "a", encoding: "utf8" });
+            this.stream = this.openStream(file);
     }
     write(level, msg) {
         const idx = levels.findIndex((l) => l.name === level);
         if (idx !== -1 && idx <= this.logLevelIdx) {
             const timestamp = DateTime.now().toFormat("yyyy-LL-dd HH:mm:ss.SSS");
             let line = `${this._program}: [${timestamp}]: `;
-            if (this._logFile === "-" && process.stdout.isTTY)
+            if (this._logFile === "-" && process.stderr.isTTY)
                 line += `${levels[idx].style("[" + levels[idx].name.toUpperCase() + "]")}`;
             else
                 line += `[${levels[idx].name.toUpperCase()}]`;

package/dst/ase-markdown.js

@@ -37,22 +37,22 @@ export class Markdown {
         for (let li = 0; li < lines.length; li++) {
             const line = lines[li];
             const nl = li < lines.length - 1 ? "\n" : "";
-            const m = line.match(/^(\s*)(`{3,}|~{3,})/);
+            const m = line.match(/^\s*(`{3,}|~{3,})/);
             if (!inFence && m) {
                 /*  a fence-opening line: flush the pending non-fenced buffer,
                     enter fenced mode, and emit the opener verbatim  */
                 flush();
                 inFence = true;
-                fenceCh = m[2][0];
-                fenceLen = m[2].length;
+                fenceCh = m[1][0];
+                fenceLen = m[1].length;
                 result += line + nl;
             }
             else if (inFence) {
                 /*  inside a fenced block: emit verbatim and, on a matching
                     closing fence line, leave fenced mode  */
                 result += line + nl;
-                const c = line.match(/^(\s*)(`{3,}|~{3,})\s*$/);
-                if (c && c[2][0] === fenceCh && c[2].length >= fenceLen)
+                const c = line.match(/^\s*(`{3,}|~{3,})\s*$/);
+                if (c && c[1][0] === fenceCh && c[1].length >= fenceLen)
                     inFence = false;
             }
             else
@@ -62,100 +62,104 @@ export class Markdown {
         flush();
         return result;
     }
-    /*  apply the inline-span and bullet-marker rewriting passes to a chunk of
-        non-fenced Markdown text (see prepare() for fenced-block handling)  */
-    static rewrite(text) {
-        /*  PASS 1: rewrite inline code spans that carry backslash-escaped
-            backticks (`\``) into CommonMark-correct spans.  */
-        {
-            let pre = "";
-            let j = 0;
-            while (j < text.length) {
-                const ch = text[j];
-                if (ch !== "`") {
-                    /*  literal backslash-escaped backtick *outside* any span
-                        is left verbatim for later scanning  */
-                    pre += ch;
-                    j++;
+    /*  measure the length of the backtick run starting at offset pos  */
+    static runLength(text, pos) {
+        let n = 0;
+        while (pos + n < text.length && text[pos + n] === "`")
+            n++;
+        return n;
+    }
+    /*  PASS 1 of rewrite(): rewrite inline code spans that carry
+        backslash-escaped backticks (`\``) into CommonMark-correct spans  */
+    static rewriteEscapedSpans(text) {
+        let pre = "";
+        let j = 0;
+        while (j < text.length) {
+            const ch = text[j];
+            if (ch !== "`") {
+                /*  literal backslash-escaped backtick *outside* any span
+                    is left verbatim for later scanning  */
+                pre += ch;
+                j++;
+                continue;
+            }
+            /*  measure the full opening backtick run: a code-span
+                delimiter is a *run* of backticks and a span opened by a
+                run of N backticks is closed only by a run of exactly N
+                backticks, so the opening-run length determines what we
+                scan for as the closing delimiter  */
+            const open = Markdown.runLength(text, j);
+            /*  scan the opening backtick-run span, capturing its raw
+                inner content up to the matching unescaped closing run of
+                exactly `open` backticks  */
+            let inner = "";
+            let k = j + open;
+            let closed = false;
+            let escaped = false;
+            while (k < text.length) {
+                const c = text[k];
+                if (c === "\\" && k + 1 < text.length && text[k + 1] === "`") {
+                    inner += "\\`";
+                    escaped = true;
+                    k += 2;
                     continue;
                 }
-                /*  measure the full opening backtick run: a code-span
-                    delimiter is a *run* of backticks and a span opened by a
-                    run of N backticks is closed only by a run of exactly N
-                    backticks, so the opening-run length determines what we
-                    scan for as the closing delimiter  */
-                let open = 0;
-                while (j + open < text.length && text[j + open] === "`")
-                    open++;
-                /*  scan the opening backtick-run span, capturing its raw
-                    inner content up to the matching unescaped closing run of
-                    exactly `open` backticks  */
-                let inner = "";
-                let k = j + open;
-                let closed = false;
-                let escaped = false;
-                while (k < text.length) {
-                    const c = text[k];
-                    if (c === "\\" && k + 1 < text.length && text[k + 1] === "`") {
-                        inner += "\\`";
-                        escaped = true;
-                        k += 2;
-                        continue;
+                if (c === "`") {
+                    /*  measure this backtick run and treat it as the
+                        closing delimiter only if it matches the opening
+                        run length exactly; a shorter or longer run is
+                        literal content of the span  */
+                    const runLen = Markdown.runLength(text, k);
+                    if (runLen === open) {
+                        closed = true;
+                        break;
                     }
-                    if (c === "`") {
-                        /*  measure this backtick run and treat it as the
-                            closing delimiter only if it matches the opening
-                            run length exactly; a shorter or longer run is
-                            literal content of the span  */
-                        let runLen = 0;
-                        while (k + runLen < text.length && text[k + runLen] === "`")
-                            runLen++;
-                        if (runLen === open) {
-                            closed = true;
-                            break;
-                        }
-                        inner += "`".repeat(runLen);
-                        k += runLen;
-                        continue;
-                    }
-                    inner += c;
-                    k++;
-                }
-                if (!closed || !escaped) {
-                    /*  not an escaped-backtick span: emit the opening run
-                        verbatim and continue scanning from just after it  */
-                    pre += "`".repeat(open);
-                    j += open;
+                    inner += "`".repeat(runLen);
+                    k += runLen;
                     continue;
                 }
-                /*  un-escape inner `\`` into literal backticks, then choose a
-                    fence longer than the longest internal backtick run  */
-                const content = inner.replace(/\\`/g, "`");
-                let maxRun = 0;
-                let run = 0;
-                for (const c of content) {
-                    if (c === "`") {
-                        run++;
-                        if (run > maxRun)
-                            maxRun = run;
-                    }
-                    else
-                        run = 0;
+                if (c === "\n" && /^[ \t]*\r?(?:\n|$)/.test(text.slice(k + 1)))
+                    /*  a code span never crosses a paragraph break  */
+                    break;
+                inner += c;
+                k++;
+            }
+            if (!closed || !escaped) {
+                /*  not an escaped-backtick span: emit the opening run
+                    verbatim and continue scanning from just after it  */
+                pre += "`".repeat(open);
+                j += open;
+                continue;
+            }
+            /*  un-escape inner `\`` into literal backticks, then choose a
+                fence longer than the longest internal backtick run  */
+            const content = inner.replace(/\\`/g, "`");
+            let maxRun = 0;
+            let run = 0;
+            for (const c of content) {
+                if (c === "`") {
+                    run++;
+                    if (run > maxRun)
+                        maxRun = run;
                 }
-                const fence = "`".repeat(maxRun + 1);
-                const pad = (content.startsWith("`") || content.endsWith("`")) ? " " : "";
-                pre += `${fence}${pad}${content}${pad}${fence}`;
-                j = k + open;
+                else
+                    run = 0;
             }
-            text = pre;
+            const fence = "`".repeat(maxRun + 1);
+            const pad = (content.startsWith("`") || content.endsWith("`")) ? " " : "";
+            pre += `${fence}${pad}${content}${pad}${fence}`;
+            j = k + open;
         }
-        /*  PASS 2: split multi-line inline code spans by scanning the
-            entire text character-by-character while tracking whether we
-            are currently inside an active backtick (U+0060) span; on
-            every "<newline><whitespaces>" sequence encountered while
-            inside a span, close the span before the break and re-open
-            it after the indentation, so each physical line becomes its
-            own single-line span */
+        return pre;
+    }
+    /*  PASS 2 of rewrite(): split multi-line inline code spans by scanning
+        the entire text character-by-character while tracking whether we
+        are currently inside an active backtick (U+0060) span; on
+        every "<newline><whitespaces>" sequence encountered while
+        inside a span, close the span before the break and re-open
+        it after the indentation, so each physical line becomes its
+        own single-line span  */
+    static splitMultiLineSpans(text) {
         let out = "";
         let fence = 0;
         let i = 0;
@@ -165,14 +169,31 @@ export class Markdown {
                 /*  measure the full backtick run (a code-span delimiter is a
                     *run* of backticks; a span opened by N backticks is closed
                     only by a run of exactly N backticks)  */
-                let n = 0;
-                while (i < text.length && text[i] === "`") {
-                    n++;
-                    i++;
+                const n = Markdown.runLength(text, i);
+                i += n;
+                if (fence === 0) {
+                    /*  open a span of fence width n, but only if a matching
+                        closing run of exactly n backticks exists ahead (an
+                        unmatched run is literal text per CommonMark and must
+                        not trigger the line-splitting below)  */
+                    let p = i;
+                    let closes = false;
+                    while (p < text.length && !closes) {
+                        if (text[p] === "`") {
+                            const r = Markdown.runLength(text, p);
+                            if (r === n)
+                                closes = true;
+                            p += r;
+                        }
+                        else if (text[p] === "\n" && /^[ \t]*\r?(?:\n|$)/.test(text.slice(p + 1)))
+                            /*  a code span never crosses a paragraph break  */
+                            break;
+                        else
+                            p++;
+                    }
+                    if (closes)
+                        fence = n;
                 }
-                if (fence === 0)
-                    /*  open a span of fence width n  */
-                    fence = n;
                 else if (n === fence)
                     /*  close the active span  */
                     fence = 0;
@@ -203,23 +224,35 @@ export class Markdown {
                     i++;
                 }
                 /*  close span before the break, re-open after indentation,
-                    preserving the active fence width on both sides  */
+                    preserving the active fence width on both sides and padding
+                    with a space wherever an inserted delimiter run would merge
+                    with an adjacent literal backtick of the span content  */
                 const bars = "`".repeat(fence);
-                out += `${bars}${nl}${ws}${bars}`;
+                const padC = out.endsWith("`") ? " " : "";
+                const padO = (i < text.length && text[i] === "`") ? " " : "";
+                out += `${padC}${bars}${nl}${ws}${bars}${padO}`;
                 continue;
             }
             out += ch;
             i++;
         }
+        return out;
+    }
+    /*  apply the inline-span and bullet-marker rewriting passes to a chunk of
+        non-fenced Markdown text (see prepare() for fenced-block handling)  */
+    static rewrite(text) {
+        /*  PASS 1: rewrite escaped-backtick inline code spans  */
+        text = Markdown.rewriteEscapedSpans(text);
+        /*  PASS 2: split multi-line inline code spans into per-line spans  */
+        const out = Markdown.splitMultiLineSpans(text);
         /*  PASS 3: replace the leading "-"/"*" marker of every unordered
             bullet paragraph with "◯", preserving the leading indentation
             and the following whitespace; operate line-by-line so only the
             actual list markers (at a line start) are affected  */
-        out = out
+        return out
             .split("\n")
             .map((line) => line.replace(/^(\s*)[-*]([ \t]+)/, "$1◯$2"))
             .join("\n");
-        return out;
     }
 }
 /*  MCP registration entry point  */

package/dst/ase-mcp.js

@@ -3,13 +3,11 @@
 **  Copyright (c) 2025-2026 Dr. Ralf S. Engelschall <rse@engelschall.com>
 **  Licensed under Apache 2.0 <https://spdx.org/licenses/Apache-2.0>
 */
-import path from "node:path";
 import { fileURLToPath } from "node:url";
 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";
-import { SERVICE_HOST as HOST, serviceSchema, probe } from "./ase-service.js";
+import { SERVICE_HOST as HOST, probe, loadServiceContext } from "./ase-service.js";
 /*  CLI command "ase mcp"  */
 export default class MCPCommand {
     log;
@@ -18,13 +16,7 @@ export default class MCPCommand {
     }
     /*  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 projectId = cfg.get("project.id") ?? path.basename(process.cwd());
-        const port = svc.get("port") ?? null;
-        return { projectId, port };
+        return loadServiceContext(this.log);
     }
     /*  run "ase service start" and wait for the service to come up  */
     async ensureService() {
@@ -116,6 +108,7 @@ export default class MCPCommand {
             try {
                 const ctx = await this.ensureService();
                 port = ctx.port;
+                projectId = ctx.projectId;
                 const stale = client;
                 client = null;
                 if (stale !== null) {

package/dst/ase-meta.js

@@ -39,8 +39,9 @@ export class Meta {
         try {
             return fs.readFileSync(abs, "utf8");
         }
-        catch (_e) {
-            throw new Error(`meta: failed to read file: ${abs}`);
+        catch (err) {
+            const message = err instanceof Error ? err.message : String(err);
+            throw new Error(`meta: failed to read file: ${abs} (${message})`);
         }
     }
 }
@@ -58,8 +59,9 @@ export default class MetaCommand {
             .argument("<name...>", "meta file name(s) (\"ase-\" prefix and \".md\" extension optional)")
             .action(async (names) => {
             this.log.write("debug", `meta: reading ${names.length} file(s)`);
-            for (const name of names)
-                await writeStdout(Meta.read(name));
+            const texts = names.map((name) => Meta.read(name));
+            for (const text of texts)
+                await writeStdout(text);
         });
     }
 }

package/dst/ase-persona.js

@@ -5,17 +5,15 @@
 */
 import { isScalar } from "yaml";
 import { z } from "zod";
-import { Config, configSchema, parseScope } from "./ase-config.js";
+import { Config, configSchema, parseScope, agentClassification } from "./ase-config.js";
 /*  reusable functionality: ASE agent persona style get/set  */
 export class Persona {
     /*  allowed persona style values  */
-    static styles = ["writer", "engineer", "journalist", "telegrapher", "caveman"];
+    static styles = agentClassification.persona;
     /*  get the effective persona style for an optional session;
         returns the default "engineer" if nothing is configured  */
     static get(log, session) {
-        const scope = session !== undefined ?
-            parseScope(`session:${session}`) :
-            parseScope(undefined);
+        const scope = parseScope(session !== undefined ? `session:${session}` : undefined);
         const cfg = new Config("config", configSchema, log, scope);
         cfg.read();
         const val = cfg.get("agent.persona");
@@ -28,9 +26,7 @@ export class Persona {
     }
     /*  set the persona style on the strongest scope of an optional session  */
     static set(log, style, session) {
-        const scope = session !== undefined ?
-            parseScope(`session:${session}`) :
-            parseScope(undefined);
+        const scope = parseScope(session !== undefined ? `session:${session}` : undefined);
         const cfg = new Config("config", configSchema, log, scope);
         cfg.lock(() => {
             cfg.read();
@@ -61,7 +57,7 @@ export default class PersonaMCP {
             inputSchema: {
                 style: z.enum(Persona.styles).optional()
                     .describe("persona style to set; if omitted, the current persona style is returned"),
-                session: z.string().optional()
+                session: z.string().regex(/^[A-Za-z0-9._-]+$/).optional()
                     .describe("session identifier (allowed characters: A-Z, a-z, 0-9, '.', '_', '-'); " +
                     "if omitted, the operation is not scoped to a specific session")
             }
@@ -71,7 +67,7 @@ export default class PersonaMCP {
                     Persona.set(this.log, args.style, args.session);
                     const where = args.session !== undefined ?
                         ` for session "${args.session}"` : "";
-                    const msg = `persona: OK: set agent.persona to "${args.style}"${where}`;
+                    const msg = `OK: set agent.persona to "${args.style}"${where}`;
                     return {
                         content: [{ type: "text", text: msg }]
                     };
@@ -85,7 +81,7 @@ export default class PersonaMCP {
                 const message = err instanceof Error ? err.message : String(err);
                 return {
                     isError: true,
-                    content: [{ type: "text", text: `persona: ERROR: ${message}` }]
+                    content: [{ type: "text", text: `ERROR: ${message}` }]
                 };
             }
         });