@rse/ase 0.0.27 → 0.0.29

package/dst/ase-kv.js

@@ -0,0 +1,136 @@
+/*
+**  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 { z } from "zod";
+/*  reusable functionality: in-memory key/value store living inside the
+    "ase service" process; per-project (one service per project) and
+    not persisted; intended for sharing information between skills
+    across multiple Claude Code instances connected to the same service  */
+export class KV {
+    /*  the actual in-memory store  */
+    static store = new Map();
+    /*  maximum allowed key length, to keep memory bounded  */
+    static KEY_MAX_LEN = 1024;
+    /*  validate the key to keep it non-empty and bounded in length  */
+    static validateKey(key) {
+        if (typeof key !== "string" || key.length === 0)
+            throw new Error("kv: key must be a non-empty string");
+        if (key.length > KV.KEY_MAX_LEN)
+            throw new Error(`kv: key must be no longer than ${KV.KEY_MAX_LEN} characters`);
+    }
+    /*  test whether a value is stored under the given key  */
+    static has(key) {
+        KV.validateKey(key);
+        return KV.store.has(key);
+    }
+    /*  get a value by key; returns undefined if no value is stored  */
+    static get(key) {
+        KV.validateKey(key);
+        return KV.store.get(key);
+    }
+    /*  set a value under the given key; overwrites any existing value  */
+    static set(key, val) {
+        KV.validateKey(key);
+        KV.store.set(key, val);
+    }
+    /*  delete a value by key; returns true if a value existed  */
+    static delete(key) {
+        KV.validateKey(key);
+        return KV.store.delete(key);
+    }
+    /*  clear all keys; returns the number of keys removed  */
+    static clear() {
+        const n = KV.store.size;
+        KV.store.clear();
+        return n;
+    }
+}
+/*  MCP registration entry point for in-memory key/value tools  */
+export class KVMCP {
+    register(mcp) {
+        /*  key/value get  */
+        mcp.registerTool("kv_get", {
+            title: "ASE key/value get",
+            description: "Get a value from the in-memory key/value store by `key`. " +
+                "Returns the value as JSON-encoded `text`; returns an empty string if no value is stored.",
+            inputSchema: {
+                key: z.string()
+                    .describe("key identifier (non-empty string, up to 1024 characters)")
+            }
+        }, async (args) => {
+            try {
+                if (!KV.has(args.key))
+                    return { content: [{ type: "text", text: "" }] };
+                const val = KV.get(args.key);
+                const text = JSON.stringify(val);
+                return { content: [{ type: "text", text }] };
+            }
+            catch (err) {
+                const message = err instanceof Error ? err.message : String(err);
+                return { isError: true, content: [{ type: "text", text: `kv_get: ERROR: ${message}` }] };
+            }
+        });
+        /*  key/value set  */
+        mcp.registerTool("kv_set", {
+            title: "ASE key/value set",
+            description: "Store a `val` under the given `key` in the in-memory key/value store. " +
+                "Overwrites any existing value for the same `key`. " +
+                "The value can be any JSON-compatible type (string, number, boolean, null, array, object).",
+            inputSchema: {
+                key: z.string()
+                    .describe("key identifier (non-empty string, up to 1024 characters)"),
+                val: z.any()
+                    .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}"` }] };
+            }
+            catch (err) {
+                const message = err instanceof Error ? err.message : String(err);
+                return { isError: true, content: [{ type: "text", text: `kv_set: ERROR: ${message}` }] };
+            }
+        });
+        /*  key/value clear  */
+        mcp.registerTool("kv_clear", {
+            title: "ASE key/value clear",
+            description: "Remove all keys from the in-memory key/value store. " +
+                "Returns a status `text` indicating how many keys were removed.",
+            inputSchema: {}
+        }, async () => {
+            try {
+                const n = KV.clear();
+                return { content: [{ type: "text", text: `kv_clear: 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}` }] };
+            }
+        });
+        /*  key/value delete  */
+        mcp.registerTool("kv_delete", {
+            title: "ASE key/value delete",
+            description: "Delete a value from the in-memory key/value store by `key`. " +
+                "Returns a status `text` indicating whether a value existed and was removed.",
+            inputSchema: {
+                key: z.string()
+                    .describe("key identifier (non-empty string, up to 1024 characters)")
+            }
+        }, async (args) => {
+            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`;
+                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}` }] };
+            }
+        });
+    }
+}

package/dst/ase-mcp.js

