@mastra/mcp-docs-server 0.13.39 → 1.0.0-beta.0

package/dist/stdio.js

@@ -1,11 +1,11 @@
 #!/usr/bin/env node
-import { fromPackageRoot, prepare, getMatchingPaths, blogPostSchema } from './chunk-TUAHUTTB.js';
+import { fromPackageRoot, prepare, getMatchingPaths, blogPostSchema } from './chunk-5NJC7NRO.js';
 import * as fs from 'fs';
 import { existsSync, mkdirSync } from 'fs';
 import * as os2 from 'os';
 import os2__default from 'os';
-import * as path3 from 'path';
-import path3__default from 'path';
+import * as path6 from 'path';
+import path6__default from 'path';
 import fs3 from 'fs/promises';
 import { MCPServer } from '@mastra/mcp';
 import { z } from 'zod';
@@ -20,9 +20,9 @@ var writeErrorLog = (message, data) => {
     ...data ? typeof data === "object" ? data : { data } : {}
   };
   try {
-    const cacheDir = path3.join(os2.homedir(), ".cache", "mastra", "mcp-docs-server-logs");
+    const cacheDir = path6.join(os2.homedir(), ".cache", "mastra", "mcp-docs-server-logs");
     fs.mkdirSync(cacheDir, { recursive: true });
-    const logFile = path3.join(cacheDir, `${hourTimestamp}.log`);
+    const logFile = path6.join(cacheDir, `${hourTimestamp}.log`);
     fs.appendFileSync(logFile, JSON.stringify(logMessage) + "\n", "utf8");
   } catch (err) {
     console.error("Failed to write to log file:", err);
@@ -102,6 +102,106 @@ function createLogger(server2) {
   };
 }
 var logger = createLogger();
