@dbx-tools/appkit-mastra 0.9.74 → 0.9.93

package/lib/src/skill-search.js

@@ -0,0 +1,171 @@
+/**
+ * On-demand skill discovery backed by a materialized workspace catalogue.
+ *
+ * @module
+ */
+import { errorUtils } from "@dbx-tools/shared-core";
+import { MASTRA_THREAD_ID_KEY } from "@mastra/core/request-context";
+import { createTool } from "@mastra/core/tools";
+import Fuse from "fuse.js";
+import { z } from "zod";
+const DEFAULT_STATE_TTL_MS = 60 * 60 * 1000;
+/** Mastra-compatible search, load, and lazy-read tools over one cached catalogue. */
+export class CatalogueSkillSearchProcessor {
+    id = "skill-catalogue-search";
+    name = "Skill Catalogue Search";
+    providesSkillDiscovery = "on-demand";
+    minScore;
+    resolve;
+    states = new Map();
+    topK;
+    ttlMs;
+    constructor(options) {
+        this.resolve = options.resolve;
+        this.topK = options.topK ?? 5;
+        this.minScore = options.minScore ?? 0.1;
+        this.ttlMs = options.ttlMs ?? DEFAULT_STATE_TTL_MS;
+    }
+    async processInputStep(args) {
+        const owner = await this.resolve(args);
+        const catalogue = await owner.get(args.abortSignal);
+        const state = this.threadState(args);
+        args.messageList.addSystem("To discover available skills, call search_skills with a keyword query. " +
+            "To load a skill's instructions, call load_skill with the exact skill name. " +
+            "Use skill_read only after loading a skill when its instructions require a reference, script, or asset.");
+        for (const [skillName, instructions] of state.skills) {
+            args.messageList.addSystem(`[Skill: ${skillName}]\n\n${instructions}`);
+        }
+        const search = new Fuse(catalogue.skills, {
+            includeScore: true,
+            ignoreLocation: true,
+            threshold: 1,
+            keys: [
+                { name: "name", weight: 0.5 },
+                { name: "description", weight: 0.35 },
+                { name: "instructions", weight: 0.15 },
+            ],
+        });
+        return {
+            tools: {
+                ...(args.tools ?? {}),
+                search_skills: createTool({
+                    id: "search_skills",
+                    description: "Search for available skills by keyword. Load a useful result with load_skill.",
+                    inputSchema: z.object({
+                        query: z.string().trim().min(1, "Query is required").describe("Search keywords."),
+                    }),
+                    outputSchema: z.object({
+                        results: z.array(z.object({
+                            name: z.string(),
+                            description: z.string(),
+                            score: z.number(),
+                        })),
+                        message: z.string(),
+                    }),
+                    execute: async ({ query }) => {
+                        const results = search
+                            .search(query)
+                            .map((result) => ({
+                            name: result.item.name,
+                            description: result.item.description.length > 150
+                                ? `${result.item.description.slice(0, 147)}...`
+                                : result.item.description,
+                            score: Math.round((1 - (result.score ?? 1)) * 100) / 100,
+                        }))
+                            .filter(({ score }) => score >= this.minScore)
+                            .slice(0, this.topK);
+                        return {
+                            results,
+                            message: results.length === 0
+                                ? `No skills found matching "${query}". Try different keywords.`
+                                : `Found ${results.length} skill(s). Use load_skill with the exact skill name to load its instructions.`,
+                        };
+                    },
+                }),
+                load_skill: createTool({
+                    id: "load_skill",
+                    description: "Load a skill's full instructions into the conversation.",
+                    inputSchema: z.object({
+                        skillName: z.string().describe("Exact skill name returned by search_skills."),
+                    }),
+                    outputSchema: z.object({
+                        success: z.boolean(),
+                        message: z.string(),
+                        skillName: z.string().optional(),
+                    }),
+                    execute: async ({ skillName }) => {
+                        if (state.skills.has(skillName)) {
+                            return {
+                                success: true,
+                                message: `Skill "${skillName}" is already loaded.`,
+                                skillName,
+                            };
+                        }
+                        const skill = catalogue.skills.find(({ name }) => name === skillName);
+                        if (!skill) {
+                            return {
+                                success: false,
+                                message: `Skill "${skillName}" not found. Use search_skills to find available skills.`,
+                            };
+                        }
+                        state.skills.set(skillName, skill.instructions);
+                        return {
+                            success: true,
+                            message: `Skill "${skillName}" loaded. Its instructions are now available as context.`,
+                            skillName,
+                        };
+                    },
+                }),
+                skill_read: createTool({
+                    id: "skill_read",
+                    description: "Read a reference, script, template, or asset from a loaded skill. The path is relative to the skill root.",
+                    inputSchema: z.object({
+                        skillName: z.string().describe("Exact loaded skill name."),
+                        path: z.string().describe("File path relative to the skill root."),
+                        startLine: z.number().int().positive().optional(),
+                        endLine: z.number().int().positive().optional(),
+                    }),
+                    execute: async ({ skillName, path, startLine, endLine }) => {
+                        if (!state.skills.has(skillName)) {
+                            return `Skill "${skillName}" is not loaded. Call load_skill first.`;
+                        }
+                        try {
+                            const source = await owner.readSkillFile(skillName, path, args.abortSignal);
+                            return lineRange(source, path, startLine, endLine);
+                        }
+                        catch (error) {
+                            return `Could not read "${path}" from skill "${skillName}": ${errorUtils.errorMessage(error)}`;
+                        }
+                    },
+                }),
+            },
+        };
+    }
+    threadState(args) {
+        const now = Date.now();
+        for (const [key, state] of this.states) {
+            if (now - state.lastAccessed > this.ttlMs)
+                this.states.delete(key);
+        }
+        const key = args.requestContext?.get(MASTRA_THREAD_ID_KEY) ?? "default";
+        const current = this.states.get(String(key)) ?? {
+            lastAccessed: now,
+            skills: new Map(),
+        };
+        current.lastAccessed = now;
+        this.states.set(String(key), current);
+        return current;
+    }
+}
+function lineRange(source, path, startLine, endLine) {
+    if (startLine === undefined && endLine === undefined)
+        return source;
+    const lines = source.split(/\r?\n/);
+    const start = Math.max(1, startLine ?? 1);
+    const end = Math.min(lines.length, endLine ?? lines.length);
+    if (start > end || start > lines.length) {
+        return `File "${path}" has ${lines.length} lines; requested range ${start}-${end} is empty.`;
+    }
+    return `${path} (lines ${start}-${end} of ${lines.length})\n${lines.slice(start - 1, end).join("\n")}`;
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"skill-search.js","sourceRoot":"","sources":["../../src/skill-search.ts"],"names":[],"mappings":"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","sourcesContent":["/**\n * On-demand skill discovery backed by a materialized workspace catalogue.\n *\n * @module\n */\n\nimport { errorUtils } from \"@dbx-tools/shared-core\";\nimport type { ProcessInputStepArgs, Processor } from \"@mastra/core/processors\";\nimport { MASTRA_THREAD_ID_KEY } from \"@mastra/core/request-context\";\nimport { createTool } from \"@mastra/core/tools\";\nimport Fuse from \"fuse.js\";\nimport { z } from \"zod\";\nimport type { SkillCatalogueResolver } from \"./skill-cache.ts\";\n\nconst DEFAULT_STATE_TTL_MS = 60 * 60 * 1000;\n\ninterface ThreadState {\n  lastAccessed: number;\n  skills: Map<string, string>;\n}\n\n/** Configuration for {@link CatalogueSkillSearchProcessor}. */\nexport interface CatalogueSkillSearchProcessorOptions {\n  minScore?: number;\n  resolve: SkillCatalogueResolver;\n  topK?: number;\n  ttlMs?: number;\n}\n\n/** Mastra-compatible search, load, and lazy-read tools over one cached catalogue. */\nexport class CatalogueSkillSearchProcessor implements Processor<\"skill-catalogue-search\"> {\n  readonly id = \"skill-catalogue-search\";\n  readonly name = \"Skill Catalogue Search\";\n  readonly providesSkillDiscovery = \"on-demand\" as const;\n\n  private readonly minScore: number;\n  private readonly resolve: SkillCatalogueResolver;\n  private readonly states = new Map<string, ThreadState>();\n  private readonly topK: number;\n  private readonly ttlMs: number;\n\n  constructor(options: CatalogueSkillSearchProcessorOptions) {\n    this.resolve = options.resolve;\n    this.topK = options.topK ?? 5;\n    this.minScore = options.minScore ?? 0.1;\n    this.ttlMs = options.ttlMs ?? DEFAULT_STATE_TTL_MS;\n  }\n\n  async processInputStep(args: ProcessInputStepArgs): Promise<{ tools: Record<string, unknown> }> {\n    const owner = await this.resolve(args);\n    const catalogue = await owner.get(args.abortSignal);\n    const state = this.threadState(args);\n    args.messageList.addSystem(\n      \"To discover available skills, call search_skills with a keyword query. \" +\n        \"To load a skill's instructions, call load_skill with the exact skill name. \" +\n        \"Use skill_read only after loading a skill when its instructions require a reference, script, or asset.\",\n    );\n    for (const [skillName, instructions] of state.skills) {\n      args.messageList.addSystem(`[Skill: ${skillName}]\\n\\n${instructions}`);\n    }\n    const search = new Fuse(catalogue.skills, {\n      includeScore: true,\n      ignoreLocation: true,\n      threshold: 1,\n      keys: [\n        { name: \"name\", weight: 0.5 },\n        { name: \"description\", weight: 0.35 },\n        { name: \"instructions\", weight: 0.15 },\n      ],\n    });\n    return {\n      tools: {\n        ...(args.tools ?? {}),\n        search_skills: createTool({\n          id: \"search_skills\",\n          description:\n            \"Search for available skills by keyword. Load a useful result with load_skill.\",\n          inputSchema: z.object({\n            query: z.string().trim().min(1, \"Query is required\").describe(\"Search keywords.\"),\n          }),\n          outputSchema: z.object({\n            results: z.array(\n              z.object({\n                name: z.string(),\n                description: z.string(),\n                score: z.number(),\n              }),\n            ),\n            message: z.string(),\n          }),\n          execute: async ({ query }) => {\n            const results = search\n              .search(query)\n              .map((result) => ({\n                name: result.item.name,\n                description:\n                  result.item.description.length > 150\n                    ? `${result.item.description.slice(0, 147)}...`\n                    : result.item.description,\n                score: Math.round((1 - (result.score ?? 1)) * 100) / 100,\n              }))\n              .filter(({ score }) => score >= this.minScore)\n              .slice(0, this.topK);\n            return {\n              results,\n              message:\n                results.length === 0\n                  ? `No skills found matching \"${query}\". Try different keywords.`\n                  : `Found ${results.length} skill(s). Use load_skill with the exact skill name to load its instructions.`,\n            };\n          },\n        }),\n        load_skill: createTool({\n          id: \"load_skill\",\n          description: \"Load a skill's full instructions into the conversation.\",\n          inputSchema: z.object({\n            skillName: z.string().describe(\"Exact skill name returned by search_skills.\"),\n          }),\n          outputSchema: z.object({\n            success: z.boolean(),\n            message: z.string(),\n            skillName: z.string().optional(),\n          }),\n          execute: async ({ skillName }) => {\n            if (state.skills.has(skillName)) {\n              return {\n                success: true,\n                message: `Skill \"${skillName}\" is already loaded.`,\n                skillName,\n              };\n            }\n            const skill = catalogue.skills.find(({ name }) => name === skillName);\n            if (!skill) {\n              return {\n                success: false,\n                message: `Skill \"${skillName}\" not found. Use search_skills to find available skills.`,\n              };\n            }\n            state.skills.set(skillName, skill.instructions);\n            return {\n              success: true,\n              message: `Skill \"${skillName}\" loaded. Its instructions are now available as context.`,\n              skillName,\n            };\n          },\n        }),\n        skill_read: createTool({\n          id: \"skill_read\",\n          description:\n            \"Read a reference, script, template, or asset from a loaded skill. The path is relative to the skill root.\",\n          inputSchema: z.object({\n            skillName: z.string().describe(\"Exact loaded skill name.\"),\n            path: z.string().describe(\"File path relative to the skill root.\"),\n            startLine: z.number().int().positive().optional(),\n            endLine: z.number().int().positive().optional(),\n          }),\n          execute: async ({ skillName, path, startLine, endLine }) => {\n            if (!state.skills.has(skillName)) {\n              return `Skill \"${skillName}\" is not loaded. Call load_skill first.`;\n            }\n            try {\n              const source = await owner.readSkillFile(skillName, path, args.abortSignal);\n              return lineRange(source, path, startLine, endLine);\n            } catch (error) {\n              return `Could not read \"${path}\" from skill \"${skillName}\": ${errorUtils.errorMessage(error)}`;\n            }\n          },\n        }),\n      },\n    };\n  }\n\n  private threadState(args: ProcessInputStepArgs): ThreadState {\n    const now = Date.now();\n    for (const [key, state] of this.states) {\n      if (now - state.lastAccessed > this.ttlMs) this.states.delete(key);\n    }\n    const key = args.requestContext?.get(MASTRA_THREAD_ID_KEY) ?? \"default\";\n    const current = this.states.get(String(key)) ?? {\n      lastAccessed: now,\n      skills: new Map<string, string>(),\n    };\n    current.lastAccessed = now;\n    this.states.set(String(key), current);\n    return current;\n  }\n}\n\nfunction lineRange(\n  source: string,\n  path: string,\n  startLine: number | undefined,\n  endLine: number | undefined,\n): string {\n  if (startLine === undefined && endLine === undefined) return source;\n  const lines = source.split(/\\r?\\n/);\n  const start = Math.max(1, startLine ?? 1);\n  const end = Math.min(lines.length, endLine ?? lines.length);\n  if (start > end || start > lines.length) {\n    return `File \"${path}\" has ${lines.length} lines; requested range ${start}-${end} is empty.`;\n  }\n  return `${path} (lines ${start}-${end} of ${lines.length})\\n${lines.slice(start - 1, end).join(\"\\n\")}`;\n}\n"]}

