mastra-minds 0.1.1 → 0.2.0

package/dist/index.d.ts

@@ -5,10 +5,12 @@
  *
  * @example
  * ```typescript
- * import { createMindsAgent, initMindRegistry } from 'mastra-minds';
+ * import { createMindsAgent, initMindRegistry, FileSystemProvider } from 'mastra-minds';
  *
- * // Initialize minds from a directory
- * await initMindRegistry('./minds');
+ * // Initialize with provider(s)
+ * await initMindRegistry({
+ *   providers: [new FileSystemProvider('./minds')],
+ * });
  *
  * // Create an agent with minds support
  * const agent = createMindsAgent({
@@ -18,10 +20,12 @@
  * });
  * ```
  */
-export { parseMindMd, loadMind } from "./parser";
-export { MindRegistry, getMindRegistry, initMindRegistry, } from "./registry";
+export { parseMindMd } from "./parser";
+export { MindRegistry, getMindRegistry, initMindRegistry } from "./registry";
+export type { MindRegistryOptions, ConflictStrategy } from "./registry";
 export { loadMindTool, readMindResourceTool, executeMindScriptTool, listMindsTool, mindTools, } from "./tools";
-export type { Mind, MindFrontmatter, MindMetadata } from "./types";
+export { FileSystemProvider } from "./providers";
+export type { Mind, MindFrontmatter, MindMetadata, MindsProvider, ScriptResult, } from "./types";
 export { MindFrontmatterSchema } from "./types";
 export { createMindsAgent, withMinds } from "./agent";
 export type { MindsAgentOptions, SystemMessage } from "./agent";

package/dist/index.js

@@ -39730,52 +39730,54 @@ function parseFrontmatter(content) {
   }
   return { frontmatter, body: body.trim() };
 }
