@rse/ase 0.0.40 → 0.0.42

package/dst/ase-config.js

@@ -485,6 +485,8 @@ export class Config {
     delete(key) {
         this.assertWritable(key);
         const td = this.docs[this.target];
+        if (td.doc.contents === null || td.doc.contents === undefined)
+            return;
         const next = td.doc.clone();
         next.deleteIn(this.resolveKey(key).split("."));
         const saved = td.doc;

package/dst/ase-decision.js

@@ -0,0 +1,67 @@
+/*
+**  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: weighted multi-criteria decision matrix  */
+export class Decision {
+    /*  compute the per-alternative product-sum (rating) row from a
+        weighted decision matrix. Each input row has the shape
+        `[weight, eval_1, eval_2, ..., eval_N]`. For each alternative
+        column j (1..N), the result is the sum over all rows K of
+        `weight_K * eval_K_j`. The output array has length N.  */
+    static productSum(matrix) {
+        if (matrix.length === 0)
+            return [];
+        const cols = matrix[0].length;
+        if (cols < 2)
+            throw new Error("each row must contain a weight followed by at least one evaluation column");
+        const N = cols - 1;
+        const ratings = new Array(N).fill(0);
+        for (let i = 0; i < matrix.length; i++) {
+            const row = matrix[i];
+            if (row.length !== cols)
+                throw new Error(`row ${i} has ${row.length} columns, expected ${cols}`);
+            const weight = row[0];
+            for (let j = 0; j < N; j++)
+                ratings[j] += weight * row[j + 1];
+        }
+        return ratings;
+    }
+}
+/*  MCP registration entry point for the decision-matrix tool  */
+export class DecisionMCP {
+    register(mcp) {
+        mcp.registerTool("decision_matrix", {
+            title: "ASE decision matrix",
+            description: "Compute the per-alternative product-sum (rating) row of a weighted " +
+                "multi-criteria decision matrix. The input `matrix` is an array of rows, " +
+                "one row per criterion, where each row has the shape " +
+                "`[weight, eval_1, eval_2, ..., eval_N]` (i.e. the criterion weight " +
+                "followed by N evaluation values, one per alternative). For each " +
+                "alternative column j (1..N), the result is the sum over all rows K of " +
+                "`weight_K * eval_K_j`. Returns a JSON `text` array of length N with " +
+                "the raw, unrounded ratings (one per alternative, in the same column " +
+                "order as the input).",
+            inputSchema: {
+                matrix: z.array(z.array(z.number()))
+                    .describe("Decision matrix rows: each row is `[weight, eval_1, ..., eval_N]`")
+            }
+        }, async (args) => {
+            try {
+                const result = Decision.productSum(args.matrix);
+                return {
+                    content: [{ type: "text", text: JSON.stringify(result) }]
+                };
+            }
+            catch (err) {
+                const message = err instanceof Error ? err.message : String(err);
+                return {
+                    isError: true,
+                    content: [{ type: "text", text: `ERROR: ${message}` }]
+                };
+            }
+        });
+    }
+}

package/dst/ase-kv.js

@@ -17,6 +17,11 @@ export class KV {
     static validateKey(key) {
         if (typeof key !== "string" || key.length === 0)
             throw new Error("kv: key must be a non-empty string");
+        if (key.trim().length === 0)
+            throw new Error("kv: key must not consist solely of whitespace");
+        /* eslint-disable-next-line no-control-regex */
+        if (/[\x00-\x1F\x7F]/.test(key))
+            throw new Error("kv: key must not contain control characters");
         if (key.length > KV.KEY_MAX_LEN)
             throw new Error(`kv: key must be no longer than ${KV.KEY_MAX_LEN} characters`);
     }
@@ -33,7 +38,7 @@ export class KV {
     /*  set a value under the given key; overwrites any existing value  */
     static set(key, val) {
         KV.validateKey(key);
-        KV.store.set(key, val);
+        KV.store.set(key, structuredClone(val));
     }
     /*  delete a value by key; returns true if a value existed  */
     static delete(key) {
@@ -46,6 +51,16 @@ export class KV {
         KV.store.clear();
         return n;
     }
+    /*  snapshot the entire store into a fresh map (for transactional batch)  */
+    static snapshot() {
+        return new Map(KV.store);
+    }
+    /*  restore the store from a previously taken snapshot  */
+    static restore(snap) {
+        KV.store.clear();
+        for (const [k, v] of snap)
+            KV.store.set(k, v);
+    }
 }
 /*  MCP registration entry point for in-memory key/value tools  */
 export class KVMCP {
@@ -57,14 +72,14 @@ export class KVMCP {
                 "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)")
+                    .describe("key identifier (non-empty, no whitespace-only, no control characters, 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);
+                const text = val === undefined ? "" : JSON.stringify(val);
                 return { content: [{ type: "text", text }] };
             }
             catch (err) {
@@ -80,8 +95,8 @@ export class KVMCP {
                 "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("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())])
                     .describe("arbitrary JSON-compatible value to store under `key`")
             }
         }, async (args) => {
@@ -117,7 +132,7 @@ export class KVMCP {
                 "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)")
+                    .describe("key identifier (non-empty, no whitespace-only, no control characters, up to 1024 characters)")
             }
         }, async (args) => {
             try {
@@ -132,5 +147,89 @@ export class KVMCP {
                 return { isError: true, content: [{ type: "text", text: `kv_delete: ERROR: ${message}` }] };
             }
         });
+        /*  key/value batch  */
+        mcp.registerTool("kv_batch", {
+            title: "ASE key/value batch",
+            description: "Execute an array of in-memory key/value `commands` in a single MCP call. " +
+                "Each entry is an object `{ command: \"clear\"|\"set\"|\"get\"|\"delete\", key?, val? }` " +
+                "and is dispatched to the corresponding single-op tool. " +
+                "If `transactional` is true, the store is snapshotted up-front and rolled back on the " +
+                "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`. " +
+                "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>`.",
+            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()
+                        .describe("value to store (required for `set`)")
+                }))
+                    .describe("ordered list of KV commands to execute"),
+                transactional: z.boolean().optional()
+                    .describe("if true, snapshot the store and roll back on first error")
+            }
+        }, 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();
+                        results.push(`kv_clear: OK: removed ${n} key(s)`);
+                        cmdNames.push("clear");
+                    }
+                    else if (c.command === "set") {
+                        if (c.key === undefined)
+                            throw new Error("kv_set: missing `key`");
+                        if (c.val === undefined)
+                            throw new Error("kv_set: missing `val`");
+                        KV.set(c.key, c.val);
+                        results.push(`kv_set: OK: stored key "${c.key}"`);
+                        cmdNames.push("set");
+                    }
+                    else if (c.command === "get") {
+                        if (c.key === undefined)
+                            throw new Error("kv_get: 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`");
+                        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");
+                    }
+                }
+                catch (err) {
+                    const message = err instanceof Error ? err.message : String(err);
+                    if (tx) {
+                        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}`);
+                        return { isError: true, content: [{ type: "text", text: JSON.stringify(results) }] };
+                    }
+                    results.push(`kv_${c.command}: ERROR: ${message}`);
+                }
+            }
+            return { content: [{ type: "text", text: JSON.stringify(results) }] };
+        });
     }
 }

package/dst/ase-service.js

@@ -9,7 +9,7 @@ import net from "node:net";
 import { fileURLToPath } from "node:url";
 import { spawn } from "node:child_process";
 import Hapi from "@hapi/hapi";
-import axios from "axios";
+import { ofetch } from "ofetch";
 import { isMap } from "yaml";
 import prettyMs from "pretty-ms";
 import * as v from "valibot";
@@ -22,6 +22,7 @@ import { KVMCP } from "./ase-kv.js";
 import PersonaMCP from "./ase-persona.js";
 import { TimestampMCP } from "./ase-timestamp.js";
 import { GetoptMCP } from "./ase-getopt.js";
+import { SkillsMCP } from "./ase-skills.js";
 import pkg from "../package.json" with { type: "json" };
 /*  shared service host  */
 export const SERVICE_HOST = "127.0.0.1";
@@ -30,23 +31,24 @@ const HOST = SERVICE_HOST;
 export 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  */
+/*  distinguish ECONNREFUSED from other ofetch transport errors  */
 export const isConnRefused = (err) => {
     const e = err;
-    return e?.code === "ECONNREFUSED" || e?.cause?.code === "ECONNREFUSED";
+    return e?.code === "ECONNREFUSED"
+        || e?.cause?.code === "ECONNREFUSED"
+        || e?.cause?.cause?.code === "ECONNREFUSED";
 };
 /*  probe the service and verify ASE identity banner  */
 export const probe = async (port, projectId) => {
     try {
-        const r = await axios.request({
+        const r = await ofetch.raw(`http://${SERVICE_HOST}:${port}/`, {
             method: "OPTIONS",
-            url: `http://${SERVICE_HOST}:${port}/`,
-            timeout: 2000,
-            validateStatus: () => true
+            signal: AbortSignal.timeout(2000),
+            ignoreResponseError: true
         });
         if (r.status < 200 || r.status >= 300)
             return false;
