@rse/ase 0.0.46 → 0.0.49

package/dst/ase-config.js

@@ -13,6 +13,7 @@ import * as v from "valibot";
 import Table from "cli-table3";
 import writeFileAtomic from "write-file-atomic";
 import lockfile from "proper-lockfile";
+import { z } from "zod";
 /*  classification taxonomy  */
 export const projectClassification = {
     boxing: ["white", "grey", "black"]
@@ -53,7 +54,8 @@ export const projectClassificationPresets = {
     (reads always cascade through the full chain; this restricts writes only);
     keys absent from this map default to all non-"default" scope kinds  */
 export const configWritableScopes = {
-    "agent.task": ["session"]
+    "agent.task": ["session"],
+    "agent.skill": ["session"]
 };
 /*  default set of scope kinds writable for any unrestricted key  */
 const configWritableScopesDefault = ["user", "project", "task", "session"];
@@ -132,7 +134,8 @@ export const configSchema = v.nullish(v.strictObject({
     })),
     agent: v.optional(v.strictObject({
         persona: v.optional(v.picklist(agentClassification.persona)),
-        task: v.optional(v.pipe(v.string(), v.minLength(1)))
+        task: v.optional(v.pipe(v.string(), v.minLength(1))),
+        skill: v.optional(v.pipe(v.string(), v.minLength(1)))
     }))
 }));
 /*  encapsulate read/write access to a stack of "<name>.yaml" configuration files,
@@ -333,10 +336,7 @@ export class Config {
                     doc.deleteIn(segs);
                     progressed = true;
                 }
-                else
-                    /*  root-level issue cannot be deleted; skip it and process
-                        remaining issues so progressed is tracked correctly  */
-                    continue;
+                /*  root-level issues cannot be deleted; processing continues with the remaining issues  */
             }
             if (!progressed)
                 return;
@@ -626,3 +626,100 @@ export default class ConfigCommand {
         });
     }
 }
+/*  MCP registration entry point for layered YAML configuration access  */
+export class ConfigMCP {
+    log;
+    constructor(log) {
+        this.log = log;
+    }
+    /*  register the MCP tools  */
+    register(mcp) {
+        /*  config get  */
+        mcp.registerTool("config_get", {
+            title: "ASE config get",
+            description: "Read the effective value of a dotted configuration `key` from the layered " +
+                "configuration, cascading through default/user/project/task/session chain up to and " +
+                "including the requested `scope`. Returns the value as JSON-encoded `text`; " +
+                "returns an empty string if no value is set.",
+            inputSchema: {
+                key: z.string()
+                    .describe("dotted configuration key (e.g. \"agent.skill\")"),
+                scope: z.string()
+                    .describe("scope chain (e.g. \"session:<id>\", \"task:<id>\", \"project\", \"user\")")
+            }
+        }, async (args) => {
+            try {
+                const scope = parseScope(args.scope);
+                const cfg = new Config("config", configSchema, this.log, scope);
+                let text = "";
+                cfg.lock(() => {
+                    cfg.read();
+                    const val = cfg.get(args.key);
+                    text = val === undefined ? "" : 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: `config_get: ERROR: ${message}` }] };
+            }
+        });
+        /*  config set  */
+        mcp.registerTool("config_set", {
+            title: "ASE config set",
+            description: "Write `val` to a dotted configuration `key` at the target `scope` " +
+                "(the strongest scope term in the chain). The value is validated against " +
+                "the configuration schema before being persisted.",
+            inputSchema: {
+                key: z.string()
+                    .describe("dotted configuration key (e.g. \"agent.skill\")"),
+                val: z.union([z.string(), z.number(), z.boolean(), z.null(), z.array(z.any()), z.record(z.string(), z.any())])
+                    .describe("value to store under `key`"),
+                scope: z.string()
+                    .describe("scope chain (e.g. \"session:<id>\", \"task:<id>\", \"project\", \"user\")")
+            }
+        }, async (args) => {
+            try {
+                const scope = parseScope(args.scope);
+                const cfg = new Config("config", configSchema, this.log, scope);
+                cfg.lock(() => {
+                    cfg.read();
+                    cfg.set(args.key, args.val);
+                    cfg.write();
+                });
+                return { content: [{ type: "text", text: `config_set: OK: stored "${args.key}" on scope "${args.scope}"` }] };
+            }
+            catch (err) {
+                const message = err instanceof Error ? err.message : String(err);
+                return { isError: true, content: [{ type: "text", text: `config_set: ERROR: ${message}` }] };
+            }
+        });
+        /*  config delete  */
+        mcp.registerTool("config_delete", {
+            title: "ASE config delete",
+            description: "Delete the value at a dotted configuration `key` from the target `scope` " +
+                "(the strongest scope term in the chain). No-op if the key is not present.",
+            inputSchema: {
+                key: z.string()
+                    .describe("dotted configuration key (e.g. \"agent.skill\")"),
+                scope: z.string()
+                    .describe("scope chain (e.g. \"session:<id>\", \"task:<id>\", \"project\", \"user\")")
+            }
+        }, async (args) => {
+            try {
+                const scope = parseScope(args.scope);
+                const cfg = new Config("config", configSchema, this.log, scope);
+                cfg.lock(() => {
+                    cfg.read();
+                    cfg.delete(args.key);
+                    cfg.write();
+                });
+                return { content: [{ type: "text", text: `config_delete: OK: removed "${args.key}" on scope "${args.scope}"` }] };
+            }
+            catch (err) {
+                const message = err instanceof Error ? err.message : String(err);
+                return { isError: true, content: [{ type: "text", text: `config_delete: ERROR: ${message}` }] };
+            }
+        });
+    }
+}