-function parseMindMd(content, baseDir) {
+function parseMindMd(content) {
   const { frontmatter, body } = parseFrontmatter(content);
   const validatedFrontmatter = MindFrontmatterSchema.parse(frontmatter);
   return {
+    metadata: {
+      name: validatedFrontmatter.name,
+      description: validatedFrontmatter.description
+    },
     frontmatter: validatedFrontmatter,
-    content: body,
-    baseDir
+    content: body
   };
 }
-async function loadMind(mindDir) {
-  const mindMdPath = `${mindDir}/MIND.md`;
-  const file2 = Bun.file(mindMdPath);
-  if (!await file2.exists()) {
-    throw new Error(`MIND.md not found in ${mindDir}`);
-  }
-  const content = await file2.text();
-  return parseMindMd(content, mindDir);
-}
 // src/registry.ts
-var {Glob } = globalThis.Bun;
 class MindRegistry {
-  mindsDir;
+  providers;
+  strategy;
   metadataCache = new Map;
   mindCache = new Map;
-  constructor(mindsDir) {
-    this.mindsDir = mindsDir;
-  }
-  async discover() {
-    const glob = new Glob("*/MIND.md");
-    const minds = [];
-    for await (const path of glob.scan(this.mindsDir)) {
-      const mindDir = `${this.mindsDir}/${path.replace("/MIND.md", "")}`;
-      try {
-        const mind = await loadMind(mindDir);
-        const metadata = {
-          name: mind.frontmatter.name,
-          description: mind.frontmatter.description
-        };
-        this.metadataCache.set(mind.frontmatter.name, metadata);
-        this.mindCache.set(mind.frontmatter.name, mind);
-        minds.push(metadata);
-      } catch (error46) {
-        console.error(`Failed to load mind from ${mindDir}:`, error46);
+  mindProviderMap = new Map;
+  constructor(options) {
+    this.providers = options.providers;
+    this.strategy = options.conflictStrategy ?? "first";
+  }
+  async init() {
+    this.metadataCache.clear();
+    this.mindCache.clear();
+    this.mindProviderMap.clear();
+    for (const provider of this.providers) {
+      const minds = await provider.discover();
+      for (const mind of minds) {
+        const existing = this.mindProviderMap.get(mind.name);
+        if (existing) {
+          if (this.strategy === "first") {
+            console.warn(`Mind "${mind.name}" from [${provider.name}] skipped, already registered from [${existing.name}]`);
+            continue;
+          }
+          console.warn(`Mind "${mind.name}" overwritten: [${existing.name}] -> [${provider.name}]`);
+        }
+        this.mindProviderMap.set(mind.name, provider);
+        this.metadataCache.set(mind.name, mind);
       }
     }
-    return minds;
+  }
+  getProviderForMind(name) {
+    return this.mindProviderMap.get(name);
+  }
+  getProviders() {
+    return this.providers;
   }
   getMetadata(name) {
     return this.metadataCache.get(name);
@@ -39784,14 +39786,33 @@ class MindRegistry {
     if (this.mindCache.has(name)) {
       return this.mindCache.get(name);
     }
-    const mindDir = `${this.mindsDir}/${name}`;
-    try {
-      const mind = await loadMind(mindDir);
+    const provider = this.mindProviderMap.get(name);
+    if (!provider) {
+      return;
+    }
+    const mind = await provider.loadMind(name);
+    if (mind) {
       this.mindCache.set(name, mind);
-      return mind;
-    } catch {
+    }
+    return mind;
+  }
+  hasMind(name) {
+    return this.mindProviderMap.has(name);
+  }
+  async readResource(mindName, path) {
+    const provider = this.mindProviderMap.get(mindName);
+    return provider?.readResource(mindName, path);
+  }
+  async executeScript(mindName, scriptPath, args) {
+    const provider = this.mindProviderMap.get(mindName);
+    if (!provider?.executeScript) {
       return;
     }
+    return provider.executeScript(mindName, scriptPath, args);
+  }
+  supportsScripts(mindName) {
+    const provider = this.mindProviderMap.get(mindName);
+    return typeof provider?.executeScript === "function";
   }
   generateAvailableMinds() {
     if (this.metadataCache.size === 0) {
@@ -39802,29 +39823,20 @@ class MindRegistry {
     return `Available minds:
 ${lines}`;
   }
-  generateAvailableMindsXml() {
-    return this.generateAvailableMinds();
-  }
   listMinds() {
     return Array.from(this.metadataCache.keys());
   }
-  hasMind(name) {
-    return this.metadataCache.has(name);
-  }
 }
 var registryInstance = null;
-function getMindRegistry(mindsDir) {
-  if (!registryInstance && mindsDir) {
-    registryInstance = new MindRegistry(mindsDir);
-  }
+function getMindRegistry() {
   if (!registryInstance) {
-    throw new Error("MindRegistry not initialized. Call with mindsDir first.");
+    throw new Error("MindRegistry not initialized. Call initMindRegistry first.");
   }
   return registryInstance;
 }
-async function initMindRegistry(mindsDir) {
-  registryInstance = new MindRegistry(mindsDir);
-  await registryInstance.discover();
+async function initMindRegistry(options) {
+  registryInstance = new MindRegistry(options);
+  await registryInstance.init();
   return registryInstance;
 }
 // node_modules/@mastra/core/dist/chunk-DD2VNRQM.js
@@ -40184,7 +40196,6 @@ guide your subsequent actions.`,
     success: exports_external.boolean(),
     mindName: exports_external.string().optional(),
     instructions: exports_external.string().optional(),
-    baseDir: exports_external.string().optional(),
     allowedTools: exports_external.array(exports_external.string()).optional(),
     message: exports_external.string().optional()
   }),
@@ -40200,9 +40211,8 @@ guide your subsequent actions.`,
     const allowedTools = mind.frontmatter["allowed-tools"]?.split(/\s+/).filter(Boolean);
     return {
       success: true,
-      mindName: mind.frontmatter.name,
+      mindName: mind.metadata.name,
       instructions: mind.content,
-      baseDir: mind.baseDir,
       allowedTools
     };
   }
@@ -40223,41 +40233,31 @@ when the mind instructions reference them.`,
   }),
   execute: async (inputData) => {
     const registry2 = getMindRegistry();
-    const mind = await registry2.loadMind(inputData.mindName);
-    if (!mind) {
+    if (!registry2.hasMind(inputData.mindName)) {
       return {
         success: false,
         message: `Mind "${inputData.mindName}" not found`
       };
     }
-    const normalizedPath = inputData.resourcePath.replace(/\.\./g, "");
-    const fullPath = `${mind.baseDir}/${normalizedPath}`;
-    try {
-      const file2 = Bun.file(fullPath);
-      if (!await file2.exists()) {
-        return {
-          success: false,
-          message: `Resource not found: ${normalizedPath}`
-        };
-      }
-      const content = await file2.text();
-      return {
-        success: true,
-        content
-      };
-    } catch (err) {
+    const content = await registry2.readResource(inputData.mindName, inputData.resourcePath);
+    if (content === undefined) {
       return {
         success: false,
-        message: `Failed to read resource: ${err}`
+        message: `Resource not found: ${inputData.resourcePath}`
       };
     }
+    return {
+      success: true,
+      content
+    };
   }
 });
 var executeMindScriptTool = createTool({
   id: "execute-mind-script",
   description: `Execute a script from a mind's scripts/ directory.
 Use this when mind instructions tell you to run a script for deterministic operations.
-Scripts can be .ts, .js, .sh, or .py files.`,
+Scripts can be .ts, .js, .sh, or .py files.
+Note: Not all providers support script execution.`,
   inputSchema: exports_external.object({
     mindName: exports_external.string().describe("The name of the mind"),
     scriptPath: exports_external.string().describe("Relative path to script in scripts/ (e.g., 'helper.ts')"),
@@ -40272,50 +40272,189 @@ Scripts can be .ts, .js, .sh, or .py files.`,
   }),
   execute: async (inputData) => {
     const registry2 = getMindRegistry();
-    const mind = await registry2.loadMind(inputData.mindName);
-    if (!mind) {
+    if (!registry2.hasMind(inputData.mindName)) {
       return {
         success: false,
         message: `Mind "${inputData.mindName}" not found`
       };
     }
-    const scriptPath = inputData.scriptPath.replace(/\.\./g, "");
-    const fullPath = `${mind.baseDir}/scripts/${scriptPath}`;
+    if (!registry2.supportsScripts(inputData.mindName)) {
+      return {
+        success: false,
+        message: "Script execution is not supported by this mind's provider"
+      };
+    }
+    const result = await registry2.executeScript(inputData.mindName, inputData.scriptPath, inputData.args);
+    if (!result) {
+      return {
+        success: false,
+        message: "Script execution failed"
+      };
+    }
+    return {
+      success: result.success,
+      stdout: result.stdout,
+      stderr: result.stderr,
+      exitCode: result.exitCode
+    };
+  }
+});
+var listMindsTool = createTool({
+  id: "list-minds",
+  description: "List all available minds with their descriptions",
+  inputSchema: exports_external.object({}),
+  outputSchema: exports_external.object({
+    minds: exports_external.array(exports_external.object({
+      name: exports_external.string(),
+      description: exports_external.string()
+    }))
+  }),
+  execute: async () => {
+    const registry2 = getMindRegistry();
+    const minds = registry2.listMinds().map((name) => {
+      const metadata = registry2.getMetadata(name);
+      return {
+        name,
+        description: metadata?.description || ""
+      };
+    });
+    return { minds };
+  }
+});
+var mindTools = {
+  loadMindTool,
+  readMindResourceTool,
+  executeMindScriptTool,
+  listMindsTool
+};
+// src/providers/filesystem.ts
+var {Glob } = globalThis.Bun;
+class FileSystemProvider {
+  name = "filesystem";
+  baseDir;
+  mindDirs = new Map;
+  constructor(baseDir) {
+    this.baseDir = baseDir;
+  }
+  async discover() {
+    const glob = new Glob("*/MIND.md");
+    const minds = [];
+    for await (const path of glob.scan(this.baseDir)) {
+      const mindDirName = path.replace("/MIND.md", "");
+      const mindDir = `${this.baseDir}/${mindDirName}`;
+      try {
+        const file2 = Bun.file(`${mindDir}/MIND.md`);
+        const content = await file2.text();
+        const mind = parseMindMd(content);
+        this.mindDirs.set(mind.metadata.name, mindDir);
+        minds.push(mind.metadata);
+      } catch (error46) {
+        console.error(`Failed to load mind from ${mindDir}:`, error46);
+      }
+    }
+    return minds;
+  }
+  async loadMind(name) {
+    const mindDir = this.mindDirs.get(name);
+    if (!mindDir) {
+      const fallbackDir = `${this.baseDir}/${name}`;
+      const file2 = Bun.file(`${fallbackDir}/MIND.md`);
+      if (!await file2.exists()) {
+        return;
+      }
+      try {
+        const content = await file2.text();
+        const mind = parseMindMd(content);
+        this.mindDirs.set(name, fallbackDir);
+        return mind;
+      } catch {
+        return;
+      }
+    }
+    try {
+      const file2 = Bun.file(`${mindDir}/MIND.md`);
+      const content = await file2.text();
+      return parseMindMd(content);
+    } catch {
+      return;
+    }
+  }
+  async hasMind(name) {
+    if (this.mindDirs.has(name)) {
+      return true;
+    }
+    const fallbackDir = `${this.baseDir}/${name}`;
+    const file2 = Bun.file(`${fallbackDir}/MIND.md`);
+    return file2.exists();
+  }
+  async readResource(mindName, path) {
+    const mindDir = this.mindDirs.get(mindName);
+    if (!mindDir) {
+      return;
+    }
+    const normalizedPath = path.replace(/\.\./g, "");
+    const fullPath = `${mindDir}/${normalizedPath}`;
+    try {
+      const file2 = Bun.file(fullPath);
+      if (!await file2.exists()) {
+        return;
+      }
+      return file2.text();
+    } catch {
+      return;
+    }
+  }
+  async executeScript(mindName, scriptPath, args) {
+    const mindDir = this.mindDirs.get(mindName);
+    if (!mindDir) {
+      return {
+        success: false,
+        stdout: "",
+        stderr: `Mind "${mindName}" not found`,
+        exitCode: 1
+      };
+    }
+    const normalizedPath = scriptPath.replace(/\.\./g, "");
+    const fullPath = `${mindDir}/scripts/${normalizedPath}`;
     const ext = scriptPath.split(".").pop()?.toLowerCase();
     let command;
     switch (ext) {
       case "ts":
       case "js":
-        command = ["bun", fullPath, ...inputData.args || []];
+        command = ["bun", fullPath, ...args || []];
         break;
       case "sh":
-        command = ["bash", fullPath, ...inputData.args || []];
+        command = ["bash", fullPath, ...args || []];
         break;
       case "py":
-        command = ["python3", fullPath, ...inputData.args || []];
+        command = ["python3", fullPath, ...args || []];
         break;
       default:
         return {
           success: false,
-          message: `Unsupported script type: .${ext}. Use .ts, .js, .sh, or .py`
+          stdout: "",
+          stderr: `Unsupported script type: .${ext}. Use .ts, .js, .sh, or .py`,
+          exitCode: 1
         };
     }
     const file2 = Bun.file(fullPath);
     if (!await file2.exists()) {
       return {
         success: false,
-        message: `Script not found: scripts/${scriptPath}`
+        stdout: "",
+        stderr: `Script not found: scripts/${scriptPath}`,
+        exitCode: 1
       };
     }
     try {
       const proc = Bun.spawn(command, {
-        cwd: mind.baseDir,
+        cwd: mindDir,
         stdout: "pipe",
         stderr: "pipe",
         env: {
           ...process.env,
-          MIND_NAME: mind.frontmatter.name,
-          MIND_DIR: mind.baseDir
+          MIND_NAME: mindName,
+          MIND_DIR: mindDir
         }
       });
       const stdout = await new Response(proc.stdout).text();
@@ -40327,42 +40466,16 @@ Scripts can be .ts, .js, .sh, or .py files.`,
         stderr: stderr.trim(),
         exitCode
       };
-    } catch (err) {
+    } catch (error46) {
       return {
         success: false,
-        message: `Execution failed: ${err}`
+        stdout: "",
+        stderr: `Execution failed: ${error46}`,
+        exitCode: 1
       };
     }
   }
-});
-var listMindsTool = createTool({
-  id: "list-minds",
-  description: "List all available minds with their descriptions",
-  inputSchema: exports_external.object({}),
-  outputSchema: exports_external.object({
-    minds: exports_external.array(exports_external.object({
-      name: exports_external.string(),
-      description: exports_external.string()
-    }))
-  }),
-  execute: async () => {
-    const registry2 = getMindRegistry();
-    const minds = registry2.listMinds().map((name) => {
-      const metadata = registry2.getMetadata(name);
-      return {
-        name,
-        description: metadata?.description || ""
-      };
-    });
-    return { minds };
-  }
-});
-var mindTools = {
-  loadMindTool,
-  readMindResourceTool,
-  executeMindScriptTool,
-  listMindsTool
-};
+}
 // node_modules/@mastra/core/dist/chunk-2SQB3WBT.js
 init_chunk_D22XABFZ();
 
@@ -97895,12 +98008,12 @@ export {
   parseMindMd,
   mindTools,
   loadMindTool,
-  loadMind,
   listMindsTool,
   initMindRegistry,
   getMindRegistry,
   executeMindScriptTool,
   createMindsAgent,
   MindRegistry,
-  MindFrontmatterSchema
+  MindFrontmatterSchema,
+  FileSystemProvider
 };

package/dist/parser.d.ts

@@ -2,8 +2,4 @@ import { type Mind } from "./types";
 /**
  * Parse a MIND.md file content into a Mind object
  */
-export declare function parseMindMd(content: string, baseDir: string): Mind;
-/**
- * Load and parse a mind from a directory
- */
-export declare function loadMind(mindDir: string): Promise<Mind>;
+export declare function parseMindMd(content: string): Mind;

package/dist/providers/filesystem.d.ts

@@ -0,0 +1,26 @@
+import type { Mind, MindMetadata, MindsProvider, ScriptResult } from "../types";
+/**
+ * FileSystemProvider - Loads minds from a local directory
+ *
+ * Directory structure:
+ * ```
+ * mindsDir/
+ * ├── mind-name/
+ * │   ├── MIND.md
+ * │   ├── references/
+ * │   │   └── guide.md
+ * │   └── scripts/
+ * │       └── helper.ts
+ * ```
+ */
+export declare class FileSystemProvider implements MindsProvider {
+    readonly name = "filesystem";
+    private baseDir;
+    private mindDirs;
+    constructor(baseDir: string);
+    discover(): Promise<MindMetadata[]>;
+    loadMind(name: string): Promise<Mind | undefined>;
+    hasMind(name: string): Promise<boolean>;
+    readResource(mindName: string, path: string): Promise<string | undefined>;
+    executeScript(mindName: string, scriptPath: string, args?: string[]): Promise<ScriptResult>;
+}

package/dist/providers/index.d.ts

@@ -0,0 +1 @@
+export { FileSystemProvider } from "./filesystem";

package/dist/registry.d.ts

@@ -1,39 +1,77 @@
-import type { Mind, MindMetadata } from "./types";
+import type { Mind, MindMetadata, MindsProvider, ScriptResult } from "./types";
 /**
- * MindRegistry manages mind discovery and loading
- * Implements progressive disclosure: metadata loaded upfront, full content on-demand
+ * Conflict resolution strategy when multiple providers have the same mind name
+ */
+export type ConflictStrategy = "first" | "last";
+/**
+ * Options for MindRegistry
+ */
+export interface MindRegistryOptions {
+    providers: MindsProvider[];
+    conflictStrategy?: ConflictStrategy;
+}
+/**
+ * MindRegistry - Central access point for minds
+ *
+ * Supports multiple providers with configurable conflict resolution.
  */
 export declare class MindRegistry {
-    private mindsDir;
+    private providers;
+    private strategy;
     private metadataCache;
     private mindCache;
-    constructor(mindsDir: string);
+    private mindProviderMap;
+    constructor(options: MindRegistryOptions);
+    /**
+     * Initialize the registry by discovering minds from all providers
+     */
+    init(): Promise<void>;
     /**
-     * Discover all minds and load their metadata (Level 1: ~100 tokens each)
+     * Get the provider for a specific mind
      */
-    discover(): Promise<MindMetadata[]>;
+    getProviderForMind(name: string): MindsProvider | undefined;
+    /**
+     * Get all providers
+     */
+    getProviders(): MindsProvider[];
     /**
      * Get mind metadata by name
      */
     getMetadata(name: string): MindMetadata | undefined;
     /**
-     * Load full mind content (Level 2: <5000 tokens)
+     * Load full mind content (with caching)
      */
     loadMind(name: string): Promise<Mind | undefined>;
+    /**
+     * Check if a mind exists
+     */
+    hasMind(name: string): boolean;
+    /**
+     * Read a resource from a mind
+     */
+    readResource(mindName: string, path: string): Promise<string | undefined>;
+    /**
+     * Execute a script from a mind (if provider supports it)
+     */
+    executeScript(mindName: string, scriptPath: string, args?: string[]): Promise<ScriptResult | undefined>;
+    /**
+     * Check if the provider for a mind supports script execution
+     */
+    supportsScripts(mindName: string): boolean;
     /**
      * Generate available minds list for system prompt injection
      */
     generateAvailableMinds(): string;
-    /** @deprecated Use generateAvailableMinds() instead */
-    generateAvailableMindsXml(): string;
     /**
      * List all available mind names
      */
     listMinds(): string[];
-    /**
-     * Check if a mind exists
-     */
-    hasMind(name: string): boolean;
 }
-export declare function getMindRegistry(mindsDir?: string): MindRegistry;
-export declare function initMindRegistry(mindsDir: string): Promise<MindRegistry>;
+/**
+ * Get the global MindRegistry instance
+ */
+export declare function getMindRegistry(): MindRegistry;
+/**
+ * Initialize the global MindRegistry
+ */
+export declare function initMindRegistry(options: MindRegistryOptions): Promise<MindRegistry>;

package/dist/tools.d.ts

@@ -1,7 +1,6 @@
 import { z } from "zod";
 /**
- * Mind Loader Tool - Core of the prompt injection system
- * When invoked, loads the full mind content and returns it for the agent to follow
+ * Load Mind Tool - Core of the prompt injection system
  */
 export declare const loadMindTool: import("@mastra/core/tools").Tool<z.ZodObject<{
     name: z.ZodString;
@@ -9,7 +8,6 @@ export declare const loadMindTool: import("@mastra/core/tools").Tool<z.ZodObject
     success: z.ZodBoolean;
     mindName: z.ZodOptional<z.ZodString>;
     instructions: z.ZodOptional<z.ZodString>;
-    baseDir: z.ZodOptional<z.ZodString>;
     allowedTools: z.ZodOptional<z.ZodArray<z.ZodString>>;
     message: z.ZodOptional<z.ZodString>;
 }, z.core.$strip>, any, any, import("@mastra/core/tools").ToolExecutionContext<any, any>, "load-mind"> & {
@@ -20,7 +18,6 @@ export declare const loadMindTool: import("@mastra/core/tools").Tool<z.ZodObject
         success: z.ZodBoolean;
         mindName: z.ZodOptional<z.ZodString>;
         instructions: z.ZodOptional<z.ZodString>;
-        baseDir: z.ZodOptional<z.ZodString>;
         allowedTools: z.ZodOptional<z.ZodArray<z.ZodString>>;
         message: z.ZodOptional<z.ZodString>;
     }, z.core.$strip>;
@@ -30,7 +27,6 @@ export declare const loadMindTool: import("@mastra/core/tools").Tool<z.ZodObject
         success: boolean;
         mindName?: string | undefined;
         instructions?: string | undefined;
-        baseDir?: string | undefined;
         allowedTools?: string[] | undefined;
         message?: string | undefined;
     } & {
@@ -38,7 +34,7 @@ export declare const loadMindTool: import("@mastra/core/tools").Tool<z.ZodObject
     }>;
 };
 /**
- * Read Mind Resource Tool - For loading references/scripts on-demand (Level 3)
+ * Read Mind Resource Tool
  */
 export declare const readMindResourceTool: import("@mastra/core/tools").Tool<z.ZodObject<{
     mindName: z.ZodString;
@@ -69,8 +65,7 @@ export declare const readMindResourceTool: import("@mastra/core/tools").Tool<z.Z
     }>;
 };
 /**
- * Execute Mind Script Tool - Run scripts from mind's scripts/ directory
- * V1: Direct execution without sandbox (development only)
+ * Execute Mind Script Tool
  */
 export declare const executeMindScriptTool: import("@mastra/core/tools").Tool<z.ZodObject<{
     mindName: z.ZodString;
@@ -110,7 +105,7 @@ export declare const executeMindScriptTool: import("@mastra/core/tools").Tool<z.
     }>;
 };
 /**
- * List Minds Tool - Show available minds
+ * List Minds Tool
  */
 export declare const listMindsTool: import("@mastra/core/tools").Tool<z.ZodObject<{}, z.core.$strip>, z.ZodObject<{
     minds: z.ZodArray<z.ZodObject<{
@@ -141,7 +136,6 @@ export declare const mindTools: {
         success: z.ZodBoolean;
         mindName: z.ZodOptional<z.ZodString>;
         instructions: z.ZodOptional<z.ZodString>;
-        baseDir: z.ZodOptional<z.ZodString>;
         allowedTools: z.ZodOptional<z.ZodArray<z.ZodString>>;
         message: z.ZodOptional<z.ZodString>;
     }, z.core.$strip>, any, any, import("@mastra/core/tools").ToolExecutionContext<any, any>, "load-mind"> & {
@@ -152,7 +146,6 @@ export declare const mindTools: {
             success: z.ZodBoolean;
             mindName: z.ZodOptional<z.ZodString>;
             instructions: z.ZodOptional<z.ZodString>;
-            baseDir: z.ZodOptional<z.ZodString>;
             allowedTools: z.ZodOptional<z.ZodArray<z.ZodString>>;
             message: z.ZodOptional<z.ZodString>;
         }, z.core.$strip>;
@@ -162,7 +155,6 @@ export declare const mindTools: {
             success: boolean;
             mindName?: string | undefined;
             instructions?: string | undefined;
-            baseDir?: string | undefined;
             allowedTools?: string[] | undefined;
             message?: string | undefined;
         } & {

package/dist/types.d.ts

@@ -9,12 +9,44 @@ export declare const MindFrontmatterSchema: z.ZodObject<{
     metadata: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
 }, z.core.$strip>;
 export type MindFrontmatter = z.infer<typeof MindFrontmatterSchema>;
+export interface MindMetadata {
+    name: string;
+    description: string;
+}
 export interface Mind {
+    metadata: MindMetadata;
     frontmatter: MindFrontmatter;
     content: string;
-    baseDir: string;
 }
-export interface MindMetadata {
-    name: string;
-    description: string;
+export interface ScriptResult {
+    success: boolean;
+    stdout: string;
+    stderr: string;
+    exitCode: number;
+}
+export interface MindsProvider {
+    readonly name: string;
+    /**
+     * Discover all available minds and return their metadata
+     */
+    discover(): Promise<MindMetadata[]>;
+    /**
+     * Load full mind content by name
+     */
+    loadMind(name: string): Promise<Mind | undefined>;
+    /**
+     * Check if a mind exists
+     */
+    hasMind(name: string): Promise<boolean>;
+    /**
+     * Read a resource file from a mind's directory
+     * @param mindName - The mind name
+     * @param path - Relative path to resource (e.g., 'references/guide.md')
+     */
+    readResource(mindName: string, path: string): Promise<string | undefined>;
+    /**
+     * Execute a script from a mind's scripts directory
+     * Optional - not all providers support script execution
+     */
+    executeScript?(mindName: string, scriptPath: string, args?: string[]): Promise<ScriptResult>;
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "mastra-minds",
-  "version": "0.1.1",
+  "version": "0.2.0",
   "description": "Agent Minds system for Mastra - Claude-style skills with progressive disclosure",
   "type": "module",
   "main": "dist/index.js",