@@ -9,7 +9,7 @@ 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-probe.js";
+import { SERVICE_HOST as HOST, serviceSchema, probe } from "./ase-service.js";
 /*  CLI command "ase mcp"  */
 export default class MCPCommand {
     log;
@@ -68,10 +68,12 @@ export default class MCPCommand {
                 return;
             bridgeDone = true;
             closedByUs = true;
-            await Promise.allSettled([
-                server.close(),
-                client?.close()
+            const timeout = new Promise((resolve) => setTimeout(resolve, 3000));
+            await Promise.race([
+                Promise.allSettled([server.close(), client?.close()]),
+                timeout
             ]);
+            process.exit(0);
         };
         /*  (re-)connect the HTTP client to the service  */
         const connectClient = async () => {
@@ -97,11 +99,13 @@ export default class MCPCommand {
             await next.start();
         };
         /*  reconnect loop: restart service if needed, then reconnect client  */
-        const reconnect = async (attempt = 0) => {
+        const reconnect = async (attempt = 0, done) => {
             const delay = Math.min(500 * 2 ** attempt, 10000);
             await new Promise((resolve) => setTimeout(resolve, delay));
-            if (bridgeDone)
+            if (bridgeDone) {
+                done?.();
                 return;
+            }
             try {
                 const ctx = await this.ensureService();
                 port = ctx.port;
@@ -110,11 +114,12 @@ export default class MCPCommand {
                 closedByUs = false;
                 await connectClient();
                 this.log.write("info", "mcp: reconnected to service");
+                done?.();
             }
             catch (_err) {
                 const err = _err instanceof Error ? _err : new Error(String(_err));
                 this.log.write("error", `mcp: reconnect failed: ${err.message}`);
-                reconnect(attempt + 1).catch(() => { });
+                reconnect(attempt + 1, done).catch(() => { });
             }
         };
         /*  wire stdio server  */
@@ -145,7 +150,7 @@ export default class MCPCommand {
                 if (match !== true) {
                     reconnecting = true;
                     this.log.write("warning", "mcp: health check failed — reconnecting");
-                    reconnect().catch(() => { }).finally(() => { reconnecting = false; });
+                    reconnect(0, () => { reconnecting = false; }).catch(() => { });
                 }
             }
             catch { /* ignore probe errors */ }

package/dst/ase-persona.js

@@ -0,0 +1,89 @@
+/*
+**  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 { isScalar } from "yaml";
+import { z } from "zod";
+import { Config, configSchema, parseScope } from "./ase-config.js";
+/*  reusable functionality: ASE agent persona style get/set  */
+export class Persona {
+    /*  allowed persona style values  */
+    static styles = ["writer", "engineer", "telegrapher", "caveman"];
+    /*  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 cfg = new Config("config", configSchema, log, scope);
+        cfg.read();
+        const val = cfg.get("agent.persona");
+        if (val === undefined)
+            return "engineer";
+        return String(isScalar(val) ? val.value : val);
+    }
+    /*  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 cfg = new Config("config", configSchema, log, scope);
+        cfg.lock(() => {
+            cfg.read();
+            cfg.set("agent.persona", style);
+            cfg.write();
+        });
+    }
+}
+/*  MCP registration entry point for persona tools  */
+export default class PersonaMCP {
+    log;
+    constructor(log) {
+        this.log = log;
+    }
+    register(mcp) {
+        mcp.registerTool("persona", {
+            title: "ASE persona style get/set",
+            description: "Get or set the active ASE agent persona `style`. " +
+                "If `style` is provided, it sets the persona style, " +
+                "otherwise it returns the current persona `style`. " +
+                "If `session` is provided, the operation is scoped to that session, " +
+                "otherwise it operates on the strongest/closest scope (user/project cascade). " +
+                "Allowed styles: \"writer\" (decorative, eloquent, explaining), " +
+                "\"engineer\" (brief, factual, accurate), " +
+                "\"telegrapher\" (very brief, factual, abbreviating), " +
+                "\"caveman\" (ultra brief, rough, stuttering).",
+            inputSchema: {
+                style: z.enum(Persona.styles).optional()
+                    .describe("persona style to set; if omitted, the current persona style is returned"),
+                session: z.string().optional()
+                    .describe("session identifier (allowed characters: A-Z, a-z, 0-9, '-'); " +
+                    "if omitted, the operation is not scoped to a specific session")
+            }
+        }, async (args) => {
+            try {
+                if (args.style !== undefined) {
+                    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}`;
+                    return {
+                        content: [{ type: "text", text: msg }]
+                    };
+                }
+                const text = Persona.get(this.log, args.session);
+                return {
+                    content: [{ type: "text", text }]
+                };
+            }
+            catch (err) {
+                const message = err instanceof Error ? err.message : String(err);
+                return {
+                    isError: true,
+                    content: [{ type: "text", text: `persona: ERROR: ${message}` }]
+                };
+            }
+        });
+    }
+}