package/dst/ase-diagram.js

@@ -278,9 +278,9 @@ export class DiagramMCP {
                 "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, " +
+                "state-machine/states/transitions as a UML State Diagram, " +
+                "data-flow/actors/messages/protocols as a UML Sequence Diagram, " +
+                "data-structure/classes/methods as a UML Class Diagram, " +
                 "data-model/entities/relationships as an ER Diagram, or " +
                 "metrics/distributions/time-series as an XY-Chart. " +
                 "Pass the Mermaid diagram specification as `diagram`. " +

package/dst/ase-getopt.js

@@ -34,7 +34,11 @@ export class GetoptMCP {
                 /*  normalize args  */
                 const argsRaw = typeof args.args === "string" ? args.args : null;
                 const argsVec = typeof args.args === "string" ?
-                    shParse(args.args).filter((e) => typeof e === "string") :
+                    shParse(args.args)
+                        .map((e) => typeof e === "string" ? e :
+                        (e !== null && typeof e === "object" && "op" in e && e.op === "glob" ?
+                            e.pattern : null))
+                        .filter((e) => e !== null) :
                     args.args;
                 /*  build a fresh commander program  */
                 const cmd = new Command(args.name)
@@ -104,9 +108,9 @@ export class GetoptMCP {
                         }
                         ranges.push({ start, end: i });
                     }
-                    const tail = cmd.args.length;
-                    if (tail > 0 && ranges.length >= tail) {
-                        const first = ranges[ranges.length - tail].start;
+                    const consumed = argsVec.length - cmd.args.length;
+                    if (cmd.args.length > 0 && consumed >= 0 && consumed < ranges.length) {
+                        const first = ranges[consumed].start;
                         argsVerbatim = argsRaw.slice(first);
                     }
                 }

package/dst/ase-hook.js

@@ -8,6 +8,7 @@ import fs from "node:fs";
 import os from "node:os";
 import { execaSync } from "execa";
 import { quote } from "shell-quote";
+import * as v from "valibot";
 import Version from "./ase-version.js";
 import { Config, configSchema, parseScope } from "./ase-config.js";
 const toolSpecs = {
@@ -36,10 +37,36 @@ export default class HookCommand {
     constructor(log) {
         this.log = log;
     }
+    /*  validate a session id against the accepted character set  */
+    isValidSessionId(id) {
+        return /^[A-Za-z0-9._-]+$/.test(id);
+    }
+    /*  best-effort JSON parse with valibot schema validation: returns
+        an empty object on blank input, malformed JSON, or schema
+        mismatch, so callers can treat the result uniformly. Extra
+        properties in the data are tolerated; only the declared schema
+        entries are required to match.  */
+    parseJSON(text, schema) {
+        const empty = {};
+        if (text.trim() === "")
+            return empty;
+        let raw;
+        try {
+            raw = JSON.parse(text);
+        }
+        catch (_e) {
+            /*  best-effort: return empty object on malformed JSON  */
+            return empty;
+        }
+        const result = v.safeParse(schema, raw);
+        if (!result.success)
+            return empty;
+        return result.output;
+    }
     /*  recursively expand "@<path>" file references in a Markdown text,
         resolving paths relative to the directory of the containing file  */
     expandReferences(text, baseDir, visited = new Set()) {
-        return text.replace(/@([^\s]+)/g, (match, ref) => {
+        return text.replace(/@(\S+)/g, (match, ref) => {
             let resolved = ref;
             if (resolved.startsWith("~/"))
                 resolved = path.join(process.env.HOME ?? "", resolved.slice(2));
@@ -71,10 +98,23 @@ export default class HookCommand {
         const filePkg = path.join(pluginRoot, ".claude-plugin", "plugin.json");
         const fileMd = path.join(pluginRoot, "meta", "ase-constitution.md");
         /*  read external files  */
-        const pkg = fs.readFileSync(filePkg, "utf8");
-        let md = fs.readFileSync(fileMd, "utf8");
+        let pkg;
+        let md;
+        try {
+            pkg = fs.readFileSync(filePkg, "utf8");
+        }
+        catch (_e) {
+            throw new Error(`failed to read plugin manifest: ${filePkg}`);
+        }
+        try {
+            md = fs.readFileSync(fileMd, "utf8");
+        }
+        catch (_e) {
+            throw new Error(`failed to read constitution file: ${fileMd}`);
+        }
         /*  determine own version  */
-        const versionCurrentPlugin = JSON.parse(pkg).version ?? "";
+        const pkgObj = this.parseJSON(pkg, v.object({ version: v.optional(v.string()) }));
+        const versionCurrentPlugin = pkgObj.version ?? "";
         const versionCurrentTool = Version.current();
         const versionLatestTool = await Version.latest();
         /*  sanity check situation  */
@@ -90,11 +130,15 @@ export default class HookCommand {
         /*  read session information (Claude Code uses snake_case fields,
             Copilot CLI uses camelCase fields)  */
         const stdin = fs.readFileSync(0, "utf8");
-        const input = stdin.trim() !== "" ? JSON.parse(stdin) : {};
+        const input = this.parseJSON(stdin, v.object({
+            session_id: v.optional(v.string()),
+            sessionId: v.optional(v.string()),
+            cwd: v.optional(v.string())
+        }));
         /*  determine session id  */
-        const sessionId = input.session_id ?? input.sessionId ?? "";
+        const sessionId = this.pickSessionId(input);
         /*  establish config context (session-scoped only if a valid sessionId is present)  */
-        const hasSession = /^[A-Za-z0-9._-]+$/.test(sessionId);
+        const hasSession = this.isValidSessionId(sessionId);
         const cfg = new Config("config", configSchema, this.log, hasSession ? parseScope(`session:${sessionId}`) : parseScope(undefined));
         cfg.lock(() => {
             cfg.read();
@@ -196,18 +240,32 @@ export default class HookCommand {
     /*  handler for "ase hook stop" (both tools)  */
     doStop(_tool) {
         this.writeAgentStatus("ready");
+        /*  safety net: clear any lingering "agent.skill" marker so a
+            crashed or aborted skill loop does not leave information active  */
+        const sessionId = this.readSessionIdFromStdin();
+        if (this.isValidSessionId(sessionId)) {
+            try {
+                const cfg = new Config("config", configSchema, this.log, parseScope(`session:${sessionId}`));
+                cfg.lock(() => {
+                    cfg.read();
+                    if (typeof cfg.get("agent.skill") === "string") {
+                        cfg.delete("agent.skill");
+                        cfg.write();
+                    }
+                });
+            }
+            catch (_e) {
+                /*  best-effort: ignore failures  */
+            }
+        }
         return 0;
     }
     /*  handler for "ase hook session-end" (both tools)  */
     doSessionEnd(_tool) {
-        /*  read session information (Claude Code uses snake_case fields,
-            Copilot CLI uses camelCase fields)  */
-        const stdin = fs.readFileSync(0, "utf8");
-        const input = stdin.trim() !== "" ? JSON.parse(stdin) : {};
         /*  determine session id  */
-        const sessionId = input.session_id ?? input.sessionId ?? "";
+        const sessionId = this.readSessionIdFromStdin();
         /*  remove the session directory ~/.ase/session/<id> (only for a valid sessionId)  */
-        if (/^[A-Za-z0-9._-]+$/.test(sessionId)) {
+        if (this.isValidSessionId(sessionId)) {
             const dir = path.join(os.homedir(), ".ase", "session", sessionId);
             try {
                 fs.rmSync(dir, { recursive: true, force: true });
@@ -218,26 +276,59 @@ export default class HookCommand {
         }
         return 0;
     }
+    /*  pick the session id from a parsed payload (Claude Code uses
+        snake_case fields, Copilot CLI uses camelCase fields)  */
+    pickSessionId(input) {
+        return input.session_id ?? input.sessionId ?? "";
+    }
+    /*  read session id from stdin JSON payload  */
+    readSessionIdFromStdin() {
+        const stdin = fs.readFileSync(0, "utf8");
+        const input = this.parseJSON(stdin, v.object({
+            session_id: v.optional(v.string()),
+            sessionId: v.optional(v.string())
+        }));
+        return this.pickSessionId(input);
+    }
+    /*  read the session-scoped "agent.skill" config value  */
+    readActiveSkill(sessionId) {
+        if (!this.isValidSessionId(sessionId))
+            return "";
+        try {
+            const cfg = new Config("config", configSchema, this.log, parseScope(`session:${sessionId}`));
+            let val = "";
+            cfg.lock(() => {
+                cfg.read();
+                const skill = cfg.get("agent.skill");
+                if (typeof skill === "string")
+                    val = skill;
+            });
+            return val;
+        }
+        catch (_e) {
+            return "";
+        }
+    }
     /*  handler for "ase hook pre-tool-use" (both tools)  */
     doPreToolUse(tool) {
         const spec = toolSpecs[tool];
         /*  read tool invocation information  */
         const stdin = fs.readFileSync(0, "utf8");
-        const input = stdin.trim() !== "" ? JSON.parse(stdin) : {};
+        const input = this.parseJSON(stdin, v.looseObject({
+            session_id: v.optional(v.string()),
+            sessionId: v.optional(v.string())
+        }));
         /*  determine whether to auto-approve the tool invocation
             (field names and value shapes differ between tools)  */
         const toolName = typeof input[spec.toolNameField] === "string" ?
             input[spec.toolNameField] : "";
         let toolInput = {};
         const rawInput = input[spec.toolInputField];
-        if (spec.toolInputIsString && typeof rawInput === "string") {
-            try {
-                toolInput = JSON.parse(rawInput);
-            }
-            catch (_e) {
-                /*  best-effort: leave toolInput empty on parse failure  */
-            }
-        }
+        if (spec.toolInputIsString && typeof rawInput === "string")
+            toolInput = this.parseJSON(rawInput, v.object({
+                command: v.optional(v.string()),
+                skill: v.optional(v.string())
+            }));
         else if (!spec.toolInputIsString && typeof rawInput === "object" && rawInput !== null)
             toolInput = rawInput;
         let approve = false;
@@ -254,6 +345,14 @@ export default class HookCommand {
             approve = true;
             reason = "ASE MCP tool invocation auto-approved";
         }
+        else if (toolName === "Edit") {
+            const sessionId = this.pickSessionId(input);
+            const activeSkill = this.readActiveSkill(sessionId);
+            if (activeSkill === "ase-docs-proofread" || activeSkill === "ase-code-lint") {
+                approve = true;
+                reason = `${activeSkill}: user already consented via AskUserQuestion`;
+            }
+        }
         /*  emit permission decision (or stay silent to defer to default flow).
             Claude Code expects the decision nested in "hookSpecificOutput";
             Copilot CLI expects flat top-level fields.  */
@@ -282,7 +381,7 @@ export default class HookCommand {
     register(program) {
         /*  default for --tool derived from ASE_TOOL environment variable  */
         const envTool = process.env.ASE_TOOL ?? "";
-        const toolDflt = envTool !== "" ? envTool : "claude";
+        const toolDflt = envTool !== "" ? this.parseTool(envTool) : "claude";
         /*  register CLI top-level command "ase hook"  */
         const hookCmd = program
             .command("hook")

package/dst/ase-mcp.js

@@ -26,9 +26,9 @@ export default class MCPCommand {
         const projectId = rawId ?? path.basename(process.cwd());
         const rawPort = svc.get("port");
         const port = rawPort ?? null;
-        return { projectId, port, svc };
+        return { projectId, port };
     }
-    /*  spawn "ase service start" detached and wait for it to come up  */
+    /*  run "ase service start" and wait for the service to come up  */
     async ensureService() {
         let ctx = this.loadContext();
         /*  fast path: already running  */
@@ -52,6 +52,10 @@ export default class MCPCommand {
             throw new Error(`mcp: service not responding on port ${ctx.port} after start`);
         return { projectId: ctx.projectId, port: ctx.port };
     }
+    /*  coerce an unknown thrown value into an Error  */
+    asError(e) {
+        return e instanceof Error ? e : new Error(String(e));
+    }
     /*  bridge stdio to a Streamable HTTP MCP endpoint on the local service  */
     async runBridge() {
         /*  ensure the service is running  */
@@ -60,8 +64,9 @@ export default class MCPCommand {
         const server = new StdioServerTransport();
         /*  track active client and bridge-level closed state  */
         let client = null;
-        let closedByUs = false; /* set when we initiated the client close */
-        let bridgeDone = false; /* set when stdio side closes             */
+        let closedByUs = false; /*  set when we initiated the client close  */
+        let bridgeDone = false; /*  set when stdio side closes              */
+        let reconnecting = false; /*  set while a reconnect chain is active   */
         /*  cleanly shut down the whole bridge  */
         const shutdown = async () => {
             if (bridgeDone)
@@ -79,11 +84,9 @@ export default class MCPCommand {
         const connectClient = async () => {
             const url = new URL(`http://${HOST}:${port}/mcp`);
             const next = new StreamableHTTPClientTransport(url);
-            client = next;
             next.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}`);
+                server.send(msg).catch((err) => {
+                    this.log.write("error", `mcp: stdout send: ${this.asError(err).message}`);
                 });
             };
             next.onerror = (err) => {
@@ -91,12 +94,14 @@ export default class MCPCommand {
             };
             /*  service closed the connection — try to recover  */
             next.onclose = () => {
-                if (closedByUs || bridgeDone)
+                if (client !== next || closedByUs || bridgeDone || reconnecting)
                     return;
+                reconnecting = true;
                 this.log.write("warning", "mcp: http connection lost — reconnecting");
-                reconnect().catch(() => { });
+                reconnect(0, () => { reconnecting = false; }).catch(() => { });
             };
             await next.start();
+            client = next;
         };
         /*  reconnect loop: restart service if needed, then reconnect client  */
         const reconnect = async (attempt = 0, done) => {
@@ -111,22 +116,21 @@ export default class MCPCommand {
                 port = ctx.port;
                 closedByUs = true;
                 await client?.close();
-                closedByUs = false;
                 await connectClient();
+                closedByUs = false;
                 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}`);
+            catch (err) {
+                closedByUs = false;
+                this.log.write("error", `mcp: reconnect failed: ${this.asError(err).message}`);
                 reconnect(attempt + 1, done).catch(() => { });
             }
         };
         /*  wire stdio server  */
         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}`);
+            client?.send(msg).catch((err) => {
+                this.log.write("error", `mcp: http send: ${this.asError(err).message}`);
             });
         };
         server.onerror = (err) => {
@@ -140,7 +144,6 @@ export default class MCPCommand {
         await connectClient();
         /*  periodically probe the service; trigger reconnect if it is gone  */
         const HEALTH_INTERVAL_MS = 30_000;
-        let reconnecting = false;
         const healthTimer = setInterval(async () => {
             if (bridgeDone || reconnecting)
                 return;
@@ -153,7 +156,10 @@ export default class MCPCommand {
                     reconnect(0, () => { reconnecting = false; }).catch(() => { });
                 }
             }
-            catch { /* ignore probe errors */ }
+            catch (err) {
+                /*  ignore transient probe/context errors but record them  */
+                this.log.write("debug", `mcp: health check error: ${this.asError(err).message}`);
+            }
         }, HEALTH_INTERVAL_MS);
         healthTimer.unref();
         /*  await stdio to be closed  */
@@ -165,7 +171,7 @@ export default class MCPCommand {
         /*  shutdown services  */
         clearInterval(healthTimer);
         await shutdown();
-        return 0;
+        return 0; /*  unreachable, kept only to satisfy the Promise<number> return type  */
     }
     /*  register commands  */
     register(program) {

package/dst/ase-service.js

@@ -15,7 +15,7 @@ import prettyMs from "pretty-ms";
 import * as v from "valibot";
 import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
 import { StreamableHTTPServerTransport } from "@modelcontextprotocol/sdk/server/streamableHttp.js";
-import { Config, configSchema } from "./ase-config.js";
+import { Config, configSchema, ConfigMCP } from "./ase-config.js";
 import { DiagramMCP } from "./ase-diagram.js";
 import { TaskMCP } from "./ase-task.js";
 import { KVMCP } from "./ase-kv.js";
@@ -241,6 +241,7 @@ export default class ServiceCommand {
             new TimestampMCP().register(mcp);
             new GetoptMCP().register(mcp);
             new SkillsMCP().register(mcp);
+            new ConfigMCP(this.log).register(mcp);
             return mcp;
         };
         /*  listen to HTTP/REST endpoints  */
@@ -257,7 +258,13 @@ export default class ServiceCommand {
             handler: (_request, h) => {
                 this.log.write("info", "service: stop requested");
                 setImmediate(async () => {
-                    await server.stop({ timeout: 1000 });
+                    try {
+                        await server.stop({ timeout: 1000 });
+                    }
+                    catch (err) {
+                        const e = err;
+                        this.log.write("error", `service: stop failed: ${e.message}`);
+                    }
                     process.exit(0);
                 });
                 return h.response({ ok: true }).code(200);
@@ -438,7 +445,6 @@ export default class ServiceCommand {
                 lastErr = new Error(`${reason}${detail}`);
             }
             finally {
-                child.removeListener("exit", onExit);
                 if (!success && !exited) {
                     child.kill("SIGTERM");
                     await Promise.race([
@@ -454,6 +460,7 @@ export default class ServiceCommand {
                         child.unref();
                     }
                 }
+                child.removeListener("exit", onExit);
                 if (!success)
                     Service.clearPort(ctx.svc);
             }