+
+// src/prompts/migration.ts
+var migrationPrompts = [
+  {
+    name: "upgrade-to-v1",
+    version: "v1",
+    description: "Get a guided migration plan for upgrading from Mastra v0.x to v1.0. Provides step-by-step instructions for handling all breaking changes.",
+    arguments: [
+      {
+        name: "area",
+        description: "Optional: Focus on a specific area (agents, tools, workflows, memory, evals, mcp, vectors, syncs). If not provided, gives an overview of all changes.",
+        required: false
+      }
+    ]
+  },
+  {
+    name: "migration-checklist",
+    version: "v1",
+    description: "Get a comprehensive checklist for migrating to Mastra v1.0. Lists all breaking changes that need to be addressed."
+  }
+];
+var migrationPromptMessages = {
+  listPrompts: async () => migrationPrompts,
+  getPromptMessages: async ({ name, args }) => {
+    const prompt = migrationPrompts.find((p) => p.name === name);
+    if (!prompt) {
+      throw new Error(`Prompt not found: ${name}`);
+    }
+    if (name === "upgrade-to-v1") {
+      return getUpgradeToV1Messages(args?.area);
+    }
+    if (name === "migration-checklist") {
+      return getMigrationChecklistMessages();
+    }
+    throw new Error(`No message handler for prompt: ${name}`);
+  }
+};
+function getUpgradeToV1Messages(area) {
+  if (area) {
+    const validAreas = ["agents", "tools", "workflows", "memory", "evals", "mcp", "vectors", "syncs"];
+    if (!validAreas.includes(area.toLowerCase())) {
+      return [
+        {
+          role: "user",
+          content: {
+            type: "text",
+            text: `Invalid area: ${area}. Valid areas are: ${validAreas.join(", ")}`
+          }
+        }
+      ];
+    }
+    return [
+      {
+        role: "user",
+        content: {
+          type: "text",
+          text: `I need help migrating my Mastra ${area} code from v0.x to v1.0. Use the mastraMigration tool to get the specific migration guide for "${area}" and walk me through the changes step by step.`
+        }
+      }
+    ];
+  }
+  return [
+    {
+      role: "user",
+      content: {
+        type: "text",
+        text: `I need to migrate my Mastra project from v0.x to v1.0. Use the mastraMigration tool to:
+
+1. First, list all available migration guides with path: "upgrade-to-v1/"
+2. Give me a high-level overview of what changed in each area
+3. Ask me which areas I'm using in my project so we can focus on relevant changes
+4. After I decided on the areas, check the migration guides for callouts to codemods. These callouts are marked with ":::tip[Codemod]" in the docs. Run the codemods with "npx @mastra/codemod v1" to automate all those changes. Afterwards, help me with any remaining manual changes needed.
+
+After I tell you which areas I use, we'll go through each one systematically.`
+      }
+    }
+  ];
+}
+function getMigrationChecklistMessages() {
+  return [
+    {
+      role: "user",
+      content: {
+        type: "text",
+        text: `Create a comprehensive migration checklist for upgrading from Mastra v0.x to v1.0. Use the mastraMigration tool to:
+
+1. List all available migration guides (path: "upgrade-to-v1/")
+2. For each guide, extract the key breaking changes
+3. Present them as a checklist I can work through
+
+Format the checklist with:
+- [ ] checkbox items for each breaking change
+- Brief description of what needs to change
+- Reference to the specific migration guide
+
+Group the checklist by area (Agents, Tools, Workflows, etc.) so I can tackle one area at a time.`
+      }
+    }
+  ];
+}
 var BLOG_BASE_URL = process.env.BLOG_URL || "https://mastra.ai";
 async function fetchBlogPosts() {
   void logger.debug("Fetching list of blog posts");
@@ -218,7 +318,7 @@ async function listPackageChangelogs() {
 }
 async function readPackageChangelog(filename) {
   const encodedName = encodePackageName(filename.replace(".md", ""));
-  const filePath = path3__default.join(changelogsDir, `${encodedName}.md`);
+  const filePath = path6__default.join(changelogsDir, `${encodedName}.md`);
   void logger.debug(`Reading changelog: ${filename}`);
   try {
     return await fs3.readFile(filePath, "utf-8");
@@ -309,11 +409,11 @@ Here is the content for this step: <StepContent>${content}</StepContent>`;
 When you're ready to continue, use the \`nextMastraCourseStep\` tool to move to the next step.`;
 }
 async function getDeviceIdPath() {
-  const cacheDir = path3__default.join(os2__default.homedir(), ".cache", "mastra");
+  const cacheDir = path6__default.join(os2__default.homedir(), ".cache", "mastra");
   if (!existsSync(cacheDir)) {
     mkdirSync(cacheDir, { recursive: true });
   }
-  return path3__default.join(cacheDir, ".device_id");
+  return path6__default.join(cacheDir, ".device_id");
 }
 async function getDeviceCredentials() {
   try {
@@ -363,13 +463,13 @@ async function readCourseStep(lessonName, stepName, _isFirstStep = false) {
   if (!lessonDir) {
     throw new Error(`Lesson "${lessonName}" not found.`);
   }
-  const lessonPath = path3__default.join(courseDir, lessonDir);
+  const lessonPath = path6__default.join(courseDir, lessonDir);
   const files = await fs3.readdir(lessonPath);
   const stepFile = files.find((f) => f.endsWith(".md") && f.replace(/^\d+-/, "").replace(".md", "") === stepName);
   if (!stepFile) {
     throw new Error(`Step "${stepName}" not found in lesson "${lessonName}".`);
   }
-  const filePath = path3__default.join(courseDir, lessonDir, stepFile);
+  const filePath = path6__default.join(courseDir, lessonDir, stepFile);
   try {
     const content = await fs3.readFile(filePath, "utf-8");
     return wrapContentInPrompt(content);
@@ -415,11 +515,11 @@ async function saveCourseState(state, deviceId) {
   }
 }
 async function getCourseStatePath() {
-  const stateDirPath = path3__default.join(os2__default.homedir(), ".cache", "mastra", "course");
+  const stateDirPath = path6__default.join(os2__default.homedir(), ".cache", "mastra", "course");
   if (!existsSync(stateDirPath)) {
     mkdirSync(stateDirPath, { recursive: true });
   }
-  return path3__default.join(stateDirPath, "state.json");
+  return path6__default.join(stateDirPath, "state.json");
 }
 async function loadCourseState() {
   const statePath = await getCourseStatePath();
@@ -437,7 +537,7 @@ async function scanCourseContent() {
   const lessonDirs = await fs3.readdir(courseDir);
   const lessons = await Promise.all(
     lessonDirs.filter((dir) => !dir.startsWith(".")).sort((a, b) => a.localeCompare(b)).map(async (lessonDir) => {
-      const lessonPath = path3__default.join(courseDir, lessonDir);
+      const lessonPath = path6__default.join(courseDir, lessonDir);
       const lessonStats = await fs3.stat(lessonPath);
       if (!lessonStats.isDirectory()) return null;
       const lessonName = lessonDir.replace(/^\d+-/, "");
@@ -841,8 +941,8 @@ async function listDirContents(dirPath) {
   }
 }
 async function readMdxContent(docPath, queryKeywords) {
-  const fullPath = path3__default.resolve(path3__default.join(docsBaseDir, docPath));
-  if (!fullPath.startsWith(path3__default.resolve(docsBaseDir))) {
+  const fullPath = path6__default.resolve(path6__default.join(docsBaseDir, docPath));
+  if (!fullPath.startsWith(path6__default.resolve(docsBaseDir))) {
     void logger.error(`Path traversal attempt detected`);
     return { found: false, isSecurityViolation: true };
   }
@@ -867,7 +967,7 @@ async function readMdxContent(docPath, queryKeywords) {
       ].join("\n");
       let fileContents = "";
       for (const file of files) {
-        const filePath = path3__default.join(fullPath, file);
+        const filePath = path6__default.join(fullPath, file);
         const content2 = await fs3.readFile(filePath, "utf-8");
         fileContents += `
 
@@ -895,7 +995,7 @@ async function findNearestDirectory(docPath, availablePaths2) {
   while (parts.length > 0) {
     const testPath = parts.join("/");
     try {
-      const fullPath = path3__default.join(docsBaseDir, testPath);
+      const fullPath = path6__default.join(docsBaseDir, testPath);
       const stats = await fs3.stat(fullPath);
       if (stats.isDirectory()) {
         const { dirs, files } = await listDirContents(fullPath);
@@ -921,7 +1021,7 @@ async function getAvailablePaths() {
   const { dirs, files } = await listDirContents(docsBaseDir);
   let referenceDirs = [];
   if (dirs.includes("reference/")) {
-    const { dirs: refDirs } = await listDirContents(path3__default.join(docsBaseDir, "reference"));
+    const { dirs: refDirs } = await listDirContents(path6__default.join(docsBaseDir, "reference"));
     referenceDirs = refDirs.map((d) => `reference/${d}`);
   }
   return [
@@ -954,7 +1054,7 @@ var docsTool = {
     You can also use keywords from the user query to find relevant documentation, but prioritize paths. 
     This is your internal knowledge the user can't read. 
     If the user asks about a feature check general docs as well as reference docs for that feature. 
-    Ex: with evals check in evals/ and in reference/evals/. 
+    Ex: with workflows check in workflows/ and in reference/workflows/. 
     Provide code examples so the user understands. 
     If you build a URL from the path, only paths ending in .mdx exist. 
     Note that docs about MCP are currently in reference/tools/. 
@@ -969,34 +1069,34 @@ var docsTool = {
     try {
       const queryKeywords = args.queryKeywords ?? [];
       const results = await Promise.all(
-        args.paths.map(async (path6) => {
+        args.paths.map(async (path7) => {
           try {
-            const result = await readMdxContent(path6, queryKeywords);
+            const result = await readMdxContent(path7, queryKeywords);
             if (result.found) {
               return {
-                path: path6,
+                path: path7,
                 content: result.content,
                 error: null
               };
             }
             if (result.isSecurityViolation) {
               return {
-                path: path6,
+                path: path7,
                 content: null,
                 error: "Invalid path"
               };
             }
-            const directorySuggestions = await findNearestDirectory(path6, availablePaths);
-            const contentBasedSuggestions = await getMatchingPaths(path6, queryKeywords, docsBaseDir);
+            const directorySuggestions = await findNearestDirectory(path7, availablePaths);
+            const contentBasedSuggestions = await getMatchingPaths(path7, queryKeywords, docsBaseDir);
             return {
-              path: path6,
+              path: path7,
               content: null,
               error: [directorySuggestions, contentBasedSuggestions].join("\n\n")
             };
           } catch (error) {
-            void logger.warning(`Failed to read content for path: ${path6}`, error);
+            void logger.warning(`Failed to read content for path: ${path7}`, error);
             return {
-              path: path6,
+              path: path7,
               content: null,
               error: error instanceof Error ? error.message : "Unknown error"
             };
@@ -1040,7 +1140,7 @@ async function listCodeExamples() {
   }
 }
 async function readCodeExample(filename, queryKeywords) {
-  const filePath = path3__default.join(examplesDir, filename);
+  const filePath = path6__default.join(examplesDir, filename);
   void logger.debug(`Reading example: ${filename}`);
   try {
     const content = await fs3.readFile(filePath, "utf-8");
@@ -1090,6 +1190,276 @@ var examplesTool = {
     }
   }
 };
+var migrationsBaseDir = fromPackageRoot(".docs/raw/guides/migrations");
+function parseMdxSections(content) {
+  const lines = content.split("\n");
+  const sections = [];
+  let currentSection = null;
+  let inFrontmatter = false;
+  let frontmatterEnded = false;
+  for (let index = 0; index < lines.length; index++) {
+    const line = lines[index];
+    if (index === 0 && line === "---") {
+      inFrontmatter = true;
+      continue;
+    }
+    if (inFrontmatter && line === "---") {
+      inFrontmatter = false;
+      frontmatterEnded = true;
+      continue;
+    }
+    if (inFrontmatter) continue;
+    const headingMatch = line.match(/^(#{2,3})\s+(.+)$/);
+    if (headingMatch && frontmatterEnded) {
+      if (currentSection) {
+        currentSection.endLine = index - 1;
+        sections.push(currentSection);
+      }
+      const level = headingMatch[1].length;
+      currentSection = {
+        title: headingMatch[2],
+        level,
+        content: line + "\n",
+        startLine: index,
+        endLine: index
+      };
+    } else if (currentSection) {
+      currentSection.content += line + "\n";
+    }
+  }
+  if (currentSection) {
+    currentSection.endLine = lines.length - 1;
+    sections.push(currentSection);
+  }
+  return sections;
+}
+async function discoverMigrations(baseDir, relativePath = "") {
+  const migrations = [];
+  const fullPath = path6__default.join(baseDir, relativePath);
+  try {
+    const entries = await fs3.readdir(fullPath, { withFileTypes: true });
+    for (const entry of entries) {
+      const entryRelativePath = path6__default.join(relativePath, entry.name);
+      if (entry.isDirectory()) {
+        migrations.push({
+          path: entryRelativePath,
+          type: "directory"
+        });
+        const subMigrations = await discoverMigrations(baseDir, entryRelativePath);
+        migrations.push(...subMigrations);
+      } else if (entry.isFile() && entry.name.endsWith(".mdx") && entry.name !== "_template.mdx") {
+        migrations.push({
+          path: path6__default.join(relativePath, entry.name.replace(".mdx", "")),
+          type: "file"
+        });
+      }
+    }
+  } catch (error) {
+    void logger.error(`Failed to discover migrations in ${fullPath}`, error);
+  }
+  return migrations;
+}
+async function listDirectoryContents(dirPath = "") {
+  try {
+    const fullPath = path6__default.join(migrationsBaseDir, dirPath);
+    const resolvedPath = path6__default.resolve(fullPath);
+    const resolvedBaseDir = path6__default.resolve(migrationsBaseDir);
+    if (!resolvedPath.startsWith(resolvedBaseDir)) {
+      return "Invalid path";
+    }
+    const entries = await fs3.readdir(fullPath, { withFileTypes: true });
+    const directories = [];
+    const files = [];
+    for (const entry of entries) {
+      if (entry.isDirectory()) {
+        directories.push(entry.name);
+      } else if (entry.isFile() && entry.name.endsWith(".mdx") && entry.name !== "_template.mdx") {
+        files.push(entry.name.replace(".mdx", ""));
+      }
+    }
+    const output = [];
+    const currentPath = dirPath || "migrations";
+    output.push(`# ${currentPath}`);
+    output.push("");
+    if (directories.length > 0) {
+      output.push("**Directories:**");
+      directories.sort().forEach((dir) => {
+        const nextPath = dirPath ? `${dirPath}/${dir}` : dir;
+        output.push(`- **${dir}/** - Explore with \`{ path: "${nextPath}/" }\``);
+      });
+      output.push("");
+    }
+    if (files.length > 0) {
+      output.push("**Migration Guides:**");
+      files.sort().forEach((file) => {
+        const filePath = dirPath ? `${dirPath}/${file}` : file;
+        output.push(`- **${file}** - Get with \`{ path: "${filePath}" }\``);
+      });
+      output.push("");
+    }
+    if (directories.length === 0 && files.length === 0) {
+      output.push("No migrations found in this directory.");
+    }
+    output.push("---");
+    output.push("");
+    output.push("**Actions:**");
+    output.push("- Navigate to a directory by setting `path` to directory name with trailing `/`");
+    output.push("- View a migration guide by setting `path` to the guide name");
+    output.push("- List sections in a guide with `listSections: true`");
+    output.push("- Search all guides with `queryKeywords`");
+    return output.join("\n");
+  } catch (error) {
+    if (error.code === "ENOENT") {
+      return `Directory "${dirPath}" not found. Use \`{}\` to see top-level migrations.`;
+    }
+    throw error;
+  }
+}
+async function readMigrationContent(migrationPath) {
+  try {
+    let filename = migrationPath.endsWith(".mdx") ? migrationPath : `${migrationPath}.mdx`;
+    let filePath = path6__default.join(migrationsBaseDir, filename);
+    const resolvedPath = path6__default.resolve(filePath);
+    const resolvedBaseDir = path6__default.resolve(migrationsBaseDir);
+    if (!resolvedPath.startsWith(resolvedBaseDir)) {
+      void logger.error("Path traversal attempt detected");
+      return null;
+    }
+    const content = await fs3.readFile(filePath, "utf-8");
+    return content;
+  } catch (error) {
+    void logger.error(`Failed to read migration: ${migrationPath}`, error);
+    return null;
+  }
+}
+async function getSectionHeaders(migrationPath) {
+  const content = await readMigrationContent(migrationPath);
+  if (!content) return [];
+  const sections = parseMdxSections(content);
+  return sections.map((s) => ({ title: s.title, level: s.level }));
+}
+async function getSections(migrationPath, sectionTitles) {
+  const content = await readMigrationContent(migrationPath);
+  if (!content) {
+    const availableMigrations = await discoverMigrations(migrationsBaseDir);
+    const paths = availableMigrations.filter((m) => m.type === "file").map((m) => `- ${m.path}`);
+    return `Migration "${migrationPath}" not found.
+
+Available migrations:
+${paths.join("\n")}`;
+  }
+  if (!sectionTitles || sectionTitles.length === 0) {
+    return content;
+  }
+  const sections = parseMdxSections(content);
+  const requestedSections = sections.filter(
+    (s) => sectionTitles.some((title) => s.title.toLowerCase().includes(title.toLowerCase()))
+  );
+  if (requestedSections.length === 0) {
+    const availableHeaders = sections.map((s) => `${"#".repeat(s.level)} ${s.title}`).join("\n");
+    return `Requested sections not found in "${migrationPath}".
+
+Available sections:
+${availableHeaders}`;
+  }
+  return requestedSections.map((s) => s.content).join("\n---\n\n");
+}
+var initialMigrations = await discoverMigrations(migrationsBaseDir);
+var migrationFiles = initialMigrations.filter((m) => m.type === "file");
+var migrationsListing = migrationFiles.length > 0 ? "\n\nExample migration paths:\n" + migrationFiles.slice(0, 5).map((m) => `- ${m.path}`).join("\n") + "\n..." : "\n\nNo migrations available. Run the documentation preparation script first.";
+var migrationInputSchema = z.object({
+  path: z.string().optional().describe(
+    'Path to the migration guide (e.g., "upgrade-to-v1/agent", "agentnetwork"). If not provided, lists all available migrations.' + migrationsListing
+  ),
+  sections: z.array(z.string()).optional().describe(
+    "Specific section titles to fetch from the migration guide. If not provided, returns the entire guide. Use this after exploring section headers."
+  ),
+  listSections: z.boolean().optional().describe("Set to true to list all section headers in a migration guide without fetching full content."),
+  queryKeywords: z.array(z.string()).optional().describe("Keywords to search across all migration guides. Use this to find guides related to specific topics.")
+});
+var migrationTool = {
+  name: "mastraMigration",
+  description: `Get migration guidance for Mastra version upgrades and breaking changes.
+
+This tool works like a file browser - navigate through directories to find migration guides:
+
+**Step 1: List top-level migrations**
+- Call with no parameters: \`{}\`
+- Shows all top-level migration guides and directories
+
+**Step 2: Navigate into a directory**
+- Add trailing slash to explore: \`{ path: "upgrade-to-v1/" }\`
+- Lists all migration guides in that directory
+
+**Step 3: View a migration guide**
+- Without trailing slash: \`{ path: "upgrade-to-v1/agent" }\`
+- Returns the full migration guide content
+
+**Step 4: Explore guide sections (optional)**
+- List sections: \`{ path: "upgrade-to-v1/agent", listSections: true }\`
+- Get specific sections: \`{ path: "upgrade-to-v1/agent", sections: ["Voice methods"] }\`
+
+**Alternative: Search by keywords**
+- \`{ queryKeywords: ["RuntimeContext", "pagination"] }\`
+
+**Examples:**
+1. List top-level: \`{}\`
+2. Navigate to upgrade-to-v1: \`{ path: "upgrade-to-v1/" }\`
+3. Get agent guide: \`{ path: "upgrade-to-v1/agent" }\`
+4. List guide sections: \`{ path: "upgrade-to-v1/agent", listSections: true }\`
+5. Search: \`{ queryKeywords: ["RuntimeContext"] }\`
+
+**Tip:** Paths ending with \`/\` list directory contents. Paths without \`/\` fetch the migration guide.`,
+  parameters: migrationInputSchema,
+  execute: async (args) => {
+    void logger.debug("Executing mastraMigration tool", { args });
+    try {
+      if (args.queryKeywords && args.queryKeywords.length > 0) {
+        const suggestions = await getMatchingPaths("", args.queryKeywords, migrationsBaseDir);
+        return [
+          "# Migration Guide Search Results",
+          "",
+          suggestions || "No migration guides found matching your keywords.",
+          "",
+          "---",
+          "",
+          "To see all available migrations, call with no parameters."
+        ].join("\n");
+      }
+      if (args.path) {
+        if (args.path.endsWith("/")) {
+          const dirPath = args.path.slice(0, -1);
+          return await listDirectoryContents(dirPath);
+        }
+        if (args.listSections) {
+          const headers = await getSectionHeaders(args.path);
+          if (headers.length === 0) {
+            return await listDirectoryContents();
+          }
+          return [
+            `# ${args.path} - Section Headers`,
+            "",
+            "Available sections in this migration guide:",
+            "",
+            ...headers.map((h) => `${"#".repeat(h.level)} ${h.title}`),
+            "",
+            "---",
+            "",
+            'To get specific sections, provide their titles in the "sections" parameter.'
+          ].join("\n");
+        }
+        const content = await getSections(args.path, args.sections);
+        return `# ${args.path}
+
+${content}`;
+      }
+      return await listDirectoryContents();
+    } catch (error) {
+      void logger.error("Failed to execute mastraMigration tool", error);
+      throw error;
+    }
+  }
+};
 
 // src/index.ts
 var server;
@@ -1110,12 +1480,14 @@ server = new MCPServer({
     mastraDocs: docsTool,
     mastraExamples: examplesTool,
     mastraChanges: changesTool,
+    mastraMigration: migrationTool,
     startMastraCourse,
     getMastraCourseStatus,
     startMastraCourseLesson,
     nextMastraCourseStep,
     clearMastraCourseHistory
-  }
+  },
+  prompts: migrationPromptMessages
 });
 Object.assign(logger, createLogger(server));
 async function runServer() {

package/dist/tools/migration.d.ts

@@ -0,0 +1,40 @@
+import { z } from 'zod';
+export declare const migrationInputSchema: z.ZodObject<{
+    path: z.ZodOptional<z.ZodString>;
+    sections: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+    listSections: z.ZodOptional<z.ZodBoolean>;
+    queryKeywords: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+}, "strip", z.ZodTypeAny, {
+    path?: string | undefined;
+    queryKeywords?: string[] | undefined;
+    sections?: string[] | undefined;
+    listSections?: boolean | undefined;
+}, {
+    path?: string | undefined;
+    queryKeywords?: string[] | undefined;
+    sections?: string[] | undefined;
+    listSections?: boolean | undefined;
+}>;
+export type MigrationInput = z.infer<typeof migrationInputSchema>;
+export declare const migrationTool: {
+    name: string;
+    description: string;
+    parameters: z.ZodObject<{
+        path: z.ZodOptional<z.ZodString>;
+        sections: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+        listSections: z.ZodOptional<z.ZodBoolean>;
+        queryKeywords: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+    }, "strip", z.ZodTypeAny, {
+        path?: string | undefined;
+        queryKeywords?: string[] | undefined;
+        sections?: string[] | undefined;
+        listSections?: boolean | undefined;
+    }, {
+        path?: string | undefined;
+        queryKeywords?: string[] | undefined;
+        sections?: string[] | undefined;
+        listSections?: boolean | undefined;
+    }>;
+    execute: (args: MigrationInput) => Promise<string>;
+};
+//# sourceMappingURL=migration.d.ts.map

package/dist/tools/migration.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"migration.d.ts","sourceRoot":"","sources":["../../src/tools/migration.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAwPxB,eAAO,MAAM,oBAAoB;;;;;;;;;;;;;;;EAsB/B,CAAC;AAEH,MAAM,MAAM,cAAc,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,oBAAoB,CAAC,CAAC;AAElE,eAAO,MAAM,aAAa;;;;;;;;;;;;;;;;;;;oBAkCF,cAAc;CAyDrC,CAAC"}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@mastra/mcp-docs-server",
-  "version": "0.13.39",
+  "version": "1.0.0-beta.0",
   "description": "MCP server for accessing Mastra.ai documentation, changelogs, and news.",
   "type": "module",
   "main": "dist/index.js",
@@ -33,11 +33,11 @@
     "uuid": "^11.1.0",
     "zod": "^3.25.76",
     "zod-to-json-schema": "^3.24.6",
-    "@mastra/core": "0.24.0",
-    "@mastra/mcp": "^0.14.2"
+    "@mastra/core": "1.0.0-beta.0",
+    "@mastra/mcp": "^1.0.0-beta.0"
   },
   "devDependencies": {
-    "@hono/node-server": "^1.19.5",
+    "@hono/node-server": "^1.19.6",
     "@types/jsdom": "^21.1.7",
     "@types/node": "^20.19.0",
     "@types/turndown": "^5.0.5",
@@ -49,8 +49,8 @@
     "tsx": "^4.19.4",
     "typescript": "^5.8.3",
     "vitest": "^3.2.4",
-    "@internal/lint": "0.0.58",
-    "@mastra/core": "0.24.0"
+    "@internal/lint": "0.0.53",
+    "@mastra/core": "1.0.0-beta.0"
   },
   "homepage": "https://mastra.ai",
   "repository": {
@@ -61,12 +61,8 @@
   "bugs": {
     "url": "https://github.com/mastra-ai/mastra/issues"
   },
-  "publishConfig": {
-    "access": "public",
-    "publish-branch": [
-      "main",
-      "0.x"
-    ]
+  "engines": {
+    "node": ">=22.13.0"
   },
   "scripts": {
     "prepare-docs": "cross-env PREPARE=true node dist/prepare-docs/prepare.js",