mastra 0.16.0 → 0.17.0

package/dist/{chunk-GK64AJRT.js → chunk-H4ZSDLAG.js}

@@ -1,203 +1,137 @@
 import { getAnalytics } from './chunk-OQQFOUQW.js';
-import * as p2 from '@clack/prompts';
+import * as p from '@clack/prompts';
 import color2 from 'picocolors';
-import fs5 from 'fs/promises';
+import fs4 from 'fs/promises';
 import child_process from 'child_process';
 import util from 'util';
-import path3 from 'path';
-import shellQuote from 'shell-quote';
-import yoctoSpinner from 'yocto-spinner';
-import { PinoLogger } from '@mastra/loggers';
-import * as fs4 from 'fs';
-import fs4__default, { existsSync } from 'fs';
-import { execa } from 'execa';
+import path from 'path';
+import shellQuote2 from 'shell-quote';
+import yoctoSpinner2 from 'yocto-spinner';
+import { InvalidArgumentError } from 'commander';
+import * as fs3 from 'fs';
+import fs3__default, { existsSync } from 'fs';
 import os from 'os';
 import fsExtra, { readJSON, ensureFile, writeJSON } from 'fs-extra/esm';
 import prettier from 'prettier';
+import { execa } from 'execa';
 import { fileURLToPath } from 'url';
+import { PinoLogger } from '@mastra/loggers';
 
