dsh-agent-plugins-market 0.6.2 → 0.7.1

package/lib/application/project-agent-roles.js

@@ -1,5 +1,7 @@
 /** Resolve read-only project roles from the calling session, never from tool-supplied paths. */
 import { defaultMarkdownResources, resourceText } from '../catalog/component-files.js';
+import { pluginRootOf } from '../catalog/plugin-variables.js';
+import { suiteDataDir } from '../catalog/paths.js';
 import { parseAgentRole } from '../runtime/agent-role-router.js';
 export async function projectAgentRoles(catalog, parent) {
     const cwd = parent?.session?.header?.cwd;
@@ -8,8 +10,10 @@ export async function projectAgentRoles(catalog, parent) {
     const snapshot = await catalog.readProjectCatalog(cwd);
     const entries = [];
     for (const suite of snapshot.enabledSuites) {
-        if (suite.activeSurfaces?.agents === false)
+        if (suite.activeSurfaces.agents === false)
             continue;
+        const suiteRoot = pluginRootOf(suite);
+        const suiteData = suiteRoot === undefined ? undefined : suiteDataDir(catalog.dataRoot, suite.sourceId, suite.id);
         for (const resource of suite.resources?.agents ?? (await defaultMarkdownResources(suite.root, 'agents'))) {
             const path = resource.file;
             const rawText = await resourceText(resource).catch(error => {
@@ -27,7 +31,9 @@ export async function projectAgentRoles(catalog, parent) {
                     rawText,
                     title: policy.title ?? resource.name.replace(/\.agent$/, ''),
                     description: policy.description ?? `${suite.manifest.name}: ${resource.name}`,
-                    disabled: policy.disabled
+                    disabled: policy.disabled,
+                    ...(suiteRoot === undefined ? {} : { suiteRoot }),
+                    ...(suiteData === undefined ? {} : { suiteData })
                 });
             }
             catch {

package/lib/application/snapshot-cache.js

@@ -0,0 +1,160 @@
+/**
+ * Discovery caching: one scan cache shared by every dimension, plus a
+ * freshness-bounded snapshot per dimension.
+ *
+ * Install / enable / surface toggles re-derive a snapshot from cached
+ * discovery (a cheap mapping) instead of re-walking every checkout — a full
+ * rescan of a 2,500-suite catalog costs ~1s and UI mutations happen in bursts.
+ * Content-changing mutations (add / update / remove / adopt / refresh /
+ * acquire) clear every cached discovery generation; the TTL bounds staleness
+ * for in-place working-tree edits of local sources.
+ */
+import { join, resolve } from 'node:path';
+import { resolveProjectRoot, STATE_FILE_NAME } from '../catalog/paths.js';
+import { discoverSourceListWithNotes } from '../catalog/source-catalog.js';
+import { loadState } from '../runtime/state-store.js';
+export const SCAN_CACHE_TTL_MS = 30_000;
+const SCAN_CACHE_MAX_ENTRIES = 8;
+export class SnapshotCache {
+    host;
+    ttls;
+    scanCache = new Map();
+    scanPromises = new Map();
+    userSnapshot;
+    userSnapshotExpiresAt = 0;
+    userSnapshotPromise;
+    /** Project-dimension snapshots keyed by project root, with TTL freshness. */
+    projectSnapshots = new Map();
+    projectSnapshotPromises = new Map();
+    constructor(host, ttls) {
+        this.host = host;
+        this.ttls = ttls;
+    }
+    /** Read one coherent user-dimension snapshot, reusing in-flight discovery. */
+    async readUserCatalog() {
+        // TTL 0 disables snapshot caching: every read observes fresh discovery,
+        // mirroring the project dimension's caching-disabled semantics.
+        if (this.ttls.user <= 0)
+            return this.build(this.host.state, 'user', this.host.userRoot);
+        if (this.userSnapshot !== undefined && Date.now() < this.userSnapshotExpiresAt)
+            return this.userSnapshot;
+        if (this.userSnapshotPromise !== undefined)
+            return this.userSnapshotPromise;
+        const revision = this.host.revision;
+        const generation = this.host.scanGeneration;
+        const promise = this.build(this.host.state, 'user', this.host.userRoot)
+            .then(snapshot => {
+            if (revision === this.host.revision && generation === this.host.scanGeneration) {
+                this.userSnapshot = snapshot;
+                this.userSnapshotExpiresAt = Date.now() + this.ttls.user;
+            }
+            return snapshot;
+        })
+            .finally(() => {
+            if (this.userSnapshotPromise === promise)
+                this.userSnapshotPromise = undefined;
+        });
+        this.userSnapshotPromise = promise;
+        return promise;
+    }
+    /** Read one coherent project-dimension snapshot for a workspace cwd. */
+    async readProjectCatalog(cwd) {
+        const projectRoot = await resolveProjectRoot(cwd);
+        // A cwd with no `.git` ancestor resolves to itself as its own project root,
+        // so a session started in the harness home lands on the user dimension root.
+        // That directory is the user's catalog, not a project's: reading it would
+        // present every user-level suite as a project suite of that one session.
+        if (resolve(projectRoot) === resolve(this.host.userRoot)) {
+            return { revision: this.host.revision, sources: [], suites: [], enabledSuites: [] };
+        }
+        if (this.ttls.project <= 0)
+            return this.buildProjectSnapshot(projectRoot);
+        const cached = this.projectSnapshots.get(projectRoot);
+        if (cached !== undefined && cached.expiresAt > Date.now())
+            return cached.snapshot;
+        const inFlight = this.projectSnapshotPromises.get(projectRoot);
+        if (inFlight !== undefined)
+            return inFlight;
+        const revision = this.host.revision;
+        const generation = this.host.scanGeneration;
+        const promise = this.buildProjectSnapshot(projectRoot)
+            .then(snapshot => {
+            if (revision === this.host.revision && generation === this.host.scanGeneration) {
+                this.projectSnapshots.set(projectRoot, { snapshot, expiresAt: Date.now() + this.ttls.project });
+            }
+            return snapshot;
+        })
+            .finally(() => {
+            if (this.projectSnapshotPromises.get(projectRoot) === promise)
+                this.projectSnapshotPromises.delete(projectRoot);
+        });
+        this.projectSnapshotPromises.set(projectRoot, promise);
+        return promise;
+    }
+    /** One snapshot for a dimension root, reusing cached discovery when it is fresh. */
+    async build(state, dimension, dimensionRoot, skipScanCache = false) {
+        const fingerprint = JSON.stringify([dimension, dimensionRoot, state.sources, this.host.scanProjectLayouts]);
+        const cached = this.scanCache.get(fingerprint);
+        // The user snapshot's TTL also bounds scan reuse: a snapshot rebuild that
+        // replays a 30s scan cache would silently outlive its own staleness bound.
+        const scanCacheTtl = dimension === 'user' ? Math.min(this.ttls.user, SCAN_CACHE_TTL_MS) : SCAN_CACHE_TTL_MS;
+        const cacheFresh = !skipScanCache && cached !== undefined && Date.now() - cached.at < scanCacheTtl;
+        let discovered;
+        let scanNotes;
+        if (cacheFresh && cached !== undefined) {
+            discovered = cached.discovered;
+            scanNotes = cached.scanNotes;
+        }
+        else {
+            const generation = this.host.scanGeneration;
+            let pending = this.scanPromises.get(fingerprint);
+            if (pending === undefined) {
+                pending = discoverSourceListWithNotes(state.sources, dimension, dimensionRoot, this.host.scanProjectLayouts);
+                this.scanPromises.set(fingerprint, pending);
+            }
+            let result;
+            try {
+                result = await pending;
+            }
+            finally {
+                if (this.scanPromises.get(fingerprint) === pending)
+                    this.scanPromises.delete(fingerprint);
+            }
+            discovered = result.suites;
+            scanNotes = result.scanNotes;
+            // A scan started before a content mutation must not repopulate its cache.
+            if (generation === this.host.scanGeneration) {
+                if (this.scanCache.size >= SCAN_CACHE_MAX_ENTRIES)
+                    this.scanCache.clear();
+                this.scanCache.set(fingerprint, { at: Date.now(), discovered, scanNotes });
+            }
+        }
+        const suites = this.host.project(discovered, state, dimension);
+        return {
+            revision: this.host.revision,
+            sources: [...state.sources],
+            suites,
+            enabledSuites: suites.filter(suite => suite.enabled),
+            ...(Object.keys(scanNotes).length > 0 ? { scanNotes } : {})
+        };
+    }
+    /** Drop every cached dimension snapshot and its in-flight dedupe slot. */
+    invalidateSnapshots() {
+        this.userSnapshot = undefined;
+        this.userSnapshotExpiresAt = 0;
+        this.userSnapshotPromise = undefined;
+        this.projectSnapshots.clear();
+        this.projectSnapshotPromises.clear();
+    }
+    /** Drop cached discovery and its in-flight dedupe slots. */
+    invalidateScans() {
+        this.scanCache.clear();
+        this.scanPromises.clear();
+    }
+    async buildProjectSnapshot(projectRoot) {
+        const state = await loadState(join(projectRoot, STATE_FILE_NAME));
+        // TTL 0 means caching is disabled for this dimension: bypass the scan
+        // cache so every read observes the working tree as it stands.
+        return this.build(state, 'project', projectRoot, this.ttls.project <= 0);
+    }
+}