@dbx-tools/appkit-mastra 0.9.74 → 0.9.79

package/lib/src/skill-cache.js

@@ -1,194 +1,251 @@
 /**
- * AppKit-backed caching for Databricks workspace skill mounts.
+ * User-scoped workspace skill catalogues cached as one semantic record.
  *
  * @module
  */
-import { randomUUID } from "node:crypto";
 import { CacheManager } from "@databricks/appkit";
-import { hash, object } from "@dbx-tools/shared-core";
-import { filesystems } from "./filesystems.js";
-const CACHE_NAMESPACE = "mastra:workspace-skills";
-const DEFAULT_MAX_SCOPED_MOUNTS = 256;
-const scopedMounts = new Map();
-/** Default remote skill metadata and content cache lifetime. */
+import { errorUtils, log, object } from "@dbx-tools/shared-core";
+import { posixPath } from "@dbx-tools/shared-fs";
+import { LRUCache } from "lru-cache";
+import { parse as parseYaml } from "yaml";
+import { z } from "zod";
+const CACHE_NAMESPACE = "mastra:workspace-skill-catalogue";
+const CATALOGUE_VERSION = 1;
+const MAX_SCOPED_CATALOGUES = 256;
+const logger = log.logger("mastra/skill-cache");
+const SkillCatalogueEntrySchema = z
+    .object({
+    name: z.string().describe("Unique skill name from SKILL.md frontmatter."),
+    description: z.string().describe("Skill description from SKILL.md frontmatter."),
+    instructions: z.string().describe("Markdown instructions below SKILL.md frontmatter."),
+    sourceId: z.string().describe("Identity of the mounted source that owns this skill."),
+    sourcePath: z.string().describe("Path to SKILL.md relative to its source root."),
+    signature: z
+        .string()
+        .optional()
+        .describe("Stable metadata signature used to retain unchanged instructions."),
+})
+    .describe("One parsed skill in a materialized workspace catalogue.");
+const SkillCatalogueSchema = z
+    .object({
+    version: z.literal(CATALOGUE_VERSION).describe("Persisted catalogue schema version."),
+    generatedAt: z.string().datetime().describe("Time the catalogue was last refreshed."),
+    roots: z.array(z.string()).describe("Ordered source identities included in the catalogue."),
+    skills: z
+        .array(SkillCatalogueEntrySchema)
+        .describe("Parsed skills after ordered duplicate-name precedence is applied."),
+})
+    .describe("One user-scoped materialized workspace skill catalogue.");
+const scopedCatalogues = new LRUCache({
+    max: MAX_SCOPED_CATALOGUES,
+});
+/** Default lifetime for one complete workspace skill catalogue. */
 export const DEFAULT_WORKSPACE_SKILL_CACHE_TTL_MS = 5 * 60 * 1000;