-// src/commands/utils.ts
-function getPackageManager() {
-  const userAgent = process.env.npm_config_user_agent || "";
-  const execPath = process.env.npm_execpath || "";
-  if (userAgent.includes("yarn")) {
-    return "yarn";
-  }
-  if (userAgent.includes("pnpm")) {
-    return "pnpm";
-  }
-  if (userAgent.includes("npm")) {
-    return "npm";
-  }
-  if (execPath.includes("yarn")) {
-    return "yarn";
-  }
-  if (execPath.includes("pnpm")) {
-    return "pnpm";
+var args = ["-y", "@mastra/mcp-docs-server"];
+var createMcpConfig = (editor) => {
+  if (editor === "vscode") {
+    return {
+      servers: {
+        mastra: process.platform === `win32` ? {
+          command: "cmd",
+          args: ["/c", "npx", ...args],
+          type: "stdio"
+        } : {
+          command: "npx",
+          args,
+          type: "stdio"
+        }
+      }
+    };
   }
-  if (execPath.includes("npm")) {
-    return "npm";
+  return {
+    mcpServers: {
+      mastra: {
+        command: "npx",
+        args
+      }
+    }
+  };
+};
+function makeConfig(original, editor) {
+  if (editor === "vscode") {
+    return {
+      ...original,
+      servers: {
+        ...original?.servers || {},
+        ...createMcpConfig(editor).servers
+      }
+    };
   }
-  return "npm";
+  return {
+    ...original,
+    mcpServers: {
+      ...original?.mcpServers || {},
+      ...createMcpConfig(editor).mcpServers
+    }
+  };
 }
-var logger = createLogger(false);
-function createLogger(debug = false) {
-  return new PinoLogger({
-    name: "Mastra CLI",
-    level: debug ? "debug" : "info"
+async function writeMergedConfig(configPath, editor) {
+  const configExists = existsSync(configPath);
+  const config = makeConfig(configExists ? await readJSON(configPath) : {}, editor);
+  await ensureFile(configPath);
+  await writeJSON(configPath, config, {
+    spaces: 2
   });
 }
-
-// src/utils/clone-template.ts
-var exec = util.promisify(child_process.exec);
-async function cloneTemplate(options) {
-  const { template, projectName, targetDir } = options;
-  const projectPath = targetDir ? path3.resolve(targetDir, projectName) : path3.resolve(projectName);
-  const spinner5 = yoctoSpinner({ text: `Cloning template "${template.title}"...` }).start();
-  try {
-    if (await directoryExists(projectPath)) {
-      spinner5.error(`Directory ${projectName} already exists`);
-      throw new Error(`Directory ${projectName} already exists`);
-    }
-    await cloneRepositoryWithoutGit(template.githubUrl, projectPath);
-    await updatePackageJson(projectPath, projectName);
-    const envExamplePath = path3.join(projectPath, ".env.example");
-    if (await fileExists(envExamplePath)) {
-      await fs5.copyFile(envExamplePath, path3.join(projectPath, ".env"));
-    }
-    spinner5.success(`Template "${template.title}" cloned successfully to ${projectName}`);
-    return projectPath;
-  } catch (error) {
-    spinner5.error(`Failed to clone template: ${error instanceof Error ? error.message : "Unknown error"}`);
-    throw error;
-  }
+var windsurfGlobalMCPConfigPath = path.join(os.homedir(), ".codeium", "windsurf", "mcp_config.json");
+var cursorGlobalMCPConfigPath = path.join(os.homedir(), ".cursor", "mcp.json");
+path.join(process.cwd(), ".vscode", "mcp.json");
+var vscodeGlobalMCPConfigPath = path.join(
+  os.homedir(),
+  process.platform === "win32" ? path.join("AppData", "Roaming", "Code", "User", "settings.json") : process.platform === "darwin" ? path.join("Library", "Application Support", "Code", "User", "settings.json") : path.join(".config", "Code", "User", "settings.json")
+);
+var EDITOR = ["cursor", "cursor-global", "windsurf", "vscode"];
+function isValidEditor(value) {
+  return EDITOR.includes(value);
 }
-async function directoryExists(dirPath) {
-  try {
-    const stat = await fs5.stat(dirPath);
-    return stat.isDirectory();
-  } catch {
-    return false;
+async function installMastraDocsMCPServer({ editor, directory }) {
+  if (editor === `cursor`) {
+    await writeMergedConfig(path.join(directory, ".cursor", "mcp.json"), "cursor");
   }
-}
-async function fileExists(filePath) {
-  try {
-    const stat = await fs5.stat(filePath);
-    return stat.isFile();
-  } catch {
-    return false;
+  if (editor === `vscode`) {
+    await writeMergedConfig(path.join(directory, ".vscode", "mcp.json"), "vscode");
   }
-}
-async function cloneRepositoryWithoutGit(repoUrl, targetPath) {
-  await fs5.mkdir(targetPath, { recursive: true });
-  try {
-    const degitRepo = repoUrl.replace("https://github.com/", "");
-    const degitCommand = shellQuote.quote(["npx", "degit", degitRepo, targetPath]);
-    await exec(degitCommand, {
-      cwd: process.cwd()
-    });
-  } catch {
-    try {
-      const gitCommand = shellQuote.quote(["git", "clone", repoUrl, targetPath]);
-      await exec(gitCommand, {
-        cwd: process.cwd()
-      });
-      const gitDir = path3.join(targetPath, ".git");
-      if (await directoryExists(gitDir)) {
-        await fs5.rm(gitDir, { recursive: true, force: true });
-      }
-    } catch (gitError) {
-      throw new Error(`Failed to clone repository: ${gitError instanceof Error ? gitError.message : "Unknown error"}`);
+  if (editor === `cursor-global`) {
+    const alreadyInstalled = await globalMCPIsAlreadyInstalled(editor);
+    if (alreadyInstalled) {
+      return;
     }
+    await writeMergedConfig(cursorGlobalMCPConfigPath, "cursor-global");
   }
-}
-async function updatePackageJson(projectPath, projectName) {
-  const packageJsonPath = path3.join(projectPath, "package.json");
-  try {
-    const packageJsonContent = await fs5.readFile(packageJsonPath, "utf-8");
-    const packageJson = JSON.parse(packageJsonContent);
-    packageJson.name = projectName;
-    await fs5.writeFile(packageJsonPath, JSON.stringify(packageJson, null, 2), "utf-8");
-  } catch (error) {
-    logger.warn(`Could not update package.json: ${error instanceof Error ? error.message : "Unknown error"}`);
+  if (editor === `windsurf`) {
+    const alreadyInstalled = await globalMCPIsAlreadyInstalled(editor);
+    if (alreadyInstalled) {
+      return;
+    }
+    await writeMergedConfig(windsurfGlobalMCPConfigPath, editor);
   }
 }
-async function installDependencies(projectPath, packageManager) {
-  const spinner5 = yoctoSpinner({ text: "Installing dependencies..." }).start();
-  try {
-    const pm = packageManager || getPackageManager();
-    const installCommand = shellQuote.quote([pm, "install"]);
-    await exec(installCommand, {
-      cwd: projectPath
-    });
-    spinner5.success("Dependencies installed successfully");
-  } catch (error) {
-    spinner5.error(`Failed to install dependencies: ${error instanceof Error ? error.message : "Unknown error"}`);
-    throw error;
+async function globalMCPIsAlreadyInstalled(editor) {
+  let configPath = ``;
+  if (editor === "windsurf") {
+    configPath = windsurfGlobalMCPConfigPath;
+  } else if (editor === "cursor-global") {
+    configPath = cursorGlobalMCPConfigPath;
+  } else if (editor === "vscode") {
+    configPath = vscodeGlobalMCPConfigPath;
   }
-}
-var TEMPLATES_API_URL = process.env.MASTRA_TEMPLATES_API_URL || "https://mastra.ai/api/templates.json";
-async function loadTemplates() {
-  try {
-    const response = await fetch(TEMPLATES_API_URL);
-    if (!response.ok) {
-      throw new Error(`Failed to fetch templates: ${response.statusText}`);
-    }
-    const templates = await response.json();
-    return templates;
-  } catch (error) {
-    console.error("Error loading templates:", error);
-    throw new Error("Failed to load templates. Please check your internet connection and try again.");
+  if (!configPath || !existsSync(configPath)) {
+    return false;
   }
-}
-function pluralize(count, singular, plural) {
-  return count === 1 ? singular : plural || `${singular}s`;
-}
-async function selectTemplate(templates) {
-  const choices = templates.map((template) => {
-    const parts = [];
-    if (template.agents?.length) {
-      parts.push(`${template.agents.length} ${pluralize(template.agents.length, "agent")}`);
-    }
-    if (template.tools?.length) {
-      parts.push(`${template.tools.length} ${pluralize(template.tools.length, "tool")}`);
-    }
-    if (template.workflows?.length) {
-      parts.push(`${template.workflows.length} ${pluralize(template.workflows.length, "workflow")}`);
-    }
-    if (template.mcp?.length) {
-      parts.push(`${template.mcp.length} ${pluralize(template.mcp.length, "MCP server")}`);
-    }
-    if (template.networks?.length) {
-      parts.push(`${template.networks.length} ${pluralize(template.networks.length, "agent network")}`);
+  try {
+    const configContents = await readJSON(configPath);
+    if (!configContents) return false;
+    if (editor === "vscode") {
+      if (!configContents.servers) return false;
+      const hasMastraMCP2 = Object.values(configContents.servers).some(
+        (server) => server?.args?.find((arg) => arg?.includes(`@mastra/mcp-docs-server`))
+      );
+      return hasMastraMCP2;
     }
-    return {
-      value: template,
-      label: template.title,
-      hint: parts.join(", ") || "Template components"
-    };
-  });
-  const selected = await p2.select({
-    message: "Select a template:",
-    options: choices
-  });
-  if (p2.isCancel(selected)) {
-    return null;
+    if (!configContents?.mcpServers) return false;
+    const hasMastraMCP = Object.values(configContents.mcpServers).some(
+      (server) => server?.args?.find((arg) => arg?.includes(`@mastra/mcp-docs-server`))
+    );
+    return hasMastraMCP;
+  } catch {
+    return false;
   }
-  return selected;
-}
-function findTemplateByName(templates, templateName) {
-  let template = templates.find((t) => t.slug === templateName);
-  if (template) return template;
-  const slugWithPrefix = `template-${templateName}`;
-  template = templates.find((t) => t.slug === slugWithPrefix);
-  if (template) return template;
-  template = templates.find((t) => t.title.toLowerCase() === templateName.toLowerCase());
-  if (template) return template;
-  return null;
-}
-function getDefaultProjectName(template) {
-  return template.slug.replace(/^template-/, "");
 }
 
 // src/utils/package-manager.ts
@@ -225,11 +159,11 @@ var DepsService = class {
   findLockFile(dir) {
     const lockFiles = ["pnpm-lock.yaml", "package-lock.json", "yarn.lock", "bun.lock"];
     for (const file of lockFiles) {
-      if (fs4__default.existsSync(path3.join(dir, file))) {
+      if (fs3__default.existsSync(path.join(dir, file))) {
         return file;
       }
     }
-    const parentDir = path3.resolve(dir, "..");
+    const parentDir = path.resolve(dir, "..");
     if (parentDir !== dir) {
       return this.findLockFile(parentDir);
     }
@@ -245,172 +179,60 @@ var DepsService = class {
       case "yarn.lock":
         return "yarn";
       case "bun.lock":
-        return "bun";
-      default:
-        return "npm";
-    }
-  }
-  async installPackages(packages) {
-    const pm = this.packageManager;
-    const installCommand = getPackageManagerAddCommand(pm);
-    const packageList = packages.join(" ");
-    return execa(`${pm} ${installCommand} ${packageList}`, {
-      all: true,
-      shell: true,
-      stdio: "inherit"
-    });
-  }
-  async checkDependencies(dependencies) {
-    try {
-      const packageJsonPath = path3.join(process.cwd(), "package.json");
-      try {
-        await fs5.access(packageJsonPath);
-      } catch {
-        return "No package.json file found in the current directory";
-      }
-      const packageJson = JSON.parse(await fs5.readFile(packageJsonPath, "utf-8"));
-      for (const dependency of dependencies) {
-        if (!packageJson.dependencies || !packageJson.dependencies[dependency]) {
-          return `Please install ${dependency} before running this command (${this.packageManager} install ${dependency})`;
-        }
-      }
-      return "ok";
-    } catch (err) {
-      console.error(err);
-      return "Could not check dependencies";
-    }
-  }
-  async getProjectName() {
-    try {
-      const packageJsonPath = path3.join(process.cwd(), "package.json");
-      const packageJson = await fs5.readFile(packageJsonPath, "utf-8");
-      const pkg = JSON.parse(packageJson);
-      return pkg.name;
-    } catch (err) {
-      throw err;
-    }
-  }
-  async addScriptsToPackageJson(scripts) {
-    const packageJson = JSON.parse(await fs5.readFile("package.json", "utf-8"));
-    packageJson.scripts = {
-      ...packageJson.scripts,
-      ...scripts
-    };
-    await fs5.writeFile("package.json", JSON.stringify(packageJson, null, 2));
-  }
-};
-var args = ["-y", "@mastra/mcp-docs-server"];
-var createMcpConfig = (editor) => {
-  if (editor === "vscode") {
-    return {
-      servers: {
-        mastra: process.platform === `win32` ? {
-          command: "cmd",
-          args: ["/c", "npx", ...args],
-          type: "stdio"
-        } : {
-          command: "npx",
-          args,
-          type: "stdio"
-        }
-      }
-    };
-  }
-  return {
-    mcpServers: {
-      mastra: {
-        command: "npx",
-        args
-      }
-    }
-  };
-};
-function makeConfig(original, editor) {
-  if (editor === "vscode") {
-    return {
-      ...original,
-      servers: {
-        ...original?.servers || {},
-        ...createMcpConfig(editor).servers
-      }
-    };
-  }
-  return {
-    ...original,
-    mcpServers: {
-      ...original?.mcpServers || {},
-      ...createMcpConfig(editor).mcpServers
-    }
-  };
-}
-async function writeMergedConfig(configPath, editor) {
-  const configExists = existsSync(configPath);
-  const config = makeConfig(configExists ? await readJSON(configPath) : {}, editor);
-  await ensureFile(configPath);
-  await writeJSON(configPath, config, {
-    spaces: 2
-  });
-}
-var windsurfGlobalMCPConfigPath = path3.join(os.homedir(), ".codeium", "windsurf", "mcp_config.json");
-var cursorGlobalMCPConfigPath = path3.join(os.homedir(), ".cursor", "mcp.json");
-path3.join(process.cwd(), ".vscode", "mcp.json");
-var vscodeGlobalMCPConfigPath = path3.join(
-  os.homedir(),
-  process.platform === "win32" ? path3.join("AppData", "Roaming", "Code", "User", "settings.json") : process.platform === "darwin" ? path3.join("Library", "Application Support", "Code", "User", "settings.json") : path3.join(".config", "Code", "User", "settings.json")
-);
-async function installMastraDocsMCPServer({ editor, directory }) {
-  if (editor === `cursor`) {
-    await writeMergedConfig(path3.join(directory, ".cursor", "mcp.json"), "cursor");
+        return "bun";
+      default:
+        return "npm";
+    }
   }
-  if (editor === `vscode`) {
-    await writeMergedConfig(path3.join(directory, ".vscode", "mcp.json"), "vscode");
+  async installPackages(packages) {
+    const pm = this.packageManager;
+    const installCommand = getPackageManagerAddCommand(pm);
+    const packageList = packages.join(" ");
+    return execa(`${pm} ${installCommand} ${packageList}`, {
+      all: true,
+      shell: true,
+      stdio: "inherit"
+    });
   }
-  if (editor === `cursor-global`) {
-    const alreadyInstalled = await globalMCPIsAlreadyInstalled(editor);
-    if (alreadyInstalled) {
-      return;
+  async checkDependencies(dependencies) {
+    try {
+      const packageJsonPath = path.join(process.cwd(), "package.json");
+      try {
+        await fs4.access(packageJsonPath);
+      } catch {
+        return "No package.json file found in the current directory";
+      }
+      const packageJson = JSON.parse(await fs4.readFile(packageJsonPath, "utf-8"));
+      for (const dependency of dependencies) {
+        if (!packageJson.dependencies || !packageJson.dependencies[dependency]) {
+          return `Please install ${dependency} before running this command (${this.packageManager} install ${dependency})`;
+        }
+      }
+      return "ok";
+    } catch (err) {
+      console.error(err);
+      return "Could not check dependencies";
     }
-    await writeMergedConfig(cursorGlobalMCPConfigPath, "cursor-global");
   }
-  if (editor === `windsurf`) {
-    const alreadyInstalled = await globalMCPIsAlreadyInstalled(editor);
-    if (alreadyInstalled) {
-      return;
+  async getProjectName() {
+    try {
+      const packageJsonPath = path.join(process.cwd(), "package.json");
+      const packageJson = await fs4.readFile(packageJsonPath, "utf-8");
+      const pkg = JSON.parse(packageJson);
+      return pkg.name;
+    } catch (err) {
+      throw err;
     }
-    await writeMergedConfig(windsurfGlobalMCPConfigPath, editor);
-  }
-}
-async function globalMCPIsAlreadyInstalled(editor) {
-  let configPath = ``;
-  if (editor === "windsurf") {
-    configPath = windsurfGlobalMCPConfigPath;
-  } else if (editor === "cursor-global") {
-    configPath = cursorGlobalMCPConfigPath;
-  } else if (editor === "vscode") {
-    configPath = vscodeGlobalMCPConfigPath;
-  }
-  if (!configPath || !existsSync(configPath)) {
-    return false;
   }
-  try {
-    const configContents = await readJSON(configPath);
-    if (!configContents) return false;
-    if (editor === "vscode") {
-      if (!configContents.servers) return false;
-      const hasMastraMCP2 = Object.values(configContents.servers).some(
-        (server) => server?.args?.find((arg) => arg?.includes(`@mastra/mcp-docs-server`))
-      );
-      return hasMastraMCP2;
-    }
-    if (!configContents?.mcpServers) return false;
-    const hasMastraMCP = Object.values(configContents.mcpServers).some(
-      (server) => server?.args?.find((arg) => arg?.includes(`@mastra/mcp-docs-server`))
-    );
-    return hasMastraMCP;
-  } catch {
-    return false;
+  async addScriptsToPackageJson(scripts) {
+    const packageJson = JSON.parse(await fs4.readFile("package.json", "utf-8"));
+    packageJson.scripts = {
+      ...packageJson.scripts,
+      ...scripts
+    };
+    await fs4.writeFile("package.json", JSON.stringify(packageJson, null, 2));
   }
-}
+};
 
 // src/services/service.env.ts
 var EnvService = class {
@@ -425,7 +247,7 @@ var FileEnvService = class extends EnvService {
   }
   readFile(filePath) {
     return new Promise((resolve, reject) => {
-      fs4.readFile(filePath, "utf8", (err, data) => {
+      fs3.readFile(filePath, "utf8", (err, data) => {
         if (err) reject(err);
         else resolve(data);
       });
@@ -433,7 +255,7 @@ var FileEnvService = class extends EnvService {
   }
   writeFile({ filePath, data }) {
     return new Promise((resolve, reject) => {
-      fs4.writeFile(filePath, data, "utf8", (err) => {
+      fs3.writeFile(filePath, data, "utf8", (err) => {
         if (err) reject(err);
         else resolve();
       });
@@ -488,10 +310,10 @@ var FileService = class {
    */
   async copyStarterFile(inputFile, outputFilePath, replaceIfExists) {
     const __filename = fileURLToPath(import.meta.url);
-    const __dirname = path3.dirname(__filename);
-    const filePath = path3.resolve(__dirname, "starter-files", inputFile);
-    const fileString = fs4__default.readFileSync(filePath, "utf8");
-    if (fs4__default.existsSync(outputFilePath) && !replaceIfExists) {
+    const __dirname = path.dirname(__filename);
+    const filePath = path.resolve(__dirname, "starter-files", inputFile);
+    const fileString = fs3__default.readFileSync(filePath, "utf8");
+    if (fs3__default.existsSync(outputFilePath) && !replaceIfExists) {
       console.info(`${outputFilePath} already exists`);
       return false;
     }
@@ -499,14 +321,14 @@ var FileService = class {
     return true;
   }
   async setupEnvFile({ dbUrl }) {
-    const envPath = path3.join(process.cwd(), ".env.development");
+    const envPath = path.join(process.cwd(), ".env.development");
     await fsExtra.ensureFile(envPath);
     const fileEnvService = new FileEnvService(envPath);
     await fileEnvService.setEnvValue("DB_URL", dbUrl);
   }
   getFirstExistingFile(files) {
     for (const f of files) {
-      if (fs4__default.existsSync(f)) {
+      if (fs3__default.existsSync(f)) {
         return f;
       }
     }
@@ -516,16 +338,24 @@ var FileService = class {
     filePath,
     replacements
   }) {
-    let fileContent = fs4__default.readFileSync(filePath, "utf8");
+    let fileContent = fs3__default.readFileSync(filePath, "utf8");
     replacements.forEach(({ search, replace }) => {
       fileContent = fileContent.replaceAll(search, replace);
     });
-    fs4__default.writeFileSync(filePath, fileContent);
+    fs3__default.writeFileSync(filePath, fileContent);
   }
 };
 
 // src/commands/init/utils.ts
-var exec2 = util.promisify(child_process.exec);
+var exec = util.promisify(child_process.exec);
+var LLMProvider = ["openai", "anthropic", "groq", "google", "cerebras", "mistral"];
+var COMPONENTS = ["agents", "workflows", "tools"];
+function isValidLLMProvider(value) {
+  return LLMProvider.includes(value);
+}
+function areValidComponents(values) {
+  return values.every((value) => COMPONENTS.includes(value));
+}
 var getModelIdentifier = (llmProvider) => {
   if (llmProvider === "openai") {
     return `'openai/gpt-4o-mini'`;
@@ -579,8 +409,8 @@ export const weatherAgent = new Agent({
     parser: "typescript",
     singleQuote: true
   });
-  await fs5.writeFile(destPath, "");
-  await fs5.writeFile(destPath, formattedContent);
+  await fs4.writeFile(destPath, "");
+  await fs4.writeFile(destPath, formattedContent);
 }
 async function writeWorkflowSample(destPath) {
   const content = `import { createStep, createWorkflow } from '@mastra/core/workflows';
@@ -773,7 +603,7 @@ export { weatherWorkflow };`;
     semi: true,
     singleQuote: true
   });
-  await fs5.writeFile(destPath, formattedContent);
+  await fs4.writeFile(destPath, formattedContent);
 }
 async function writeToolSample(destPath) {
   const fileService = new FileService();
@@ -802,15 +632,15 @@ var writeIndexFile = async ({
   addWorkflow
 }) => {
   const indexPath = dirPath + "/index.ts";
-  const destPath = path3.join(indexPath);
+  const destPath = path.join(indexPath);
   try {
-    await fs5.writeFile(destPath, "");
+    await fs4.writeFile(destPath, "");
     const filteredExports = [
       addWorkflow ? `workflows: { weatherWorkflow },` : "",
       addAgent ? `agents: { weatherAgent },` : ""
     ].filter(Boolean);
     if (!addExample) {
-      await fs5.writeFile(
+      await fs4.writeFile(
         destPath,
         `
 import { Mastra } from '@mastra/core';
@@ -820,7 +650,7 @@ export const mastra = new Mastra()
       );
       return;
     }
-    await fs5.writeFile(
+    await fs4.writeFile(
       destPath,
       `
 import { Mastra } from '@mastra/core/mastra';
@@ -862,7 +692,7 @@ var checkAndInstallCoreDeps = async (addExample) => {
     await installCoreDeps("@mastra/core");
   }
   if (needsZod) {
-    await installCoreDeps("zod", "^3");
+    await installCoreDeps("zod", "^4");
   }
   if (addExample) {
     const needsLibsql = await depService.checkDependencies(["@mastra/libsql"]) !== `ok`;
@@ -871,19 +701,19 @@ var checkAndInstallCoreDeps = async (addExample) => {
     }
   }
 };
-var spinner = yoctoSpinner({ text: "Installing Mastra core dependencies\n" });
+var spinner = yoctoSpinner2({ text: "Installing Mastra core dependencies\n" });
 async function installCoreDeps(pkg, version = "latest") {
   try {
-    const confirm2 = await p2.confirm({
+    const confirm2 = await p.confirm({
       message: `You do not have the ${pkg} package installed. Would you like to install it?`,
       initialValue: false
     });
-    if (p2.isCancel(confirm2)) {
-      p2.cancel("Installation Cancelled");
+    if (p.isCancel(confirm2)) {
+      p.cancel("Installation Cancelled");
       process.exit(0);
     }
     if (!confirm2) {
-      p2.cancel("Installation Cancelled");
+      p.cancel("Installation Cancelled");
       process.exit(0);
     }
     spinner.start();
@@ -919,15 +749,15 @@ var getAPIKey = async (provider) => {
 var writeAPIKey = async ({ provider, apiKey }) => {
   const envFileName = apiKey ? ".env" : ".env.example";
   const key = await getAPIKey(provider);
-  const escapedKey = shellQuote.quote([key]);
-  const escapedApiKey = shellQuote.quote([apiKey ? apiKey : "your-api-key"]);
-  await exec2(`echo ${escapedKey}=${escapedApiKey} >> ${envFileName}`);
+  const escapedKey = shellQuote2.quote([key]);
+  const escapedApiKey = shellQuote2.quote([apiKey ? apiKey : "your-api-key"]);
+  await exec(`echo ${escapedKey}=${escapedApiKey} >> ${envFileName}`);
 };
 var createMastraDir = async (directory) => {
   let dir = directory.trim().split("/").filter((item) => item !== "");
-  const dirPath = path3.join(process.cwd(), ...dir, "mastra");
+  const dirPath = path.join(process.cwd(), ...dir, "mastra");
   try {
-    await fs5.access(dirPath);
+    await fs4.access(dirPath);
     return { ok: false };
   } catch {
     await fsExtra.ensureDir(dirPath);
@@ -953,23 +783,23 @@ var LLM_PROVIDERS = [
 var interactivePrompt = async (args2 = {}) => {
   const { skip = {}, options: { showBanner = true } = {} } = args2;
   if (showBanner) {
-    p2.intro(color2.inverse(" Mastra Init "));
+    p.intro(color2.inverse(" Mastra Init "));
   }
-  const mastraProject = await p2.group(
+  const mastraProject = await p.group(
     {
-      directory: () => p2.text({
+      directory: () => p.text({
         message: "Where should we create the Mastra files? (default: src/)",
         placeholder: "src/",
         defaultValue: "src/"
       }),
-      llmProvider: () => skip?.llmProvider ? void 0 : p2.select({
+      llmProvider: () => skip?.llmProvider ? void 0 : p.select({
         message: "Select a default provider:",
         options: LLM_PROVIDERS
       }),
       llmApiKey: async ({ results: { llmProvider } }) => {
         if (skip?.llmApiKey) return void 0;
         const llmName = LLM_PROVIDERS.find((p6) => p6.value === llmProvider)?.label || "provider";
-        const keyChoice = await p2.select({
+        const keyChoice = await p.select({
           message: `Enter your ${llmName} API key?`,
           options: [
             { value: "skip", label: "Skip for now", hint: "default" },
@@ -978,7 +808,7 @@ var interactivePrompt = async (args2 = {}) => {
           initialValue: "skip"
         });
         if (keyChoice === "enter") {
-          return p2.text({
+          return p.text({
             message: "Enter your API key:",
             placeholder: "sk-...",
             validate: (value) => {
@@ -992,7 +822,7 @@ var interactivePrompt = async (args2 = {}) => {
         const windsurfIsAlreadyInstalled = await globalMCPIsAlreadyInstalled(`windsurf`);
         const cursorIsAlreadyInstalled = await globalMCPIsAlreadyInstalled(`cursor`);
         const vscodeIsAlreadyInstalled = await globalMCPIsAlreadyInstalled(`vscode`);
-        const editor = await p2.select({
+        const editor = await p.select({
           message: `Make your IDE into a Mastra expert? (Installs Mastra's MCP server)`,
           options: [
             { value: "skip", label: "Skip for now", hint: "default" },
@@ -1020,24 +850,24 @@ var interactivePrompt = async (args2 = {}) => {
         });
         if (editor === `skip`) return void 0;
         if (editor === `windsurf` && windsurfIsAlreadyInstalled) {
-          p2.log.message(`
+          p.log.message(`
 Windsurf is already installed, skipping.`);
           return void 0;
         }
         if (editor === `vscode` && vscodeIsAlreadyInstalled) {
-          p2.log.message(`
+          p.log.message(`
 VSCode is already installed, skipping.`);
           return void 0;
         }
         if (editor === `cursor`) {
-          p2.log.message(
+          p.log.message(
             `
 Note: you will need to go into Cursor Settings -> MCP Settings and manually enable the installed Mastra MCP server.
 `
           );
         }
         if (editor === `cursor-global`) {
-          const confirm2 = await p2.select({
+          const confirm2 = await p.select({
             message: `Global install will add/update ${cursorGlobalMCPConfigPath} and make the Mastra docs MCP server available in all your Cursor projects. Continue?`,
             options: [
               { value: "yes", label: "Yes, I understand" },
@@ -1049,7 +879,7 @@ Note: you will need to go into Cursor Settings -> MCP Settings and manually enab
           }
         }
         if (editor === `windsurf`) {
-          const confirm2 = await p2.select({
+          const confirm2 = await p.select({
             message: `Windsurf only supports a global MCP config (at ${windsurfGlobalMCPConfigPath}) is it ok to add/update that global config?
 This means the Mastra docs MCP server will be available in all your Windsurf projects.`,
             options: [
@@ -1066,7 +896,7 @@ This means the Mastra docs MCP server will be available in all your Windsurf pro
     },
     {
       onCancel: () => {
-        p2.cancel("Operation cancelled.");
+        p.cancel("Operation cancelled.");
         process.exit(0);
       }
     }
@@ -1075,25 +905,226 @@ This means the Mastra docs MCP server will be available in all your Windsurf pro
 };
 var checkForPkgJson = async () => {
   const cwd = process.cwd();
-  const pkgJsonPath = path3.join(cwd, "package.json");
+  const pkgJsonPath = path.join(cwd, "package.json");
   try {
-    await fs5.access(pkgJsonPath);
+    await fs4.access(pkgJsonPath);
   } catch {
-    p2.log.error(
+    p.log.error(
       'No package.json file found in the current directory. Please run "npm init -y" to create one, or run "npx create-mastra@latest" to create a new Mastra project.'
     );
     process.exit(1);
   }
 };
 
-// src/commands/init/init.ts
-var s = p2.spinner();
+// src/commands/utils.ts
+function getPackageManager() {
+  const userAgent = process.env.npm_config_user_agent || "";
+  const execPath = process.env.npm_execpath || "";
+  if (userAgent.includes("yarn")) {
+    return "yarn";
+  }
+  if (userAgent.includes("pnpm")) {
+    return "pnpm";
+  }
+  if (userAgent.includes("npm")) {
+    return "npm";
+  }
+  if (execPath.includes("yarn")) {
+    return "yarn";
+  }
+  if (execPath.includes("pnpm")) {
+    return "pnpm";
+  }
+  if (execPath.includes("npm")) {
+    return "npm";
+  }
+  return "npm";
+}
+function parseMcp(value) {
+  if (!isValidEditor(value)) {
+    throw new InvalidArgumentError(`Choose a valid value: ${EDITOR.join(", ")}`);
+  }
+  return value;
+}
+function parseComponents(value) {
+  const parsedValue = value.split(",");
+  if (!areValidComponents(parsedValue)) {
+    throw new InvalidArgumentError(`Choose valid components: ${COMPONENTS.join(", ")}`);
+  }
+  return parsedValue;
+}
+function parseLlmProvider(value) {
+  if (!isValidLLMProvider(value)) {
+    throw new InvalidArgumentError(`Choose a valid provider: ${LLMProvider.join(", ")}`);
+  }
+  return value;
+}
+var logger = createLogger(false);
+function createLogger(debug = false) {
+  return new PinoLogger({
+    name: "Mastra CLI",
+    level: debug ? "debug" : "info"
+  });
+}
+
+// src/utils/clone-template.ts
+var exec2 = util.promisify(child_process.exec);
+async function cloneTemplate(options) {
+  const { template, projectName, targetDir } = options;
+  const projectPath = targetDir ? path.resolve(targetDir, projectName) : path.resolve(projectName);
+  const spinner5 = yoctoSpinner2({ text: `Cloning template "${template.title}"...` }).start();
+  try {
+    if (await directoryExists(projectPath)) {
+      spinner5.error(`Directory ${projectName} already exists`);
+      throw new Error(`Directory ${projectName} already exists`);
+    }
+    await cloneRepositoryWithoutGit(template.githubUrl, projectPath);
+    await updatePackageJson(projectPath, projectName);
+    const envExamplePath = path.join(projectPath, ".env.example");
+    if (await fileExists(envExamplePath)) {
+      await fs4.copyFile(envExamplePath, path.join(projectPath, ".env"));
+    }
+    spinner5.success(`Template "${template.title}" cloned successfully to ${projectName}`);
+    return projectPath;
+  } catch (error) {
+    spinner5.error(`Failed to clone template: ${error instanceof Error ? error.message : "Unknown error"}`);
+    throw error;
+  }
+}
+async function directoryExists(dirPath) {
+  try {
+    const stat = await fs4.stat(dirPath);
+    return stat.isDirectory();
+  } catch {
+    return false;
+  }
+}
+async function fileExists(filePath) {
+  try {
+    const stat = await fs4.stat(filePath);
+    return stat.isFile();
+  } catch {
+    return false;
+  }
+}
+async function cloneRepositoryWithoutGit(repoUrl, targetPath) {
+  await fs4.mkdir(targetPath, { recursive: true });
+  try {
+    const degitRepo = repoUrl.replace("https://github.com/", "");
+    const degitCommand = shellQuote2.quote(["npx", "degit", degitRepo, targetPath]);
+    await exec2(degitCommand, {
+      cwd: process.cwd()
+    });
+  } catch {
+    try {
+      const gitCommand = shellQuote2.quote(["git", "clone", repoUrl, targetPath]);
+      await exec2(gitCommand, {
+        cwd: process.cwd()
+      });
+      const gitDir = path.join(targetPath, ".git");
+      if (await directoryExists(gitDir)) {
+        await fs4.rm(gitDir, { recursive: true, force: true });
+      }
+    } catch (gitError) {
+      throw new Error(`Failed to clone repository: ${gitError instanceof Error ? gitError.message : "Unknown error"}`);
+    }
+  }
+}
+async function updatePackageJson(projectPath, projectName) {
+  const packageJsonPath = path.join(projectPath, "package.json");
+  try {
+    const packageJsonContent = await fs4.readFile(packageJsonPath, "utf-8");
+    const packageJson = JSON.parse(packageJsonContent);
+    packageJson.name = projectName;
+    await fs4.writeFile(packageJsonPath, JSON.stringify(packageJson, null, 2), "utf-8");
+  } catch (error) {
+    logger.warn(`Could not update package.json: ${error instanceof Error ? error.message : "Unknown error"}`);
+  }
+}
+async function installDependencies(projectPath, packageManager) {
+  const spinner5 = yoctoSpinner2({ text: "Installing dependencies..." }).start();
+  try {
+    const pm = packageManager || getPackageManager();
+    const installCommand = shellQuote2.quote([pm, "install"]);
+    await exec2(installCommand, {
+      cwd: projectPath
+    });
+    spinner5.success("Dependencies installed successfully");
+  } catch (error) {
+    spinner5.error(`Failed to install dependencies: ${error instanceof Error ? error.message : "Unknown error"}`);
+    throw error;
+  }
+}
+var TEMPLATES_API_URL = process.env.MASTRA_TEMPLATES_API_URL || "https://mastra.ai/api/templates.json";
+async function loadTemplates() {
+  try {
+    const response = await fetch(TEMPLATES_API_URL);
+    if (!response.ok) {
+      throw new Error(`Failed to fetch templates: ${response.statusText}`);
+    }
+    const templates = await response.json();
+    return templates;
+  } catch (error) {
+    console.error("Error loading templates:", error);
+    throw new Error("Failed to load templates. Please check your internet connection and try again.");
+  }
+}
+function pluralize(count, singular, plural) {
+  return count === 1 ? singular : plural || `${singular}s`;
+}
+async function selectTemplate(templates) {
+  const choices = templates.map((template) => {
+    const parts = [];
+    if (template.agents?.length) {
+      parts.push(`${template.agents.length} ${pluralize(template.agents.length, "agent")}`);
+    }
+    if (template.tools?.length) {
+      parts.push(`${template.tools.length} ${pluralize(template.tools.length, "tool")}`);
+    }
+    if (template.workflows?.length) {
+      parts.push(`${template.workflows.length} ${pluralize(template.workflows.length, "workflow")}`);
+    }
+    if (template.mcp?.length) {
+      parts.push(`${template.mcp.length} ${pluralize(template.mcp.length, "MCP server")}`);
+    }
+    if (template.networks?.length) {
+      parts.push(`${template.networks.length} ${pluralize(template.networks.length, "agent network")}`);
+    }
+    return {
+      value: template,
+      label: template.title,
+      hint: parts.join(", ") || "Template components"
+    };
+  });
+  const selected = await p.select({
+    message: "Select a template:",
+    options: choices
+  });
+  if (p.isCancel(selected)) {
+    return null;
+  }
+  return selected;
+}
+function findTemplateByName(templates, templateName) {
+  let template = templates.find((t) => t.slug === templateName);
+  if (template) return template;
+  const slugWithPrefix = `template-${templateName}`;
+  template = templates.find((t) => t.slug === slugWithPrefix);
+  if (template) return template;
+  template = templates.find((t) => t.title.toLowerCase() === templateName.toLowerCase());
+  if (template) return template;
+  return null;
+}
+function getDefaultProjectName(template) {
+  return template.slug.replace(/^template-/, "");
+}
+var s = p.spinner();
 var init = async ({
-  directory,
-  addExample = false,
+  directory = "src/",
   components,
   llmProvider = "openai",
   llmApiKey,
+  addExample = false,
   configureEditorWithDocsMCP
 }) => {
   s.start("Initializing Mastra");
@@ -1143,14 +1174,14 @@ var init = async ({
     }
     s.stop();
     if (!llmApiKey) {
-      p2.note(`
+      p.note(`
       ${color2.green("Mastra initialized successfully!")}
 
       Add your ${color2.cyan(key)} as an environment variable
       in your ${color2.cyan(".env")} file
       `);
     } else {
-      p2.note(`
+      p.note(`
       ${color2.green("Mastra initialized successfully!")}
       `);
     }
@@ -1217,20 +1248,20 @@ var createMastraProject = async ({
   llmApiKey,
   needsInteractive
 }) => {
-  p2.intro(color2.inverse(" Mastra Create "));
-  const projectName = name ?? await p2.text({
+  p.intro(color2.inverse(" Mastra Create "));
+  const projectName = name ?? await p.text({
     message: "What do you want to name your project?",
     placeholder: "my-mastra-app",
     defaultValue: "my-mastra-app",
     validate: (value) => {
       if (value.length === 0) return "Project name cannot be empty";
-      if (fs4__default.existsSync(value)) {
+      if (fs3__default.existsSync(value)) {
         return `A directory named "${value}" already exists. Please choose a different name.`;
       }
     }
   });
-  if (p2.isCancel(projectName)) {
-    p2.cancel("Operation cancelled");
+  if (p.isCancel(projectName)) {
+    p.cancel("Operation cancelled");
     process.exit(0);
   }
   let result;
@@ -1240,11 +1271,11 @@ var createMastraProject = async ({
       skip: { llmProvider: llmProvider !== void 0, llmApiKey: llmApiKey !== void 0 }
     });
   }
-  const s2 = p2.spinner();
+  const s2 = p.spinner();
   try {
     s2.start("Creating project");
     try {
-      await fs5.mkdir(projectName);
+      await fs4.mkdir(projectName);
     } catch (error) {
       if (error instanceof Error && "code" in error && error.code === "EEXIST") {
         s2.stop(`A directory named "${projectName}" already exists. Please choose a different name.`);
@@ -1276,7 +1307,7 @@ var createMastraProject = async ({
     s2.stop("Project structure created");
     s2.start(`Installing ${pm} dependencies`);
     try {
-      await exec3(`${pm} ${installCommand} zod@^3`);
+      await exec3(`${pm} ${installCommand} zod@^4`);
       await exec3(`${pm} ${installCommand} typescript @types/node --save-dev`);
       await exec3(`echo '{
   "compilerOptions": {
@@ -1333,13 +1364,13 @@ var createMastraProject = async ({
       throw new Error(`Failed to create .gitignore: ${error instanceof Error ? error.message : "Unknown error"}`);
     }
     s2.stop(".gitignore added");
-    p2.outro("Project created successfully");
+    p.outro("Project created successfully");
     console.info("");
     return { projectName, result };
   } catch (error) {
     s2.stop();
     const errorMessage = error instanceof Error ? error.message : "An unexpected error occurred";
-    p2.cancel(`Project creation failed: ${errorMessage}`);
+    p.cancel(`Project creation failed: ${errorMessage}`);
     process.exit(1);
   }
 };
@@ -1397,7 +1428,7 @@ var create = async (args2) => {
 };
 var postCreate = ({ projectName }) => {
   const packageManager = getPackageManager();
-  p2.outro(`
+  p.outro(`
    ${color2.green("To start your project:")}
 
     ${color2.cyan("cd")} ${projectName}
@@ -1488,19 +1519,19 @@ async function createFromTemplate(args2) {
     const templates = await loadTemplates();
     const selected = await selectTemplate(templates);
     if (!selected) {
-      p2.log.info("No template selected. Exiting.");
+      p.log.info("No template selected. Exiting.");
       return;
     }
     selectedTemplate = selected;
   } else if (args2.template && typeof args2.template === "string") {
     if (isGitHubUrl(args2.template)) {
-      const spinner5 = p2.spinner();
+      const spinner5 = p.spinner();
       spinner5.start("Validating GitHub repository...");
       const validation = await validateGitHubProject(args2.template);
       if (!validation.isValid) {
         spinner5.stop("Validation failed");
-        p2.log.error("This does not appear to be a valid Mastra project:");
-        validation.errors.forEach((error) => p2.log.error(`  - ${error}`));
+        p.log.error("This does not appear to be a valid Mastra project:");
+        validation.errors.forEach((error) => p.log.error(`  - ${error}`));
         throw new Error("Invalid Mastra project");
       }
       spinner5.stop("Valid Mastra project \u2713");
@@ -1509,8 +1540,8 @@ async function createFromTemplate(args2) {
       const templates = await loadTemplates();
       const found = findTemplateByName(templates, args2.template);
       if (!found) {
-        p2.log.error(`Template "${args2.template}" not found. Available templates:`);
-        templates.forEach((t) => p2.log.info(`  - ${t.title} (use: ${t.slug.replace("template-", "")})`));
+        p.log.error(`Template "${args2.template}" not found. Available templates:`);
+        templates.forEach((t) => p.log.info(`  - ${t.title} (use: ${t.slug.replace("template-", "")})`));
         throw new Error(`Template "${args2.template}" not found`);
       }
       selectedTemplate = found;
@@ -1522,13 +1553,13 @@ async function createFromTemplate(args2) {
   let projectName = args2.projectName;
   if (!projectName) {
     const defaultName = getDefaultProjectName(selectedTemplate);
-    const response = await p2.text({
+    const response = await p.text({
       message: "What is your project name?",
       defaultValue: defaultName,
       placeholder: defaultName
     });
-    if (p2.isCancel(response)) {
-      p2.log.info("Project creation cancelled.");
+    if (p.isCancel(response)) {
+      p.log.info("Project creation cancelled.");
       return;
     }
     projectName = response;
@@ -1546,7 +1577,7 @@ async function createFromTemplate(args2) {
       projectName
     });
     await installDependencies(projectPath);
-    p2.note(`
+    p.note(`
       ${color2.green("Mastra template installed!")}
 
       Add the necessary environment
@@ -1554,11 +1585,11 @@ async function createFromTemplate(args2) {
       `);
     postCreate({ projectName });
   } catch (error) {
-    p2.log.error(`Failed to create project from template: ${error instanceof Error ? error.message : "Unknown error"}`);
+    p.log.error(`Failed to create project from template: ${error instanceof Error ? error.message : "Unknown error"}`);
     throw error;
   }
 }
 
-export { DepsService, FileService, checkAndInstallCoreDeps, checkForPkgJson, create, createLogger, init, interactivePrompt, logger };
-//# sourceMappingURL=chunk-GK64AJRT.js.map
-//# sourceMappingURL=chunk-GK64AJRT.js.map
+export { COMPONENTS, DepsService, FileService, LLMProvider, checkAndInstallCoreDeps, checkForPkgJson, create, createLogger, init, interactivePrompt, logger, parseComponents, parseLlmProvider, parseMcp };
+//# sourceMappingURL=chunk-H4ZSDLAG.js.map
+//# sourceMappingURL=chunk-H4ZSDLAG.js.map