-        const d = r.data;
+        const d = r._data;
         return d?.ase === true && d?.projectId === projectId;
     }
     catch (err) {
@@ -238,6 +240,7 @@ export default class ServiceCommand {
             new PersonaMCP(this.log).register(mcp);
             new TimestampMCP().register(mcp);
             new GetoptMCP().register(mcp);
+            new SkillsMCP().register(mcp);
             return mcp;
         };
         /*  listen to HTTP/REST endpoints  */
@@ -466,15 +469,14 @@ export default class ServiceCommand {
         }
         const match = await probe(ctx.port, ctx.projectId);
         if (match === true) {
-            const r = await axios.request({
+            const r = await ofetch.raw(`http://${HOST}:${ctx.port}/command`, {
                 method: "POST",
-                url: `http://${HOST}:${ctx.port}/command`,
                 headers: { "Content-Type": "application/json" },
-                data: { command: "status" },
-                timeout: 2000,
-                validateStatus: () => true
+                body: { command: "status" },
+                signal: AbortSignal.timeout(2000),
+                ignoreResponseError: true
             });
-            const d = r.data;
+            const d = r._data;
             const uptimeMs = typeof d?.uptimeMs === "number" ? d.uptimeMs : 0;
             const uptime = prettyMs(uptimeMs, { verbose: true });
             process.stdout.write(`service: running on port ${ctx.port} (uptime: ${uptime})\n`);
@@ -503,17 +505,15 @@ export default class ServiceCommand {
             if (ctx.port === null)
                 throw new Error("service not running (no port configured after auto-start)");
         }
-        const r = await axios.request({
+        const r = await ofetch.raw(`http://${HOST}:${ctx.port}/command`, {
             method: "POST",
-            url: `http://${HOST}:${ctx.port}/command`,
             headers: { "Content-Type": "application/json" },
-            data: { command: cmd },
-            timeout: 5000,
-            validateStatus: () => true,
-            responseType: "text",
-            transformResponse: [(x) => x]
+            body: { command: cmd },
+            signal: AbortSignal.timeout(5000),
+            ignoreResponseError: true,
+            responseType: "text"
         });
-        const body = typeof r.data === "string" ? r.data : JSON.stringify(r.data);
+        const body = typeof r._data === "string" ? r._data : JSON.stringify(r._data);
         process.stdout.write(body);
         if (!body.endsWith("\n"))
             process.stdout.write("\n");
@@ -536,11 +536,10 @@ export default class ServiceCommand {
             Service.clearPort(ctx.svc);
             return 0;
         }
-        const r = await axios.request({
+        const r = await ofetch.raw(`http://${HOST}:${ctx.port}/stop`, {
             method: "GET",
-            url: `http://${HOST}:${ctx.port}/stop`,
-            timeout: 5000,
-            validateStatus: () => true
+            signal: AbortSignal.timeout(5000),
+            ignoreResponseError: true
         });
         const ok = r.status >= 200 && r.status < 300;
         Service.clearPort(ctx.svc);

package/dst/ase-skills.js

@@ -0,0 +1,224 @@
+/*
+**  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";
+import { ofetch } from "ofetch";
+import pacote from "pacote";
+/*  reusable functionality: gather per-package metadata in maximum parallel  */
+export class Skills {
+    /*  HTTP timeout for the GitHub/npm-downloads side calls  */
+    static HTTP_TIMEOUT_MS = 10_000;
+    /*  cap concurrent ofetch web requests to avoid hammering the remote
+        endpoints (GitHub API, npm downloads API)  */
+    static HTTP_CONCURRENCY = 4;
+    static httpActive = 0;
+    static httpQueue = [];
+    static async httpLimit(fn) {
+        if (Skills.httpActive >= Skills.HTTP_CONCURRENCY)
+            await new Promise((resolve) => Skills.httpQueue.push(resolve));
+        Skills.httpActive++;
+        try {
+            return await fn();
+        }
+        finally {
+            Skills.httpActive--;
+            const next = Skills.httpQueue.shift();
+            if (next !== undefined)
+                next();
+        }
+    }
+    /*  fetch the full registry packument for a single package  */
+    static async fetchPackument(name) {
+        try {
+            const pkg = await pacote.packument(name, { fullMetadata: true });
+            const version = pkg["dist-tags"]?.latest ?? "";
+            const time = pkg.time ?? {};
+            const verEntry = version !== "" ? pkg.versions?.[version] : undefined;
+            let repository = "";
+            if (verEntry !== undefined) {
+                const r = verEntry.repository;
+                if (typeof r === "string")
+                    repository = r;
+                else if (r !== undefined && typeof r.url === "string")
+                    repository = r.url;
+            }
+            return { version, time, repository };
+        }
+        catch {
+            return { version: "", time: {}, repository: "" };
+        }
+    }
+    /*  fetch GitHub stars given a repository URL (or empty string)  */
+    static async fetchStars(repository) {
+        const m = /^.+?\/\/github\.com\/([^/]+\/[^/#?]+?)(?:\.git)?(?:[/#?].*)?$/.exec(repository);
+        if (m === null)
+            return "N.A.";
+        try {
+            const data = await Skills.httpLimit(() => ofetch(`https://api.github.com/repos/${m[1]}`, { timeout: Skills.HTTP_TIMEOUT_MS, ignoreResponseError: true }));
+            const n = data?.stargazers_count;
+            return typeof n === "number" ? n : "N.A.";
+        }
+        catch {
+            return "N.A.";
+        }
+    }
+    /*  fetch last-month npm downloads for a single package  */
+    static async fetchDownloads(name) {
+        try {
+            const data = await Skills.httpLimit(() => ofetch(`https://api.npmjs.org/downloads/point/last-month/${encodeURIComponent(name)}`, { timeout: Skills.HTTP_TIMEOUT_MS, ignoreResponseError: true }));
+            const n = data?.downloads;
+            return typeof n === "number" ? n : "N.A.";
+        }
+        catch {
+            return "N.A.";
+        }
+    }
+    /*  gather metadata for all given components in maximum parallel,
+        dispatching on the technology stack:
+        -   "JavaScript"/"TypeScript": NPM registry (pacote) + GitHub stars + npm-downloads
+        -   "Java"/"Kotlin"/"Unknown": not yet supported -- return empty result  */
+    static async info(stack, components) {
+        /*  FIXME: currently just limited technology stack support  */
+        if (stack !== "JavaScript" && stack !== "TypeScript")
+            return [];
+        /*  per package: kick off packument and downloads in parallel,
+            then stars as soon as the packument resolves; across packages
+            everything runs concurrently via Promise.all  */
+        const results = await Promise.all(components.map(async (name) => {
+            const packumentPromise = Skills.fetchPackument(name);
+            const downloadsPromise = Skills.fetchDownloads(name);
+            const starsPromise = packumentPromise.then((p) => Skills.fetchStars(p.repository));
+            const [p, downloads, stars] = await Promise.all([
+                packumentPromise, downloadsPromise, starsPromise
+            ]);
+            const created = p.time.created ?? "";
+            const updated = p.version !== "" ? (p.time[p.version] ?? "") : "";
+            const rank = Skills.computeRank(downloads, stars, created, updated);
+            return {
+                name,
+                version: p.version,
+                created,
+                updated,
+                repository: p.repository,
+                stars,
+                downloads,
+                rank
+            };
+        }));
+        /*  sort by rank in descending order (best first)  */
+        results.sort((a, b) => b.rank - a.rank);
+        return results;
+    }
+    /*  compute composite rank score from weighted metrics:
+        downloads x
+        stars x
+        ([lifespan =] (updated - created)) x
+        ([recentness =] exp(-(now - updated) / halfLife))  */
+    static computeRank(downloads, stars, created, updated) {
+        const d = typeof downloads === "number" ? downloads : 0;
+        const s = typeof stars === "number" ? stars : 0;
+        const cMs = created !== "" ? Date.parse(created) : NaN;
+        const uMs = updated !== "" ? Date.parse(updated) : NaN;
+        if (Number.isNaN(cMs) || Number.isNaN(uMs))
+            return 0;
+        const now = Date.now();
+        const msPerDay = 1000 * 60 * 60 * 24;
+        const halfLife = 365 / 2;
+        const lifespan = Math.max(0, uMs - cMs);
+        const ageDays = Math.max(0, (now - uMs) / msPerDay);
+        const recentness = Math.exp(-ageDays / halfLife);
+        return d * s * lifespan * recentness;
+    }
+    /*  compute the per-alternative product-sum (rating) row from a
+        weighted decision matrix. Each input row has the shape
+        `[ weight, eval_1, eval_2, ..., eval_N ]`. For each alternative
+        column j (1..N), the result is the sum over all rows K of
+        `weight_K * eval_K_j`. The output array has length N.  */
+    static productSum(matrix) {
+        if (matrix.length === 0)
+            return [];
+        const cols = matrix[0].length;
+        if (cols < 2)
+            throw new Error("each row must contain a weight followed by at least one evaluation column");
+        const N = cols - 1;
+        const ratings = new Array(N).fill(0);
+        for (let i = 0; i < matrix.length; i++) {
+            const row = matrix[i];
+            if (row.length !== cols)
+                throw new Error(`row ${i} has ${row.length} columns, expected ${cols}`);
+            const weight = row[0];
+            for (let j = 0; j < N; j++)
+                ratings[j] += weight * row[j + 1];
+        }
+        return ratings;
+    }
+}
+/*  MCP registration entry point for various skill helper tools  */
+export class SkillsMCP {
+    register(mcp) {
+        mcp.registerTool("component_info", {
+            title: "ASE component info",
+            description: "Gather metadata for a list of NPM packages in maximum parallel. " +
+                "For each package, fetches the full registry packument via `pacote` " +
+                "(in-process, no `npm view` subprocess), the GitHub `stargazers_count` " +
+                "from `api.github.com` (if the repository points to GitHub), and the " +
+                "last-month downloads from `api.npmjs.org`. Returns a JSON `text` array " +
+                "of `{ name, version, created, updated, repository, stars, downloads, rank }` " +
+                "objects, sorted in descending order by `rank`. Failures of " +
+                "individual side calls are isolated and reported as `\"N.A.\"` or empty " +
+                "string so every entry has the full shape.",
+            inputSchema: {
+                stack: z.string()
+                    .describe("Technology stack: \"JavaScript\", \"TypeScript\", \"Java\", \"Kotlin\", or \"Unknown\""),
+                components: z.array(z.string())
+                    .describe("List of package names to gather metadata for")
+            }
+        }, async (args) => {
+            try {
+                const result = await Skills.info(args.stack, args.components);
+                return {
+                    content: [{ type: "text", text: JSON.stringify(result) }]
+                };
+            }
+            catch (err) {
+                const message = err instanceof Error ? err.message : String(err);
+                return {
+                    isError: true,
+                    content: [{ type: "text", text: `ERROR: ${message}` }]
+                };
+            }
+        });
+        mcp.registerTool("decision_matrix", {
+            title: "ASE decision matrix",
+            description: "Compute the per-alternative product-sum (rating) row of a weighted " +
+                "multi-criteria decision matrix. The input `matrix` is an array of rows, " +
+                "one row per criterion, where each row has the shape " +
+                "`[ weight, eval_1, eval_2, ..., eval_N ]` (i.e. the criterion weight " +
+                "followed by N evaluation values, one per alternative). For each " +
+                "alternative column j (1..N), the result is the sum over all rows K of " +
+                "`weight_K * eval_K_j`. Returns a JSON `text` array of length N with " +
+                "the raw, unrounded ratings (one per alternative, in the same column " +
+                "order as the input).",
+            inputSchema: {
+                matrix: z.array(z.array(z.number()))
+                    .describe("Decision matrix rows: each row is `[weight, eval_1, ..., eval_N]`")
+            }
+        }, async (args) => {
+            try {
+                const result = Skills.productSum(args.matrix);
+                return {
+                    content: [{ type: "text", text: JSON.stringify(result) }]
+                };
+            }
+            catch (err) {
+                const message = err instanceof Error ? err.message : String(err);
+                return {
+                    isError: true,
+                    content: [{ type: "text", text: `ERROR: ${message}` }]
+                };
+            }
+        });
+    }
+}

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.40",
+    "version":                              "0.0.42",
     "license":                              "GPL-3.0-only",
     "author": {
         "name":                             "Dr. Ralf S. Engelschall",
@@ -36,7 +36,8 @@
         "@types/update-notifier":           "6.0.8",
         "@types/shell-quote":               "1.7.5",
         "@types/proper-lockfile":           "4.1.4",
-        "@types/write-file-atomic":         "4.0.3"
+        "@types/write-file-atomic":         "4.0.3",
+        "@types/pacote":                    "11.1.8"
     },
     "dependencies": {
         "commander":                        "14.0.3",
@@ -45,7 +46,6 @@
         "execa":                            "9.6.1",
         "mkdirp":                           "3.0.1",
         "@hapi/hapi":                       "21.4.9",
-        "axios":                            "1.16.1",
         "beautiful-mermaid":                "1.1.3",
         "cli-table3":                       "0.6.5",
         "chalk":                            "5.6.2",
@@ -57,7 +57,9 @@
         "update-notifier":                  "7.3.1",
         "shell-quote":                      "1.8.3",
         "proper-lockfile":                  "4.1.2",
-        "write-file-atomic":                "4.0.0"
+        "write-file-atomic":                "4.0.0",
+        "pacote":                           "21.5.0",
+        "ofetch":                           "1.4.1"
     },
     "engines": {
         "npm":                              ">=10.0.0",

package/plugin/.claude-plugin/plugin.json

@@ -1,6 +1,6 @@
 {
     "name":        "ase",
-    "version":     "0.0.40",
+    "version":     "0.0.42",
     "description": "Agentic Software Engineering (ASE)",
     "keywords":    [ "agentic", "software", "engineering" ],
     "homepage":    "https://ase.tools",

package/plugin/.github/plugin/plugin.json

@@ -1,6 +1,6 @@
 {
     "name":        "ase",
-    "version":     "0.0.40",
+    "version":     "0.0.42",
     "description": "Agentic Software Engineering (ASE)",
     "keywords":    [ "agentic", "software", "engineering" ],
     "homepage":    "https://ase.tools",

package/plugin/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.40",
+    "version":                              "0.0.42",
     "license":                              "GPL-3.0-only",
     "author": {
         "name":                             "Dr. Ralf S. Engelschall",

package/plugin/skills/ase-arch-analyze/SKILL.md

@@ -100,7 +100,6 @@ allowed-tools:
 ---
 
 @${CLAUDE_SKILL_DIR}/../../meta/ase-control.md
-@${CLAUDE_SKILL_DIR}/../../meta/ase-persona.md
 @${CLAUDE_SKILL_DIR}/../../meta/ase-skill.md
 
 Review Software Architecture