package/lib/src/workspaces.d.ts

@@ -20,6 +20,7 @@
 import type { RequestContext } from "@mastra/core/request-context";
 import { Workspace, type SkillsResolver, type WorkspaceFilesystem, type WorkspaceSandbox, type WorkspaceSandboxResolver } from "@mastra/core/workspace";
 import { type DatabricksWorkspaceSandboxOptions } from "./sandbox.ts";
+import { type SkillCatalogueResolver, type SkillCatalogueSource } from "./skill-cache.ts";
 /** Per-request context for mount and skill-folder resolvers. */
 export interface WorkspaceMountContext {
     requestContext?: RequestContext;
@@ -58,6 +59,8 @@ export interface SkillFolderOptions {
 /** Mount map plus optional Mastra skill scan roots for one resolver. */
 export interface WorkspaceMountContribution {
     mounts: Record<string, WorkspaceFilesystem>;
+    /** Ordered source roots included in catalogue discovery. */
+    skillSources?: SkillCatalogueSource[];
     /** Paths within the composite namespace where `SKILL.md` files are scanned. */
     skillPaths?: string[];
     /**
@@ -100,16 +103,16 @@ export interface CreateWorkspaceOptions {
     /** Forwarded to Mastra when skill discovery is enabled. */
     checkSkillFileMtime?: boolean;
     /**
-     * AppKit cache TTL for Databricks skill metadata and content.
-     * Defaults to five minutes.
+     * Refresh TTL for the complete parsed skill catalogue. Auxiliary reads are
+     * always fresh. Defaults to five minutes.
      */
     workspaceSkillRefreshTtlMs?: number;
     /** Enable BM25 keyword search over indexed workspace content. */
     bm25?: boolean;
     /**
-     * Command sandbox. Defaults to Databricks Sandbox. Pass `false` to disable
-     * command execution, or an explicit Mastra sandbox/provider resolver to
-     * replace Databricks for this workspace.
+     * Command sandbox. Defaults to Monty. Pass `"databricks"` or an options
+     * object for Databricks Sandbox, `false` to disable command execution, or an
+     * explicit Mastra sandbox/provider resolver.
      */
     sandbox?: WorkspaceSandboxSelection;
     /**
@@ -164,6 +167,8 @@ export declare const DEFAULT_SKILL_FOLDERS: Readonly<Record<DefaultSkillFolderNa
  * ```
  */
 export declare function createWorkspace(options?: CreateWorkspaceOptions): Workspace;
+/** Return the dbx-tools catalogue resolver attached to one workspace. */
+export declare function workspaceSkillCatalogueResolver(workspace: Workspace | undefined): SkillCatalogueResolver | undefined;
 /**
  * Merge the configured skill folders over {@link DEFAULT_SKILL_FOLDERS}.
  *