@rse/ase 1.0.6 → 2.0.0

package/dst/{ase-skills.js → ase-service-skills.js}

@@ -46,10 +46,12 @@ export class Skills {
                     repository = r.url;
                 deps = Object.keys(verEntry.dependencies ?? {}).length;
             }
-            return { version, time, repository, deps };
+            const created = time.created ?? "";
+            const updated = version !== "" ? (time[version] ?? "") : "";
+            return { version, created, updated, repository, deps };
         }
         catch {
-            return { version: "", time: {}, repository: "", deps: "N.A." };
+            return { version: "", created: "", updated: "", repository: "", deps: "N.A." };
         }
     }
     /*  fetch GitHub stars given a repository URL (or empty string)  */
@@ -199,73 +201,36 @@ export class Skills {
         -   "Java"/"Kotlin":           Maven Central + GitHub stars + mvnrepository.com "Used By"
         -   "Unknown":                 not supported -- return empty result  */
     static async info(stack, components, staleMonths = 18, smallScope = false) {
-        if (stack === "JavaScript" || stack === "TypeScript") {
-            /*  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, p.deps, staleMonths, smallScope);
-                return {
-                    name,
-                    version: p.version,
-                    created,
-                    updated,
-                    repository: p.repository,
-                    stars,
-                    downloads,
-                    deps: p.deps,
-                    rank
-                };
-            }));
-            /*  sort by rank in descending order (best first)  */
-            results.sort((a, b) => b.rank - a.rank);
-            return results;
-        }
-        else if (stack === "Java" || stack === "Kotlin") {
-            /*  per coordinate: kick off Maven Central info and mvnrepository
-                downloads in parallel, then stars as soon as the POM-derived
-                repository is known; across coordinates everything runs
-                concurrently via Promise.all  */
-            const results = await Promise.all(components.map(async (name) => {
-                const infoPromise = Skills.fetchMavenInfo(name);
-                const downloadsPromise = Skills.fetchMavenDownloads(name);
-                const starsPromise = infoPromise.then((i) => Skills.fetchStars(i.repository));
-                const [i, downloads, stars] = await Promise.all([
-                    infoPromise, downloadsPromise, starsPromise
-                ]);
-                const rank = Skills.computeRank(downloads, stars, i.created, i.updated, i.deps, staleMonths, smallScope);
-                return {
-                    name,
-                    version: i.version,
-                    created: i.created,
-                    updated: i.updated,
-                    repository: i.repository,
-                    stars,
-                    downloads,
-                    deps: i.deps,
-                    rank
-                };
-            }));
-            /*  sort by rank in descending order (best first)  */
-            results.sort((a, b) => b.rank - a.rank);
-            return results;
-        }
-        else
+        /*  select the per-stack metadata and downloads fetchers  */
+        const fetchers = stack === "JavaScript" || stack === "TypeScript" ?
+            { meta: Skills.fetchPackument, downloads: Skills.fetchDownloads } :
+            stack === "Java" || stack === "Kotlin" ?
+                { meta: Skills.fetchMavenInfo, downloads: Skills.fetchMavenDownloads } :
+                null;
+        if (fetchers === null)
             return [];
+        /*  per component: kick off metadata and downloads in parallel,
+            then stars as soon as the repository is known; across components
+            everything runs concurrently via Promise.all  */
+        const results = await Promise.all(components.map(async (name) => {
+            const metaPromise = fetchers.meta(name);
+            const downloadsPromise = fetchers.downloads(name);
+            const starsPromise = metaPromise.then((m) => Skills.fetchStars(m.repository));
+            const [m, downloads, stars] = await Promise.all([
+                metaPromise, downloadsPromise, starsPromise
+            ]);
+            const rank = Skills.computeRank(downloads, stars, m.created, m.updated, m.deps, staleMonths, smallScope);
+            return { name, ...m, 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 + 1) x
         (stars + 1) x
         ([lifespan =] (updated - created)) x
-        ([recentness =] exp(-(now - updated) / halfLife))
+        ([recentness =] 0.5 ^ ((now - updated) / halfLife))
         Numeric count metrics are shifted by `+1` so that a genuine `0`
         (e.g. a real package with zero downloads or stars) contributes a
         neutral `1` instead of collapsing the entire product to zero, while
@@ -296,7 +261,7 @@ export class Skills {
             one half-life (`0.5`), a conservative midpoint that keeps the
             entry rankable without rewarding the missing date.  */
         const lifespan = (!Number.isNaN(cMs) && !Number.isNaN(uMs)) ? Math.max(1, uMs - cMs) : 1;
-        const recentness = !Number.isNaN(uMs) ? Math.exp(-Math.max(0, (now - uMs) / msPerDay) / halfLife) : 0.5;
+        const recentness = !Number.isNaN(uMs) ? 0.5 ** (Math.max(0, (now - uMs) / msPerDay) / halfLife) : 0.5;
         let rank = d * s * lifespan * recentness;
         /*  hard, caller-tunable staleness penalty on top of the soft
             `recentness` decay: unlike the smooth exp-decay above, this is a

package/dst/ase-service-state.js

@@ -0,0 +1,101 @@
+/*
+**  Agentic Software Engineering (ASE)
+**  Copyright (c) 2025-2026 Dr. Ralf S. Engelschall <rse@engelschall.com>
+**  Licensed under Apache 2.0 <https://spdx.org/licenses/Apache-2.0>
+*/
+import { z } from "zod";
+import { sessionState } from "./ase-config-core.js";
+/*  the keys of the internal session state  */
+const stateKeys = ["basedir", "task", "skill"];
+/*  render a caught error as an MCP tool error result  */
+const mcpToolError = (err) => ({
+    isError: true,
+    content: [{ type: "text", text: `ERROR: ${err instanceof Error ? err.message : String(err)}` }]
+});
+/*  MCP registration entry point for the internal session state access  */
+export class StateMCP {
+    log;
+    constructor(log) {
+        this.log = log;
+    }
+    /*  register the MCP tools  */
+    register(mcp) {
+        /*  state get  */
+        mcp.registerTool("ase_state_get", {
+            title: "ASE state get",
+            description: "Read the value of a `key` from the internal state of a `session`: " +
+                "`basedir` (the project directory, recorded for GitHub Copilot CLI only), " +
+                "`task` (the id of the active task), or `skill` (the id of the active " +
+                "edit-capable skill). Returns the value as `text`; returns an empty string " +
+                "if no value is set.",
+            inputSchema: {
+                key: z.enum(stateKeys)
+                    .describe("state key (\"basedir\", \"task\", or \"skill\")"),
+                session: z.string()
+                    .describe("session identifier (allowed characters: A-Z, a-z, 0-9, '.', '_', '-')")
+            }
+        }, async (args) => {
+            try {
+                const state = sessionState(this.log, args.session);
+                state.read();
+                const val = state.get(args.key);
+                return { content: [{ type: "text", text: typeof val === "string" ? val : "" }] };
+            }
+            catch (err) {
+                return mcpToolError(err);
+            }
+        });
+        /*  state set  */
+        mcp.registerTool("ase_state_set", {
+            title: "ASE state set",
+            description: "Write the non-empty `val` to a `key` of the internal state of a `session`. " +
+                "The value is validated against the state schema before being persisted.",
+            inputSchema: {
+                key: z.enum(stateKeys)
+                    .describe("state key (\"basedir\", \"task\", or \"skill\")"),
+                val: z.string().min(1)
+                    .describe("value to store under `key`"),
+                session: z.string()
+                    .describe("session identifier (allowed characters: A-Z, a-z, 0-9, '.', '_', '-')")
+            }
+        }, async (args) => {
+            try {
+                const state = sessionState(this.log, args.session);
+                state.lock(() => {
+                    state.read();
+                    state.set(args.key, args.val);
+                    state.write();
+                });
+                return { content: [{ type: "text", text: `OK: stored "${args.key}" for session "${args.session}"` }] };
+            }
+            catch (err) {
+                return mcpToolError(err);
+            }
+        });
+        /*  state delete  */
+        mcp.registerTool("ase_state_delete", {
+            title: "ASE state delete",
+            description: "Delete the value of a `key` from the internal state of a `session`. " +
+                "No-op if the key is not present.",
+            inputSchema: {
+                key: z.enum(stateKeys)
+                    .describe("state key (\"basedir\", \"task\", or \"skill\")"),
+                session: z.string()
+                    .describe("session identifier (allowed characters: A-Z, a-z, 0-9, '.', '_', '-')")
+            }
+        }, async (args) => {
+            try {
+                const state = sessionState(this.log, args.session);
+                state.lock(() => {
+                    state.read();
+                    state.delete(args.key);
+                    state.write();
+                });
+                return { content: [{ type: "text", text: `OK: removed "${args.key}" for session "${args.session}"` }] };
+            }
+            catch (err) {
+                return mcpToolError(err);
+            }
+        });
+    }
+}