-/**
- * Cache read-only filesystem operations through AppKit while delegating
- * mutations to the current request's source.
- */
-export class AppKitCachedFileSystem {
-    backend = "appkit-cache";
-    id;
-    readOnly;
-    root;
-    source;
+/** Materialized catalogue with one AppKit cache record and fresh auxiliary reads. */
+export class WorkspaceSkillCatalogue {
+    options;
+    cacheKey;
     host;
-    ttlSec;
     userKey;
+    lastValid;
+    ttlMs;
+    sources;
     constructor(options) {
+        this.options = options;
         this.host = options.host;
-        this.source = options.source;
-        this.root = options.source.root;
-        this.readOnly = options.source.readOnly;
-        this.ttlSec = cacheTtlSec(options.ttlMs);
         this.userKey = options.userKey;
-        this.id = `appkit-skill-cache-${hash.fnvHash(this.host, this.userKey, this.root)}`;
+        this.sources = options.sources;
+        this.ttlMs = positiveTtl(options.ttlMs);
+        this.cacheKey = object.toStableKey({
+            host: options.host,
+            roots: options.sources.map(({ id }) => id),
+            userKey: options.userKey,
+            version: CATALOGUE_VERSION,
+        });
     }
-    /** Rebind cache misses and writes to the current request's OBO filesystem. */
-    bind(source) {
-        if (source.root !== this.root || source.readOnly !== this.readOnly) {
-            throw new Error("Cannot rebind a workspace skill cache to a different filesystem scope");
+    /** Rebind refreshes and lazy reads to the current request's filesystem clients. */
+    bind(sources) {
+        const identities = sources.map(({ id }) => id);
+        if (object.toStableKey(identities) !== object.toStableKey(this.sources.map(({ id }) => id))) {
+            throw new Error("Cannot rebind a skill catalogue to a different ordered root set");
+        }
+        this.sources = sources;
+    }
+    /** Return the cached catalogue, refreshing all roots once on cache miss. */
+    async get(signal) {
+        const cache = CacheManager.getInstanceSync();
+        try {
+            const catalogue = SkillCatalogueSchema.parse(await cache.getOrExecute([CACHE_NAMESPACE, CATALOGUE_VERSION, this.options.host, this.rootKey()], () => this.refresh(), this.options.userKey, {
+                ttl: Math.max(1, Math.ceil(this.ttlMs / 1000)),
+                callerSignal: signal,
+            }));
+            this.lastValid = catalogue;
+            return catalogue;
+        }
+        catch (error) {
+            if (!this.lastValid)
+                throw error;
+            logger.warn("skill catalogue refresh failed; retaining last valid catalogue", {
+                error: errorUtils.errorMessage(error),
+                roots: this.sources.map(({ id }) => id),
+            });
+            return this.lastValid;
         }
-        this.source = source;
-    }
-    async init() {
-        await this.source.init();
-    }
-    /** Keep the shared scope alive when one request releases its workspace view. */
-    close() {
-        return Promise.resolve();
-    }
-    resolvePath(inputPath) {
-        return this.source.resolvePath(inputPath);
-    }
-    async readFile(inputPath, options) {
-        const value = await this.cached("readFile", inputPath, undefined, async (source) => ({
-            base64: Buffer.from(await source.readFile(inputPath)).toString("base64"),
-        }));
-        const bytes = Buffer.from(value.base64, "base64");
-        return options?.encoding ? bytes.toString(options.encoding) : bytes;
-    }
-    async writeFile(inputPath, content, options) {
-        await this.mutate((source) => source.writeFile(inputPath, content, options));
-    }
-    async appendFile(inputPath, content) {
-        await this.mutate((source) => source.appendFile(inputPath, content));
-    }
-    async deleteFile(inputPath, options) {
-        await this.mutate((source) => source.deleteFile(inputPath, options));
-    }
-    async copyFile(sourcePath, destinationPath, options) {
-        await this.mutate((source) => source.copyFile(sourcePath, destinationPath, options));
-    }
-    async moveFile(sourcePath, destinationPath, options) {
-        await this.mutate((source) => source.moveFile(sourcePath, destinationPath, options));
-    }
-    async mkdir(inputPath, options) {
-        await this.mutate((source) => source.mkdir(inputPath, options));
-    }
-    async rmdir(inputPath, options) {
-        await this.mutate((source) => source.rmdir(inputPath, options));
-    }
-    async readdir(inputPath, options) {
-        return this.cached("readdir", inputPath, options, (source) => source.readdir(inputPath, options));
-    }
-    async exists(inputPath) {
-        return this.cached("exists", inputPath, undefined, (source) => source.exists(inputPath));
-    }
-    async stat(inputPath) {
-        const value = await this.cached("stat", inputPath, undefined, async (source) => serializeStat(await source.stat(inputPath)));
-        return deserializeStat(value);
     }
-    /** Rotate this scope's cache generation so the next read reloads it. */
+    /** Expire this complete catalogue without touching unrelated cache entries. */
     async invalidate() {
-        const cache = await CacheManager.getInstance();
-        await cache.set(this.generationKey(cache), randomUUID(), {
-            ttl: this.ttlSec * 2,
+        const cache = CacheManager.getInstanceSync();
+        await cache.delete(this.persistentKey(cache));
+    }
+    /** Read one selected skill's auxiliary file directly from its current source. */
+    async readSkillFile(skillName, inputPath, signal) {
+        signal?.throwIfAborted();
+        const catalogue = await this.get(signal);
+        const skill = catalogue.skills.find(({ name }) => name === skillName);
+        if (!skill)
+            throw new Error(`Unknown skill: ${skillName}`);
+        const normalized = posixPath.normalize(inputPath);
+        if (!normalized.ok ||
+            normalized.path === "/" ||
+            inputPath.split("/").some((segment) => segment === "..")) {
+            throw new Error(`Invalid skill file path: ${inputPath}`);
+        }
+        const source = this.sources.find(({ id }) => id === skill.sourceId);
+        if (!source)
+            throw new Error(`Skill source is no longer mounted: ${skill.sourceId}`);
+        const parent = skill.sourcePath.split("/").slice(0, -1).join("/");
+        const path = [parent, normalized.path.replace(/^\/+/, "")].filter(Boolean).join("/");
+        return source.read(path);
+    }
+    async refresh() {
+        const previous = new Map(this.lastValid?.skills.map((skill) => [`${skill.sourceId}\0${skill.sourcePath}`, skill]) ?? []);
+        const selected = new Map();
+        for (const source of this.sources) {
+            for (const candidate of await discoverSkillFiles(source)) {
+                const prior = previous.get(`${source.id}\0${candidate.path}`);
+                const signature = fileSignature(candidate.entry);
+                let parsed;
+                if (signature && prior?.signature === signature) {
+                    parsed = prior;
+                }
+                else {
+                    parsed = parseSkill(await source.read(candidate.path), candidate.path);
+                }
+                if (!parsed || selected.has(parsed.name))
+                    continue;
+                selected.set(parsed.name, {
+                    ...parsed,
+                    sourceId: source.id,
+                    sourcePath: candidate.path,
+                    ...(signature ? { signature } : {}),
+                });
+            }
+        }
+        return SkillCatalogueSchema.parse({
+            version: CATALOGUE_VERSION,
+            generatedAt: new Date().toISOString(),
+            roots: this.sources.map(({ id }) => id),
+            skills: [...selected.values()],
         });
     }
-    async cached(operation, inputPath, options, load) {
-        const source = this.source;
-        const cache = await CacheManager.getInstance();
-        const generation = await this.generation(cache);
-        return cache.getOrExecute([
-            CACHE_NAMESPACE,
-            this.host,
-            this.root,
-            generation,
-            operation,
-            source.resolvePath(inputPath),
-            object.toStableKey(options ?? {}),
-        ], () => load(source), this.userKey, { ttl: this.ttlSec });
-    }
-    async generation(cache) {
-        return cache.getOrExecute([CACHE_NAMESPACE, "generation", this.host, this.root], async () => randomUUID(), this.userKey, { ttl: this.ttlSec * 2 });
-    }
-    generationKey(cache) {
-        return cache.generateKey([CACHE_NAMESPACE, "generation", this.host, this.root], this.userKey);
+    rootKey() {
+        return object.toStableKey(this.sources.map(({ id }) => id));
     }
-    async mutate(run) {
-        const source = this.source;
-        await run(source);
-        await this.invalidate();
+    persistentKey(cache) {
+        return cache.generateKey([CACHE_NAMESPACE, CATALOGUE_VERSION, this.options.host, this.rootKey()], this.options.userKey);
     }
 }
-/** Return one stable Mastra mount per resolved user, host, and source root. */
-export function cachedWorkspaceSkillMount(options) {
-    const cacheKey = object.toStableKey({
+/** Return one stable catalogue owner for a user, host, and ordered root set. */
+export function workspaceSkillCatalogue(options) {
+    const key = object.toStableKey({
         host: options.host,
-        readOnly: options.source.readOnly,
-        root: options.source.root,
+        roots: options.sources.map(({ id }) => id),
         userKey: options.userKey,
     });
-    const existing = scopedMounts.get(cacheKey);
+    const existing = scopedCatalogues.get(key);
     if (existing) {
-        existing.cache.bind(options.source);
-        scopedMounts.delete(cacheKey);
-        scopedMounts.set(cacheKey, existing);
-        return { cacheKey, filesystem: existing.adapter };
+        existing.bind(options.sources);
+        return existing;
     }
-    const cache = new AppKitCachedFileSystem(options);
-    const entry = {
-        adapter: filesystems(cache, {
-            id: cache.id,
-            readOnly: options.source.readOnly,
-        }),
-        cache,
-        host: options.host,
-        root: options.source.root,
-        userKey: options.userKey,
-    };
-    scopedMounts.set(cacheKey, entry);
-    trimScopedMounts();
-    return { cacheKey, filesystem: entry.adapter };
+    const catalogue = new WorkspaceSkillCatalogue(options);
+    scopedCatalogues.set(key, catalogue);
+    return catalogue;
 }
-/** Invalidate one user's cached workspace skill scope. */
+/** Invalidate matching complete catalogues and retain their stable owners. */
 export async function clearWorkspaceSkillCache(options) {
-    const matches = [...scopedMounts.entries()].filter(([, entry]) => entry.host === options.host &&
-        entry.userKey === options.userKey &&
-        (options.root === undefined || entry.root === options.root));
-    await Promise.all(matches.map(([, entry]) => entry.cache.invalidate()));
+    const matches = [...scopedCatalogues.values()].filter((catalogue) => catalogue.host === options.host &&
+        (options.userKey === undefined || catalogue.userKey === options.userKey));
+    await Promise.all(matches.map((catalogue) => catalogue.invalidate()));
 }
-function cacheTtlSec(ttlMs = DEFAULT_WORKSPACE_SKILL_CACHE_TTL_MS) {
-    if (!Number.isFinite(ttlMs) || ttlMs <= 0) {
-        throw new Error("Workspace skill cache ttlMs must be a positive finite number");
-    }
-    return Math.max(1, Math.ceil(ttlMs / 1000));
+async function discoverSkillFiles(source) {
+    let rootEntries;
+    try {
+        rootEntries = await source.list(".");
+    }
+    catch (error) {
+        if (errorUtils.errorContext(error).notAccessible)
+            return [];
+        throw error;
+    }
+    const candidates = [];
+    const rootSkill = rootEntries.find(({ name, type }) => name.toLowerCase() === "skill.md" && type === "file");
+    if (rootSkill)
+        candidates.push({ entry: rootSkill, path: rootSkill.name });
+    await Promise.all(rootEntries
+        .filter(({ type }) => type === "directory")
+        .map(async (directory) => {
+        const entries = await source.list(directory.name);
+        const skill = entries.find(({ name, type }) => name.toLowerCase() === "skill.md" && type === "file");
+        if (skill)
+            candidates.push({ entry: skill, path: posixPath.join(directory.name, skill.name) });
+    }));
+    return candidates.sort((left, right) => left.path.localeCompare(right.path));
 }
-function serializeStat(value) {
-    const { accessedAt, createdAt, modifiedAt, ...stat } = value;
+function parseSkill(source, path) {
+    const match = /^---\s*\r?\n([\s\S]*?)\r?\n---\s*(?:\r?\n|$)([\s\S]*)$/.exec(source);
+    if (!match) {
+        logger.warn("skill skipped (missing YAML frontmatter)", { path });
+        return undefined;
+    }
+    const metadata = parseYaml(match[1]);
+    if (!object.isRecord(metadata)) {
+        logger.warn("skill skipped (invalid YAML frontmatter)", { path });
+        return undefined;
+    }
+    const parsed = z
+        .object({
+        name: z.string().trim().min(1),
+        description: z.string().trim().min(1),
+    })
+        .safeParse(metadata);
+    if (!parsed.success) {
+        logger.warn("skill skipped (invalid metadata)", {
+            path,
+            error: parsed.error.message,
+        });
+        return undefined;
+    }
     return {
-        ...stat,
-        ...(accessedAt ? { accessedAt: accessedAt.getTime() } : {}),
-        ...(createdAt ? { createdAt: createdAt.getTime() } : {}),
-        ...(modifiedAt ? { modifiedAt: modifiedAt.getTime() } : {}),
+        name: parsed.data.name,
+        description: parsed.data.description,
+        instructions: match[2].trim(),
     };
 }
-function deserializeStat(value) {
-    const { accessedAt, createdAt, modifiedAt, ...stat } = value;
-    return {
-        ...stat,
-        ...(accessedAt !== undefined ? { accessedAt: new Date(accessedAt) } : {}),
-        ...(createdAt !== undefined ? { createdAt: new Date(createdAt) } : {}),
-        ...(modifiedAt !== undefined ? { modifiedAt: new Date(modifiedAt) } : {}),
+function fileSignature(entry) {
+    const metadata = object.isRecord(entry.metadata) ? entry.metadata : {};
+    const values = {
+        modifiedAt: metadata.modifiedAt,
+        objectId: metadata.objectId,
+        size: entry.size,
     };
+    return Object.values(values).some((value) => value !== undefined)
+        ? object.toStableKey(values)
+        : undefined;
 }
-function trimScopedMounts() {
-    while (scopedMounts.size > DEFAULT_MAX_SCOPED_MOUNTS) {
-        const oldest = scopedMounts.keys().next().value;
-        if (oldest === undefined)
-            return;
-        scopedMounts.delete(oldest);
+function positiveTtl(value = DEFAULT_WORKSPACE_SKILL_CACHE_TTL_MS) {
+    if (!Number.isFinite(value) || value <= 0) {
+        throw new RangeError("Workspace skill catalogue ttlMs must be a positive finite number");
     }
+    return value;
 }
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"skill-cache.js","sourceRoot":"","sources":["../../src/skill-cache.ts"],"names":[],"mappings":"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","sourcesContent":["/**\n * AppKit-backed caching for Databricks workspace skill mounts.\n *\n * @module\n */\n\nimport { randomUUID } from \"node:crypto\";\nimport { CacheManager } from \"@databricks/appkit\";\nimport { hash, object } from \"@dbx-tools/shared-core\";\nimport type {\n  CopyOptions,\n  FileContent,\n  FileEntry,\n  FileStat,\n  FileSystem,\n  ListOptions,\n  MakeDirectoryOptions,\n  ReadFileOptions,\n  RemoveOptions,\n  WriteFileOptions,\n} from \"@dbx-tools/shared-fs\";\n\nimport { filesystems, type MastraFileSystemAdapter } from \"./filesystems.ts\";\n\nconst CACHE_NAMESPACE = \"mastra:workspace-skills\";\nconst DEFAULT_MAX_SCOPED_MOUNTS = 256;\n\ninterface CachedFileStat extends Omit<FileStat, \"accessedAt\" | \"createdAt\" | \"modifiedAt\"> {\n  accessedAt?: number;\n  createdAt?: number;\n  modifiedAt?: number;\n}\n\ninterface ScopedMountEntry {\n  adapter: MastraFileSystemAdapter;\n  cache: AppKitCachedFileSystem;\n  host: string;\n  root: string;\n  userKey: string;\n}\n\nconst scopedMounts = new Map<string, ScopedMountEntry>();\n\n/** Default remote skill metadata and content cache lifetime. */\nexport const DEFAULT_WORKSPACE_SKILL_CACHE_TTL_MS = 5 * 60 * 1000;\n\n/** Options for one AppKit-cached workspace skill filesystem. */\nexport interface AppKitCachedFileSystemOptions {\n  host: string;\n  source: FileSystem;\n  ttlMs?: number;\n  userKey: string;\n}\n\n/** Stable Mastra mount plus the identity key used for source reuse. */\nexport interface CachedWorkspaceSkillMount {\n  cacheKey: string;\n  filesystem: MastraFileSystemAdapter;\n}\n\n/**\n * Cache read-only filesystem operations through AppKit while delegating\n * mutations to the current request's source.\n */\nexport class AppKitCachedFileSystem implements FileSystem<\"appkit-cache\"> {\n  readonly backend = \"appkit-cache\" as const;\n  readonly id: string;\n  readonly readOnly: boolean;\n  readonly root: string;\n\n  private source: FileSystem;\n  private readonly host: string;\n  private readonly ttlSec: number;\n  private readonly userKey: string;\n\n  constructor(options: AppKitCachedFileSystemOptions) {\n    this.host = options.host;\n    this.source = options.source;\n    this.root = options.source.root;\n    this.readOnly = options.source.readOnly;\n    this.ttlSec = cacheTtlSec(options.ttlMs);\n    this.userKey = options.userKey;\n    this.id = `appkit-skill-cache-${hash.fnvHash(this.host, this.userKey, this.root)}`;\n  }\n\n  /** Rebind cache misses and writes to the current request's OBO filesystem. */\n  bind(source: FileSystem): void {\n    if (source.root !== this.root || source.readOnly !== this.readOnly) {\n      throw new Error(\"Cannot rebind a workspace skill cache to a different filesystem scope\");\n    }\n    this.source = source;\n  }\n\n  async init(): Promise<void> {\n    await this.source.init();\n  }\n\n  /** Keep the shared scope alive when one request releases its workspace view. */\n  close(): Promise<void> {\n    return Promise.resolve();\n  }\n\n  resolvePath(inputPath: string): string {\n    return this.source.resolvePath(inputPath);\n  }\n\n  async readFile(inputPath: string): Promise<Uint8Array>;\n  async readFile(\n    inputPath: string,\n    options: ReadFileOptions & { encoding: string },\n  ): Promise<string>;\n  async readFile(inputPath: string, options?: ReadFileOptions): Promise<string | Uint8Array> {\n    const value = await this.cached(\"readFile\", inputPath, undefined, async (source) => ({\n      base64: Buffer.from(await source.readFile(inputPath)).toString(\"base64\"),\n    }));\n    const bytes = Buffer.from(value.base64, \"base64\");\n    return options?.encoding ? bytes.toString(options.encoding as BufferEncoding) : bytes;\n  }\n\n  async writeFile(\n    inputPath: string,\n    content: FileContent,\n    options?: WriteFileOptions,\n  ): Promise<void> {\n    await this.mutate((source) => source.writeFile(inputPath, content, options));\n  }\n\n  async appendFile(inputPath: string, content: FileContent): Promise<void> {\n    await this.mutate((source) => source.appendFile(inputPath, content));\n  }\n\n  async deleteFile(inputPath: string, options?: RemoveOptions): Promise<void> {\n    await this.mutate((source) => source.deleteFile(inputPath, options));\n  }\n\n  async copyFile(\n    sourcePath: string,\n    destinationPath: string,\n    options?: CopyOptions,\n  ): Promise<void> {\n    await this.mutate((source) => source.copyFile(sourcePath, destinationPath, options));\n  }\n\n  async moveFile(\n    sourcePath: string,\n    destinationPath: string,\n    options?: CopyOptions,\n  ): Promise<void> {\n    await this.mutate((source) => source.moveFile(sourcePath, destinationPath, options));\n  }\n\n  async mkdir(inputPath: string, options?: MakeDirectoryOptions): Promise<void> {\n    await this.mutate((source) => source.mkdir(inputPath, options));\n  }\n\n  async rmdir(inputPath: string, options?: RemoveOptions): Promise<void> {\n    await this.mutate((source) => source.rmdir(inputPath, options));\n  }\n\n  async readdir(inputPath: string, options?: ListOptions): Promise<FileEntry[]> {\n    return this.cached(\"readdir\", inputPath, options, (source) =>\n      source.readdir(inputPath, options),\n    );\n  }\n\n  async exists(inputPath: string): Promise<boolean> {\n    return this.cached(\"exists\", inputPath, undefined, (source) => source.exists(inputPath));\n  }\n\n  async stat(inputPath: string): Promise<FileStat> {\n    const value = await this.cached(\"stat\", inputPath, undefined, async (source) =>\n      serializeStat(await source.stat(inputPath)),\n    );\n    return deserializeStat(value);\n  }\n\n  /** Rotate this scope's cache generation so the next read reloads it. */\n  async invalidate(): Promise<void> {\n    const cache = await CacheManager.getInstance();\n    await cache.set(this.generationKey(cache), randomUUID(), {\n      ttl: this.ttlSec * 2,\n    });\n  }\n\n  private async cached<T>(\n    operation: string,\n    inputPath: string,\n    options: unknown,\n    load: (source: FileSystem) => Promise<T>,\n  ): Promise<T> {\n    const source = this.source;\n    const cache = await CacheManager.getInstance();\n    const generation = await this.generation(cache);\n    return cache.getOrExecute(\n      [\n        CACHE_NAMESPACE,\n        this.host,\n        this.root,\n        generation,\n        operation,\n        source.resolvePath(inputPath),\n        object.toStableKey(options ?? {}),\n      ],\n      () => load(source),\n      this.userKey,\n      { ttl: this.ttlSec },\n    );\n  }\n\n  private async generation(cache: CacheManager): Promise<string> {\n    return cache.getOrExecute(\n      [CACHE_NAMESPACE, \"generation\", this.host, this.root],\n      async () => randomUUID(),\n      this.userKey,\n      { ttl: this.ttlSec * 2 },\n    );\n  }\n\n  private generationKey(cache: CacheManager): string {\n    return cache.generateKey([CACHE_NAMESPACE, \"generation\", this.host, this.root], this.userKey);\n  }\n\n  private async mutate(run: (source: FileSystem) => Promise<void>): Promise<void> {\n    const source = this.source;\n    await run(source);\n    await this.invalidate();\n  }\n}\n\n/** Return one stable Mastra mount per resolved user, host, and source root. */\nexport function cachedWorkspaceSkillMount(\n  options: AppKitCachedFileSystemOptions,\n): CachedWorkspaceSkillMount {\n  const cacheKey = object.toStableKey({\n    host: options.host,\n    readOnly: options.source.readOnly,\n    root: options.source.root,\n    userKey: options.userKey,\n  });\n  const existing = scopedMounts.get(cacheKey);\n  if (existing) {\n    existing.cache.bind(options.source);\n    scopedMounts.delete(cacheKey);\n    scopedMounts.set(cacheKey, existing);\n    return { cacheKey, filesystem: existing.adapter };\n  }\n\n  const cache = new AppKitCachedFileSystem(options);\n  const entry: ScopedMountEntry = {\n    adapter: filesystems(cache, {\n      id: cache.id,\n      readOnly: options.source.readOnly,\n    }),\n    cache,\n    host: options.host,\n    root: options.source.root,\n    userKey: options.userKey,\n  };\n  scopedMounts.set(cacheKey, entry);\n  trimScopedMounts();\n  return { cacheKey, filesystem: entry.adapter };\n}\n\n/** Invalidate one user's cached workspace skill scope. */\nexport async function clearWorkspaceSkillCache(options: {\n  host: string;\n  root?: string;\n  userKey: string;\n}): Promise<void> {\n  const matches = [...scopedMounts.entries()].filter(\n    ([, entry]) =>\n      entry.host === options.host &&\n      entry.userKey === options.userKey &&\n      (options.root === undefined || entry.root === options.root),\n  );\n  await Promise.all(matches.map(([, entry]) => entry.cache.invalidate()));\n}\n\nfunction cacheTtlSec(ttlMs = DEFAULT_WORKSPACE_SKILL_CACHE_TTL_MS): number {\n  if (!Number.isFinite(ttlMs) || ttlMs <= 0) {\n    throw new Error(\"Workspace skill cache ttlMs must be a positive finite number\");\n  }\n  return Math.max(1, Math.ceil(ttlMs / 1000));\n}\n\nfunction serializeStat(value: FileStat): CachedFileStat {\n  const { accessedAt, createdAt, modifiedAt, ...stat } = value;\n  return {\n    ...stat,\n    ...(accessedAt ? { accessedAt: accessedAt.getTime() } : {}),\n    ...(createdAt ? { createdAt: createdAt.getTime() } : {}),\n    ...(modifiedAt ? { modifiedAt: modifiedAt.getTime() } : {}),\n  };\n}\n\nfunction deserializeStat(value: CachedFileStat): FileStat {\n  const { accessedAt, createdAt, modifiedAt, ...stat } = value;\n  return {\n    ...stat,\n    ...(accessedAt !== undefined ? { accessedAt: new Date(accessedAt) } : {}),\n    ...(createdAt !== undefined ? { createdAt: new Date(createdAt) } : {}),\n    ...(modifiedAt !== undefined ? { modifiedAt: new Date(modifiedAt) } : {}),\n  };\n}\n\nfunction trimScopedMounts(): void {\n  while (scopedMounts.size > DEFAULT_MAX_SCOPED_MOUNTS) {\n    const oldest = scopedMounts.keys().next().value;\n    if (oldest === undefined) return;\n    scopedMounts.delete(oldest);\n  }\n}\n"]}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"skill-cache.js","sourceRoot":"","sources":["../../src/skill-cache.ts"],"names":[],"mappings":"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","sourcesContent":["/**\n * User-scoped workspace skill catalogues cached as one semantic record.\n *\n * @module\n */\n\nimport { CacheManager } from \"@databricks/appkit\";\nimport { errorUtils, log, object } from \"@dbx-tools/shared-core\";\nimport { posixPath } from \"@dbx-tools/shared-fs\";\nimport type { RequestContext } from \"@mastra/core/request-context\";\nimport { LRUCache } from \"lru-cache\";\nimport { parse as parseYaml } from \"yaml\";\nimport { z } from \"zod\";\n\nconst CACHE_NAMESPACE = \"mastra:workspace-skill-catalogue\";\nconst CATALOGUE_VERSION = 1;\nconst MAX_SCOPED_CATALOGUES = 256;\nconst logger = log.logger(\"mastra/skill-cache\");\n\nconst SkillCatalogueEntrySchema = z\n  .object({\n    name: z.string().describe(\"Unique skill name from SKILL.md frontmatter.\"),\n    description: z.string().describe(\"Skill description from SKILL.md frontmatter.\"),\n    instructions: z.string().describe(\"Markdown instructions below SKILL.md frontmatter.\"),\n    sourceId: z.string().describe(\"Identity of the mounted source that owns this skill.\"),\n    sourcePath: z.string().describe(\"Path to SKILL.md relative to its source root.\"),\n    signature: z\n      .string()\n      .optional()\n      .describe(\"Stable metadata signature used to retain unchanged instructions.\"),\n  })\n  .describe(\"One parsed skill in a materialized workspace catalogue.\");\n\nconst SkillCatalogueSchema = z\n  .object({\n    version: z.literal(CATALOGUE_VERSION).describe(\"Persisted catalogue schema version.\"),\n    generatedAt: z.string().datetime().describe(\"Time the catalogue was last refreshed.\"),\n    roots: z.array(z.string()).describe(\"Ordered source identities included in the catalogue.\"),\n    skills: z\n      .array(SkillCatalogueEntrySchema)\n      .describe(\"Parsed skills after ordered duplicate-name precedence is applied.\"),\n  })\n  .describe(\"One user-scoped materialized workspace skill catalogue.\");\n\n/** Parsed skill retained in a materialized workspace catalogue. */\nexport type SkillCatalogueEntry = z.infer<typeof SkillCatalogueEntrySchema>;\n\n/** Versioned persisted skill catalogue. */\nexport type SkillCatalogue = z.infer<typeof SkillCatalogueSchema>;\n\n/** One ordered filesystem root contributing skills to a catalogue. */\nexport interface SkillCatalogueSource {\n  /** Stable source identity including its mount precedence. */\n  id: string;\n  /** List one source-relative directory with provider metadata when available. */\n  list(path: string): Promise<SkillCatalogueFileEntry[]>;\n  /** Read one source-relative file fresh from its owning filesystem. */\n  read(path: string): Promise<string>;\n}\n\n/** Minimal directory metadata used to compare one catalogue refresh. */\nexport interface SkillCatalogueFileEntry {\n  metadata?: Readonly<Record<string, unknown>>;\n  name: string;\n  size?: number;\n  type: \"directory\" | \"file\";\n}\n\n/** Options for one user-scoped workspace skill catalogue. */\nexport interface WorkspaceSkillCatalogueOptions {\n  host: string;\n  sources: readonly SkillCatalogueSource[];\n  ttlMs?: number;\n  userKey: string;\n}\n\n/** Request state used to resolve one user-scoped catalogue owner. */\nexport interface SkillCatalogueResolveContext {\n  abortSignal?: AbortSignal;\n  requestContext?: RequestContext;\n}\n\n/** Resolve one request's complete skill catalogue. */\nexport type SkillCatalogueResolver = (\n  context: SkillCatalogueResolveContext,\n) => Promise<WorkspaceSkillCatalogue>;\n\ninterface ParsedSkill {\n  description: string;\n  instructions: string;\n  name: string;\n}\n\nconst scopedCatalogues = new LRUCache<string, WorkspaceSkillCatalogue>({\n  max: MAX_SCOPED_CATALOGUES,\n});\n\n/** Default lifetime for one complete workspace skill catalogue. */\nexport const DEFAULT_WORKSPACE_SKILL_CACHE_TTL_MS = 5 * 60 * 1000;\n\n/** Materialized catalogue with one AppKit cache record and fresh auxiliary reads. */\nexport class WorkspaceSkillCatalogue {\n  readonly cacheKey: string;\n  readonly host: string;\n  readonly userKey: string;\n\n  private lastValid?: SkillCatalogue;\n  private readonly ttlMs: number;\n  private sources: readonly SkillCatalogueSource[];\n\n  constructor(private readonly options: WorkspaceSkillCatalogueOptions) {\n    this.host = options.host;\n    this.userKey = options.userKey;\n    this.sources = options.sources;\n    this.ttlMs = positiveTtl(options.ttlMs);\n    this.cacheKey = object.toStableKey({\n      host: options.host,\n      roots: options.sources.map(({ id }) => id),\n      userKey: options.userKey,\n      version: CATALOGUE_VERSION,\n    });\n  }\n\n  /** Rebind refreshes and lazy reads to the current request's filesystem clients. */\n  bind(sources: readonly SkillCatalogueSource[]): void {\n    const identities = sources.map(({ id }) => id);\n    if (object.toStableKey(identities) !== object.toStableKey(this.sources.map(({ id }) => id))) {\n      throw new Error(\"Cannot rebind a skill catalogue to a different ordered root set\");\n    }\n    this.sources = sources;\n  }\n\n  /** Return the cached catalogue, refreshing all roots once on cache miss. */\n  async get(signal?: AbortSignal): Promise<SkillCatalogue> {\n    const cache = CacheManager.getInstanceSync();\n    try {\n      const catalogue = SkillCatalogueSchema.parse(\n        await cache.getOrExecute(\n          [CACHE_NAMESPACE, CATALOGUE_VERSION, this.options.host, this.rootKey()],\n          () => this.refresh(),\n          this.options.userKey,\n          {\n            ttl: Math.max(1, Math.ceil(this.ttlMs / 1000)),\n            callerSignal: signal,\n          },\n        ),\n      );\n      this.lastValid = catalogue;\n      return catalogue;\n    } catch (error) {\n      if (!this.lastValid) throw error;\n      logger.warn(\"skill catalogue refresh failed; retaining last valid catalogue\", {\n        error: errorUtils.errorMessage(error),\n        roots: this.sources.map(({ id }) => id),\n      });\n      return this.lastValid;\n    }\n  }\n\n  /** Expire this complete catalogue without touching unrelated cache entries. */\n  async invalidate(): Promise<void> {\n    const cache = CacheManager.getInstanceSync();\n    await cache.delete(this.persistentKey(cache));\n  }\n\n  /** Read one selected skill's auxiliary file directly from its current source. */\n  async readSkillFile(\n    skillName: string,\n    inputPath: string,\n    signal?: AbortSignal,\n  ): Promise<string> {\n    signal?.throwIfAborted();\n    const catalogue = await this.get(signal);\n    const skill = catalogue.skills.find(({ name }) => name === skillName);\n    if (!skill) throw new Error(`Unknown skill: ${skillName}`);\n    const normalized = posixPath.normalize(inputPath);\n    if (\n      !normalized.ok ||\n      normalized.path === \"/\" ||\n      inputPath.split(\"/\").some((segment) => segment === \"..\")\n    ) {\n      throw new Error(`Invalid skill file path: ${inputPath}`);\n    }\n    const source = this.sources.find(({ id }) => id === skill.sourceId);\n    if (!source) throw new Error(`Skill source is no longer mounted: ${skill.sourceId}`);\n    const parent = skill.sourcePath.split(\"/\").slice(0, -1).join(\"/\");\n    const path = [parent, normalized.path.replace(/^\\/+/, \"\")].filter(Boolean).join(\"/\");\n    return source.read(path);\n  }\n\n  private async refresh(): Promise<SkillCatalogue> {\n    const previous = new Map(\n      this.lastValid?.skills.map((skill) => [`${skill.sourceId}\\0${skill.sourcePath}`, skill]) ?? [],\n    );\n    const selected = new Map<string, SkillCatalogueEntry>();\n    for (const source of this.sources) {\n      for (const candidate of await discoverSkillFiles(source)) {\n        const prior = previous.get(`${source.id}\\0${candidate.path}`);\n        const signature = fileSignature(candidate.entry);\n        let parsed: ParsedSkill | undefined;\n        if (signature && prior?.signature === signature) {\n          parsed = prior;\n        } else {\n          parsed = parseSkill(\n            await source.read(candidate.path),\n            candidate.path,\n          );\n        }\n        if (!parsed || selected.has(parsed.name)) continue;\n        selected.set(parsed.name, {\n          ...parsed,\n          sourceId: source.id,\n          sourcePath: candidate.path,\n          ...(signature ? { signature } : {}),\n        });\n      }\n    }\n    return SkillCatalogueSchema.parse({\n      version: CATALOGUE_VERSION,\n      generatedAt: new Date().toISOString(),\n      roots: this.sources.map(({ id }) => id),\n      skills: [...selected.values()],\n    });\n  }\n\n  private rootKey(): string {\n    return object.toStableKey(this.sources.map(({ id }) => id));\n  }\n\n  private persistentKey(cache: CacheManager): string {\n    return cache.generateKey(\n      [CACHE_NAMESPACE, CATALOGUE_VERSION, this.options.host, this.rootKey()],\n      this.options.userKey,\n    );\n  }\n}\n\n/** Return one stable catalogue owner for a user, host, and ordered root set. */\nexport function workspaceSkillCatalogue(\n  options: WorkspaceSkillCatalogueOptions,\n): WorkspaceSkillCatalogue {\n  const key = object.toStableKey({\n    host: options.host,\n    roots: options.sources.map(({ id }) => id),\n    userKey: options.userKey,\n  });\n  const existing = scopedCatalogues.get(key);\n  if (existing) {\n    existing.bind(options.sources);\n    return existing;\n  }\n  const catalogue = new WorkspaceSkillCatalogue(options);\n  scopedCatalogues.set(key, catalogue);\n  return catalogue;\n}\n\n/** Invalidate matching complete catalogues and retain their stable owners. */\nexport async function clearWorkspaceSkillCache(options: {\n  host: string;\n  userKey?: string;\n}): Promise<void> {\n  const matches = [...scopedCatalogues.values()].filter(\n    (catalogue) =>\n      catalogue.host === options.host &&\n      (options.userKey === undefined || catalogue.userKey === options.userKey),\n  );\n  await Promise.all(matches.map((catalogue) => catalogue.invalidate()));\n}\n\nasync function discoverSkillFiles(\n  source: SkillCatalogueSource,\n): Promise<Array<{ entry: SkillCatalogueFileEntry; path: string }>> {\n  let rootEntries: SkillCatalogueFileEntry[];\n  try {\n    rootEntries = await source.list(\".\");\n  } catch (error) {\n    if (errorUtils.errorContext(error).notAccessible) return [];\n    throw error;\n  }\n  const candidates: Array<{ entry: SkillCatalogueFileEntry; path: string }> = [];\n  const rootSkill = rootEntries.find(\n    ({ name, type }) => name.toLowerCase() === \"skill.md\" && type === \"file\",\n  );\n  if (rootSkill) candidates.push({ entry: rootSkill, path: rootSkill.name });\n  await Promise.all(\n    rootEntries\n      .filter(({ type }) => type === \"directory\")\n      .map(async (directory) => {\n        const entries = await source.list(directory.name);\n        const skill = entries.find(\n          ({ name, type }) => name.toLowerCase() === \"skill.md\" && type === \"file\",\n        );\n        if (skill) candidates.push({ entry: skill, path: posixPath.join(directory.name, skill.name) });\n      }),\n  );\n  return candidates.sort((left, right) => left.path.localeCompare(right.path));\n}\n\nfunction parseSkill(source: string, path: string): ParsedSkill | undefined {\n  const match = /^---\\s*\\r?\\n([\\s\\S]*?)\\r?\\n---\\s*(?:\\r?\\n|$)([\\s\\S]*)$/.exec(source);\n  if (!match) {\n    logger.warn(\"skill skipped (missing YAML frontmatter)\", { path });\n    return undefined;\n  }\n  const metadata = parseYaml(match[1]!) as unknown;\n  if (!object.isRecord(metadata)) {\n    logger.warn(\"skill skipped (invalid YAML frontmatter)\", { path });\n    return undefined;\n  }\n  const parsed = z\n    .object({\n      name: z.string().trim().min(1),\n      description: z.string().trim().min(1),\n    })\n    .safeParse(metadata);\n  if (!parsed.success) {\n    logger.warn(\"skill skipped (invalid metadata)\", {\n      path,\n      error: parsed.error.message,\n    });\n    return undefined;\n  }\n  return {\n    name: parsed.data.name,\n    description: parsed.data.description,\n    instructions: match[2]!.trim(),\n  };\n}\n\nfunction fileSignature(entry: SkillCatalogueFileEntry): string | undefined {\n  const metadata = object.isRecord(entry.metadata) ? entry.metadata : {};\n  const values = {\n    modifiedAt: metadata.modifiedAt,\n    objectId: metadata.objectId,\n    size: entry.size,\n  };\n  return Object.values(values).some((value) => value !== undefined)\n    ? object.toStableKey(values)\n    : undefined;\n}\n\nfunction positiveTtl(value = DEFAULT_WORKSPACE_SKILL_CACHE_TTL_MS): number {\n  if (!Number.isFinite(value) || value <= 0) {\n    throw new RangeError(\"Workspace skill catalogue ttlMs must be a positive finite number\");\n  }\n  return value;\n}\n"]}

package/lib/src/skill-search.d.ts

@@ -0,0 +1,30 @@
+/**
+ * On-demand skill discovery backed by a materialized workspace catalogue.
+ *
+ * @module
+ */
+import type { ProcessInputStepArgs, Processor } from "@mastra/core/processors";
+import type { SkillCatalogueResolver } from "./skill-cache.ts";
+/** Configuration for {@link CatalogueSkillSearchProcessor}. */
+export interface CatalogueSkillSearchProcessorOptions {
+    minScore?: number;
+    resolve: SkillCatalogueResolver;
+    topK?: number;
+    ttlMs?: number;
+}
+/** Mastra-compatible search, load, and lazy-read tools over one cached catalogue. */
+export declare class CatalogueSkillSearchProcessor implements Processor<"skill-catalogue-search"> {
+    readonly id = "skill-catalogue-search";
+    readonly name = "Skill Catalogue Search";
+    readonly providesSkillDiscovery: "on-demand";
+    private readonly minScore;
+    private readonly resolve;
+    private readonly states;
+    private readonly topK;
+    private readonly ttlMs;
+    constructor(options: CatalogueSkillSearchProcessorOptions);
+    processInputStep(args: ProcessInputStepArgs): Promise<{
+        tools: Record<string, unknown>;
+    }>;
+    private threadState;
+}