mastra 1.0.0-beta.1 → 1.0.0-beta.10

package/dist/{chunk-NHL3S2MZ.js → chunk-THUIZ4X5.js}

@@ -1,138 +1,130 @@
-import { getAnalytics } from './chunk-OQQFOUQW.js';
-import * as p from '@clack/prompts';
-import color2 from 'picocolors';
+import { getAnalytics } from './chunk-TL3K64EI.js';
+import * as fs3 from 'fs';
+import fs3__default, { existsSync } from 'fs';
 import fs4 from 'fs/promises';
+import * as p5 from '@clack/prompts';
+import color2 from 'picocolors';
 import child_process from 'child_process';
+import path3 from 'path';
 import util from 'util';
-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 os from 'os';
+import { InvalidArgumentError } from 'commander';
+import fsExtra3 from 'fs-extra';
 import { PinoLogger } from '@mastra/loggers';
 
-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"
-        }
-      }
-    };
+// package.json
+var package_default = {
+  name: "mastra",
+  version: "1.0.0-beta.10",
+  license: "Apache-2.0",
+  description: "cli for mastra",
+  type: "module",
+  main: "dist/index.js",
+  types: "dist/index.d.ts",
+  bin: {
+    mastra: "./dist/index.js"
+  },
+  exports: {
+    ".": "./dist/index.js",
+    "./package.json": "./package.json",
+    "./telemetry-loader": "./dist/commands/dev/telemetry-loader.js",
+    "./dist/*": [
+      "./dist/*",
+      "./dist/*.js"
+    ]
+  },
+  files: [
+    "dist",
+    "CHANGELOG.md"
+  ],
+  scripts: {
+    "build:lib": "tsup --silent --config tsup.config.ts",
+    test: "vitest run",
+    "test:watch": "vitest watch",
+    clean: "rm -rf dist && rm -rf node_modules",
+    typecheck: "tsc --noEmit --incremental",
+    lint: "eslint ."
+  },
+  keywords: [
+    "mastra",
+    "cli",
+    "ai",
+    "llm",
+    "llms",
+    "agent",
+    "agents",
+    "dev",
+    "development",
+    "deploy",
+    "deployment",
+    "build",
+    "workflow",
+    "typescript",
+    "command-line",
+    "devtools"
+  ],
+  dependencies: {
+    "@clack/prompts": "^0.11.0",
+    "@expo/devcert": "^1.2.1",
+    "@mastra/deployer": "workspace:^",
+    "@mastra/loggers": "workspace:^",
+    commander: "^14.0.2",
+    dotenv: "^17.2.3",
+    execa: "^9.6.1",
+    "fs-extra": "^11.3.2",
+    "get-port": "^7.1.0",
+    picocolors: "^1.1.1",
+    "posthog-node": "5.17.2",
+    prettier: "^3.7.4",
+    serve: "^14.2.5",
+    "serve-handler": "^6.1.6",
+    "shell-quote": "^1.8.3",
+    "strip-json-comments": "^5.0.3",
+    "yocto-spinner": "^1.0.0"
+  },
+  devDependencies: {
+    "@commander-js/extra-typings": "^14.0.0",
+    "@internal/lint": "workspace:*",
+    "@internal/playground": "workspace:*",
+    "@internal/types-builder": "workspace:*",
+    "@mastra/core": "workspace:*",
+    "@types/fs-extra": "^11.0.4",
+    "@types/node": "22.13.17",
+    "@types/serve-handler": "^6.1.4",
+    "@types/shell-quote": "^1.7.5",
+    "@vitest/coverage-v8": "catalog:",
+    "@vitest/ui": "catalog:",
+    eslint: "^9.37.0",
+    memfs: "^4.51.1",
+    rollup: "^4.50.2",
+    tsup: "^8.5.1",
+    "type-fest": "^5.3.1",
+    typescript: "^5.9.3",
+    vitest: "catalog:"
+  },
+  peerDependencies: {
+    "@mastra/core": ">=1.0.0-0 <2.0.0-0",
+    zod: "^3.25.0 || ^4.0.0"
+  },
+  homepage: "https://mastra.ai",
+  repository: {
+    type: "git",
+    url: "git+https://github.com/mastra-ai/mastra.git",
+    directory: "packages/cli"
+  },
+  bugs: {
+    url: "https://github.com/mastra-ai/mastra/issues"
+  },
+  engines: {
+    node: ">=22.13.0"
   }
-  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 = 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 installMastraDocsMCPServer({ editor, directory }) {
-  if (editor === `cursor`) {
-    await writeMergedConfig(path.join(directory, ".cursor", "mcp.json"), "cursor");
-  }
-  if (editor === `vscode`) {
-    await writeMergedConfig(path.join(directory, ".vscode", "mcp.json"), "vscode");
-  }
-  if (editor === `cursor-global`) {
-    const alreadyInstalled = await globalMCPIsAlreadyInstalled(editor);
-    if (alreadyInstalled) {
-      return;
-    }
-    await writeMergedConfig(cursorGlobalMCPConfigPath, "cursor-global");
-  }
-  if (editor === `windsurf`) {
-    const alreadyInstalled = await globalMCPIsAlreadyInstalled(editor);
-    if (alreadyInstalled) {
-      return;
-    }
-    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;
-  }
-}
 
 // src/utils/package-manager.ts
 function getPackageManagerAddCommand(pm) {
@@ -159,11 +151,11 @@ var DepsService = class {
   findLockFile(dir) {
     const lockFiles = ["pnpm-lock.yaml", "package-lock.json", "yarn.lock", "bun.lock"];
     for (const file of lockFiles) {
-      if (fs3__default.existsSync(path.join(dir, file))) {
+      if (fs3__default.existsSync(path3.join(dir, file))) {
         return file;
       }
     }
-    const parentDir = path.resolve(dir, "..");
+    const parentDir = path3.resolve(dir, "..");
     if (parentDir !== dir) {
       return this.findLockFile(parentDir);
     }
@@ -196,7 +188,7 @@ var DepsService = class {
   }
   async checkDependencies(dependencies) {
     try {
-      const packageJsonPath = path.join(process.cwd(), "package.json");
+      const packageJsonPath = path3.join(process.cwd(), "package.json");
       try {
         await fs4.access(packageJsonPath);
       } catch {
@@ -216,7 +208,7 @@ var DepsService = class {
   }
   async getProjectName() {
     try {
-      const packageJsonPath = path.join(process.cwd(), "package.json");
+      const packageJsonPath = path3.join(process.cwd(), "package.json");
       const packageJson = await fs4.readFile(packageJsonPath, "utf-8");
       const pkg = JSON.parse(packageJson);
       return pkg.name;
@@ -310,8 +302,8 @@ var FileService = class {
    */
   async copyStarterFile(inputFile, outputFilePath, replaceIfExists) {
     const __filename = fileURLToPath(import.meta.url);
-    const __dirname = path.dirname(__filename);
-    const filePath = path.resolve(__dirname, "starter-files", inputFile);
+    const __dirname = path3.dirname(__filename);
+    const filePath = path3.resolve(__dirname, "starter-files", inputFile);
     const fileString = fs3__default.readFileSync(filePath, "utf8");
     if (fs3__default.existsSync(outputFilePath) && !replaceIfExists) {
       console.info(`${outputFilePath} already exists`);
@@ -321,7 +313,7 @@ var FileService = class {
     return true;
   }
   async setupEnvFile({ dbUrl }) {
-    const envPath = path.join(process.cwd(), ".env.development");
+    const envPath = path3.join(process.cwd(), ".env.development");
     await fsExtra.ensureFile(envPath);
     const fileEnvService = new FileEnvService(envPath);
     await fileEnvService.setEnvValue("DB_URL", dbUrl);
@@ -345,6 +337,131 @@ var FileService = class {
     fs3__default.writeFileSync(filePath, fileContent);
   }
 };
+var createArgs = (versionTag) => {
+  const packageName = versionTag ? `@mastra/mcp-docs-server@${versionTag}` : "@mastra/mcp-docs-server";
+  return ["-y", packageName];
+};
+var createMcpConfig = (editor, versionTag) => {
+  const args = createArgs(versionTag);
+  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, versionTag) {
+  if (editor === "vscode") {
+    return {
+      ...original,
+      servers: {
+        ...original?.servers || {},
+        ...createMcpConfig(editor, versionTag).servers
+      }
+    };
+  }
+  return {
+    ...original,
+    mcpServers: {
+      ...original?.mcpServers || {},
+      ...createMcpConfig(editor, versionTag).mcpServers
+    }
+  };
+}
+async function writeMergedConfig(configPath, editor, versionTag) {
+  const configExists = existsSync(configPath);
+  const config = makeConfig(configExists ? await readJSON(configPath) : {}, editor, versionTag);
+  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")
+);
+var EDITOR = ["cursor", "cursor-global", "windsurf", "vscode"];
+function isValidEditor(value) {
+  return EDITOR.includes(value);
+}
+async function installMastraDocsMCPServer({
+  editor,
+  directory,
+  versionTag
+}) {
+  if (editor === `cursor`) {
+    await writeMergedConfig(path3.join(directory, ".cursor", "mcp.json"), "cursor", versionTag);
+  }
+  if (editor === `vscode`) {
+    await writeMergedConfig(path3.join(directory, ".vscode", "mcp.json"), "vscode", versionTag);
+  }
+  if (editor === `cursor-global`) {
+    const alreadyInstalled = await globalMCPIsAlreadyInstalled(editor, versionTag);
+    if (alreadyInstalled) {
+      return;
+    }
+    await writeMergedConfig(cursorGlobalMCPConfigPath, "cursor-global", versionTag);
+  }
+  if (editor === `windsurf`) {
+    const alreadyInstalled = await globalMCPIsAlreadyInstalled(editor, versionTag);
+    if (alreadyInstalled) {
+      return;
+    }
+    await writeMergedConfig(windsurfGlobalMCPConfigPath, editor, versionTag);
+  }
+}
+async function globalMCPIsAlreadyInstalled(editor, versionTag) {
+  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;
+    const expectedPackage = versionTag ? `@mastra/mcp-docs-server@${versionTag}` : "@mastra/mcp-docs-server";
+    if (editor === "vscode") {
+      if (!configContents.servers) return false;
+      const hasMastraMCP2 = Object.values(configContents.servers).some(
+        (server) => server?.args?.find((arg) => arg === expectedPackage)
+      );
+      return hasMastraMCP2;
+    }
+    if (!configContents?.mcpServers) return false;
+    const hasMastraMCP = Object.values(configContents.mcpServers).some(
+      (server) => server?.args?.find((arg) => arg === expectedPackage)
+    );
+    return hasMastraMCP;
+  } catch {
+    return false;
+  }
+}
 
 // src/commands/init/utils.ts
 var exec = util.promisify(child_process.exec);
@@ -357,19 +474,19 @@ function areValidComponents(values) {
   return values.every((value) => COMPONENTS.includes(value));
 }
 var getModelIdentifier = (llmProvider) => {
-  if (llmProvider === "openai") {
-    return `'openai/gpt-4o-mini'`;
-  } else if (llmProvider === "anthropic") {
-    return `'anthropic/claude-sonnet-4-5-20250929'`;
+  let model = "openai/gpt-4o";
+  if (llmProvider === "anthropic") {
+    model = "anthropic/claude-sonnet-4-5";
   } else if (llmProvider === "groq") {
-    return `'groq/llama-3.3-70b-versatile'`;
+    model = "groq/llama-3.3-70b-versatile";
   } else if (llmProvider === "google") {
-    return `'google/gemini-2.5-pro'`;
+    model = "google/gemini-2.5-pro";
   } else if (llmProvider === "cerebras") {
-    return `'cerebras/llama-3.3-70b'`;
+    model = "cerebras/llama-3.3-70b";
   } else if (llmProvider === "mistral") {
-    return `'mistral/mistral-medium-2508'`;
+    model = "mistral/mistral-medium-2508";
   }
+  return model;
 };
 async function writeAgentSample(llmProvider, destPath, addExampleTool, addScorers) {
   const modelString = getModelIdentifier(llmProvider);
@@ -398,7 +515,7 @@ export const weatherAgent = new Agent({
   id: 'weather-agent',
   name: 'Weather Agent',
   instructions: \`${instructions}\`,
-  model: ${modelString},
+  model: '${modelString}',
   ${addExampleTool ? "tools: { weatherTool }," : ""}
   ${addScorers ? `scorers: {
     toolCallAppropriateness: {
@@ -657,7 +774,7 @@ export const translationScorer = createScorer({
   description: 'Checks that non-English location names are translated and used correctly',
   type: 'agent',
   judge: {
-    model: ${modelString},
+    model: '${modelString}',
     instructions:
       'You are an expert evaluator of translation quality for geographic locations. ' +
       'Determine whether the user text mentions a non-English location and whether the assistant correctly uses an English translation of that location. ' +
@@ -754,7 +871,7 @@ var writeIndexFile = async ({
   addScorers
 }) => {
   const indexPath = dirPath + "/index.ts";
-  const destPath = path.join(indexPath);
+  const destPath = path3.join(indexPath);
   try {
     await fs4.writeFile(destPath, "");
     const filteredExports = [
@@ -806,9 +923,10 @@ export const mastra = new Mastra({
     throw err;
   }
 };
-var checkAndInstallCoreDeps = async (addExample) => {
+var checkAndInstallCoreDeps = async (addExample, versionTag) => {
   const spinner4 = yoctoSpinner2({ text: "Installing Mastra core dependencies" });
   let packages = [];
+  const mastraVersionTag = versionTag || "latest";
   try {
     const depService = new DepsService();
     spinner4.start();
@@ -816,10 +934,10 @@ var checkAndInstallCoreDeps = async (addExample) => {
     const needsCli = await depService.checkDependencies(["mastra"]) !== `ok`;
     const needsZod = await depService.checkDependencies(["zod"]) !== `ok`;
     if (needsCore) {
-      packages.push({ name: "@mastra/core", version: "latest" });
+      packages.push({ name: "@mastra/core", version: mastraVersionTag });
     }
     if (needsCli) {
-      packages.push({ name: "mastra", version: "latest" });
+      packages.push({ name: "mastra", version: mastraVersionTag });
     }
     if (needsZod) {
       packages.push({ name: "zod", version: "^4" });
@@ -827,7 +945,7 @@ var checkAndInstallCoreDeps = async (addExample) => {
     if (addExample) {
       const needsLibsql = await depService.checkDependencies(["@mastra/libsql"]) !== `ok`;
       if (needsLibsql) {
-        packages.push({ name: "@mastra/libsql", version: "latest" });
+        packages.push({ name: "@mastra/libsql", version: mastraVersionTag });
       }
     }
     if (packages.length > 0) {
@@ -869,7 +987,7 @@ var writeAPIKey = async ({ provider, apiKey }) => {
 };
 var createMastraDir = async (directory) => {
   let dir = directory.trim().split("/").filter((item) => item !== "");
-  const dirPath = path.join(process.cwd(), ...dir, "mastra");
+  const dirPath = path3.join(process.cwd(), ...dir, "mastra");
   try {
     await fs4.access(dirPath);
     return { ok: false };
@@ -894,26 +1012,26 @@ var LLM_PROVIDERS = [
   { value: "cerebras", label: "Cerebras" },
   { value: "mistral", label: "Mistral" }
 ];
-var interactivePrompt = async (args2 = {}) => {
-  const { skip = {}, options: { showBanner = true } = {} } = args2;
+var interactivePrompt = async (args = {}) => {
+  const { skip = {}, options: { showBanner = true } = {} } = args;
   if (showBanner) {
-    p.intro(color2.inverse(" Mastra Init "));
+    p5.intro(color2.inverse(" Mastra Init "));
   }
-  const mastraProject = await p.group(
+  const mastraProject = await p5.group(
     {
-      directory: () => p.text({
+      directory: () => p5.text({
         message: "Where should we create the Mastra files? (default: src/)",
         placeholder: "src/",
         defaultValue: "src/"
       }),
-      llmProvider: () => skip?.llmProvider ? void 0 : p.select({
+      llmProvider: () => skip?.llmProvider ? void 0 : p5.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 p.select({
+        const keyChoice = await p5.select({
           message: `Enter your ${llmName} API key?`,
           options: [
             { value: "skip", label: "Skip for now", hint: "default" },
@@ -922,7 +1040,7 @@ var interactivePrompt = async (args2 = {}) => {
           initialValue: "skip"
         });
         if (keyChoice === "enter") {
-          return p.text({
+          return p5.text({
             message: "Enter your API key:",
             placeholder: "sk-...",
             validate: (value) => {
@@ -933,67 +1051,50 @@ var interactivePrompt = async (args2 = {}) => {
         return void 0;
       },
       configureEditorWithDocsMCP: async () => {
-        const windsurfIsAlreadyInstalled = await globalMCPIsAlreadyInstalled(`windsurf`);
-        const cursorIsAlreadyInstalled = await globalMCPIsAlreadyInstalled(`cursor`);
-        const vscodeIsAlreadyInstalled = await globalMCPIsAlreadyInstalled(`vscode`);
-        const editor = await p.select({
+        const editor = await p5.select({
           message: `Make your IDE into a Mastra expert? (Installs Mastra's MCP server)`,
           options: [
             { value: "skip", label: "Skip for now", hint: "default" },
             {
               value: "cursor",
-              label: "Cursor (project only)",
-              hint: cursorIsAlreadyInstalled ? `Already installed globally` : void 0
+              label: "Cursor (project only)"
             },
             {
               value: "cursor-global",
-              label: "Cursor (global, all projects)",
-              hint: cursorIsAlreadyInstalled ? `Already installed` : void 0
+              label: "Cursor (global, all projects)"
             },
             {
               value: "windsurf",
-              label: "Windsurf",
-              hint: windsurfIsAlreadyInstalled ? `Already installed` : void 0
+              label: "Windsurf"
             },
             {
               value: "vscode",
-              label: "VSCode",
-              hint: vscodeIsAlreadyInstalled ? `Already installed` : void 0
+              label: "VSCode"
             }
           ]
         });
         if (editor === `skip`) return void 0;
-        if (editor === `windsurf` && windsurfIsAlreadyInstalled) {
-          p.log.message(`
-Windsurf is already installed, skipping.`);
-          return void 0;
-        }
-        if (editor === `vscode` && vscodeIsAlreadyInstalled) {
-          p.log.message(`
-VSCode is already installed, skipping.`);
-          return void 0;
-        }
         if (editor === `cursor`) {
-          p.log.message(
+          p5.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 confirm = await p.select({
+          const confirm3 = await p5.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" },
               { value: "skip", label: "No, skip for now" }
             ]
           });
-          if (confirm !== `yes`) {
+          if (confirm3 !== `yes`) {
             return void 0;
           }
         }
         if (editor === `windsurf`) {
-          const confirm = await p.select({
+          const confirm3 = await p5.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: [
@@ -1001,16 +1102,22 @@ This means the Mastra docs MCP server will be available in all your Windsurf pro
               { value: "skip", label: "No, skip for now" }
             ]
           });
-          if (confirm !== `yes`) {
+          if (confirm3 !== `yes`) {
             return void 0;
           }
         }
         return editor;
+      },
+      initGit: async () => {
+        return p5.confirm({
+          message: "Initialize a new git repository?",
+          initialValue: true
+        });
       }
     },
     {
       onCancel: () => {
-        p.cancel("Operation cancelled.");
+        p5.cancel("Operation cancelled.");
         process.exit(0);
       }
     }
@@ -1019,21 +1126,22 @@ This means the Mastra docs MCP server will be available in all your Windsurf pro
 };
 var checkForPkgJson = async () => {
   const cwd = process.cwd();
-  const pkgJsonPath = path.join(cwd, "package.json");
+  const pkgJsonPath = path3.join(cwd, "package.json");
   try {
     await fs4.access(pkgJsonPath);
   } catch {
-    p.log.error(
+    p5.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/utils.ts
 function getPackageManager() {
   const userAgent = process.env.npm_config_user_agent || "";
   const execPath = process.env.npm_execpath || "";
+  if (userAgent.includes("bun")) {
+    return "bun";
+  }
   if (userAgent.includes("yarn")) {
     return "yarn";
   }
@@ -1043,6 +1151,9 @@ function getPackageManager() {
   if (userAgent.includes("npm")) {
     return "npm";
   }
+  if (execPath.includes("bun")) {
+    return "bun";
+  }
   if (execPath.includes("yarn")) {
     return "yarn";
   }
@@ -1073,6 +1184,36 @@ function parseLlmProvider(value) {
   }
   return value;
 }
+function shouldSkipDotenvLoading() {
+  return process.env.MASTRA_SKIP_DOTENV === "true" || process.env.MASTRA_SKIP_DOTENV === "1";
+}
+async function getVersionTag() {
+  try {
+    const pkgPath = fileURLToPath(import.meta.resolve("mastra/package.json"));
+    const json = await fsExtra3.readJSON(pkgPath);
+    const currentVersion = json.version;
+    const { stdout } = await execa("npm", ["dist-tag", "ls", "mastra"]);
+    const tagLine = stdout.split("\n").find((distLine) => distLine.endsWith(`: ${currentVersion}`));
+    const tag = tagLine ? tagLine.split(":")[0]?.trim() : void 0;
+    return tag;
+  } catch {
+    return void 0;
+  }
+}
+async function gitInit({ cwd }) {
+  await execa("git", ["init"], { cwd, stdio: "ignore" });
+  await execa("git", ["add", "-A"], { cwd, stdio: "ignore" });
+  await execa(
+    "git",
+    [
+      "commit",
+      "-m",
+      '"Initial commit from Mastra"',
+      '--author="dane-ai-mastra[bot] <dane-ai-mastra[bot]@users.noreply.github.com>"'
+    ],
+    { cwd, stdio: "ignore" }
+  );
+}
 var logger = createLogger(false);
 function createLogger(debug = false) {
   return new PinoLogger({
@@ -1084,19 +1225,23 @@ function createLogger(debug = false) {
 // 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 { template, projectName, targetDir, branch, llmProvider } = options;
+  const projectPath = targetDir ? path3.resolve(targetDir, projectName) : path3.resolve(projectName);
   const spinner4 = yoctoSpinner2({ text: `Cloning template "${template.title}"...` }).start();
   try {
     if (await directoryExists(projectPath)) {
       spinner4.error(`Directory ${projectName} already exists`);
       throw new Error(`Directory ${projectName} already exists`);
     }
-    await cloneRepositoryWithoutGit(template.githubUrl, projectPath);
+    await cloneRepositoryWithoutGit(template.githubUrl, projectPath, branch);
     await updatePackageJson(projectPath, projectName);
-    const envExamplePath = path.join(projectPath, ".env.example");
+    const envExamplePath = path3.join(projectPath, ".env.example");
     if (await fileExists(envExamplePath)) {
-      await fs4.copyFile(envExamplePath, path.join(projectPath, ".env"));
+      const envPath = path3.join(projectPath, ".env");
+      await fs4.copyFile(envExamplePath, envPath);
+      if (llmProvider) {
+        await updateEnvFile(envPath, llmProvider);
+      }
     }
     spinner4.success(`Template "${template.title}" cloned successfully to ${projectName}`);
     return projectPath;
@@ -1121,21 +1266,27 @@ async function fileExists(filePath) {
     return false;
   }
 }
-async function cloneRepositoryWithoutGit(repoUrl, targetPath) {
+async function cloneRepositoryWithoutGit(repoUrl, targetPath, branch) {
   await fs4.mkdir(targetPath, { recursive: true });
   try {
     const degitRepo = repoUrl.replace("https://github.com/", "");
-    const degitCommand = shellQuote2.quote(["npx", "degit", degitRepo, targetPath]);
+    const degitRepoWithBranch = branch ? `${degitRepo}#${branch}` : degitRepo;
+    const degitCommand = shellQuote2.quote(["npx", "degit", degitRepoWithBranch, targetPath]);
     await exec2(degitCommand, {
       cwd: process.cwd()
     });
   } catch {
     try {
-      const gitCommand = shellQuote2.quote(["git", "clone", repoUrl, targetPath]);
+      const gitArgs = ["git", "clone"];
+      if (branch) {
+        gitArgs.push("--branch", branch);
+      }
+      gitArgs.push(repoUrl, targetPath);
+      const gitCommand = shellQuote2.quote(gitArgs);
       await exec2(gitCommand, {
         cwd: process.cwd()
       });
-      const gitDir = path.join(targetPath, ".git");
+      const gitDir = path3.join(targetPath, ".git");
       if (await directoryExists(gitDir)) {
         await fs4.rm(gitDir, { recursive: true, force: true });
       }
@@ -1145,7 +1296,7 @@ async function cloneRepositoryWithoutGit(repoUrl, targetPath) {
   }
 }
 async function updatePackageJson(projectPath, projectName) {
-  const packageJsonPath = path.join(projectPath, "package.json");
+  const packageJsonPath = path3.join(projectPath, "package.json");
   try {
     const packageJsonContent = await fs4.readFile(packageJsonPath, "utf-8");
     const packageJson = JSON.parse(packageJsonContent);
@@ -1155,6 +1306,22 @@ async function updatePackageJson(projectPath, projectName) {
     logger.warn(`Could not update package.json: ${error instanceof Error ? error.message : "Unknown error"}`);
   }
 }
+async function updateEnvFile(envPath, llmProvider) {
+  try {
+    const envContent = await fs4.readFile(envPath, "utf-8");
+    const modelString = getModelIdentifier(llmProvider);
+    if (!modelString) {
+      logger.warn(`Could not get model identifier for provider: ${llmProvider}`);
+      return;
+    }
+    const modelValue = modelString.replace(/'/g, "");
+    const updatedContent = envContent.replace(/^MODEL=.*/m, `MODEL=${modelValue}`);
+    await fs4.writeFile(envPath, updatedContent, "utf-8");
+    logger.info(`Updated MODEL in .env to ${modelValue}`);
+  } catch (error) {
+    logger.warn(`Could not update .env file: ${error instanceof Error ? error.message : "Unknown error"}`);
+  }
+}
 async function installDependencies(projectPath, packageManager) {
   const spinner4 = yoctoSpinner2({ text: "Installing dependencies..." }).start();
   try {
@@ -1210,11 +1377,11 @@ async function selectTemplate(templates) {
       hint: parts.join(", ") || "Template components"
     };
   });
-  const selected = await p.select({
+  const selected = await p5.select({
     message: "Select a template:",
     options: choices
   });
-  if (p.isCancel(selected)) {
+  if (p5.isCancel(selected)) {
     return null;
   }
   return selected;
@@ -1232,7 +1399,7 @@ function findTemplateByName(templates, templateName) {
 function getDefaultProjectName(template) {
   return template.slug.replace(/^template-/, "");
 }
-var s = p.spinner();
+var s = p5.spinner();
 var init = async ({
   directory = "src/",
   components,
@@ -1240,7 +1407,8 @@ var init = async ({
   llmApiKey,
   addExample = false,
   configureEditorWithDocsMCP,
-  versionTag
+  versionTag,
+  initGit = false
 }) => {
   s.start("Initializing Mastra");
   const packageVersionTag = versionTag ? `@${versionTag}` : "";
@@ -1294,19 +1462,30 @@ var init = async ({
     if (configureEditorWithDocsMCP) {
       await installMastraDocsMCPServer({
         editor: configureEditorWithDocsMCP,
-        directory: process.cwd()
+        directory: process.cwd(),
+        versionTag
       });
     }
     s.stop();
+    if (initGit) {
+      const s2 = p5.spinner();
+      try {
+        s2.start("Initializing git repository");
+        await gitInit({ cwd: process.cwd() });
+        s2.stop("Git repository initialized");
+      } catch {
+        s2.stop();
+      }
+    }
     if (!llmApiKey) {
-      p.note(`
+      p5.note(`
       ${color2.green("Mastra initialized successfully!")}
 
       Add your ${color2.cyan(key)} as an environment variable
       in your ${color2.cyan(".env")} file
       `);
     } else {
-      p.note(`
+      p5.note(`
       ${color2.green("Mastra initialized successfully!")}
       `);
     }
@@ -1343,6 +1522,32 @@ var execWithTimeout = async (command, timeoutMs) => {
     throw error;
   }
 };
+async function getInitCommand(pm) {
+  switch (pm) {
+    case "npm":
+      return "npm init -y";
+    case "pnpm":
+      return "pnpm init";
+    case "yarn":
+      return "yarn init -y";
+    case "bun":
+      return "bun init -y";
+    default:
+      return "npm init -y";
+  }
+}
+async function initializePackageJson(pm) {
+  const initCommand = await getInitCommand(pm);
+  await exec3(initCommand);
+  const packageJsonPath = path3.join(process.cwd(), "package.json");
+  const packageJson = JSON.parse(await fs4.readFile(packageJsonPath, "utf-8"));
+  packageJson.type = "module";
+  packageJson.engines = {
+    ...packageJson.engines,
+    node: ">=22.13.0"
+  };
+  await fs4.writeFile(packageJsonPath, JSON.stringify(packageJson, null, 2));
+}
 async function installMastraDependency(pm, dependency, versionTag, isDev, timeout) {
   let installCommand = getPackageManagerAddCommand(pm);
   if (isDev) {
@@ -1373,8 +1578,8 @@ var createMastraProject = async ({
   llmApiKey,
   needsInteractive
 }) => {
-  p.intro(color2.inverse(" Mastra Create "));
-  const projectName = name ?? await p.text({
+  p5.intro(color2.inverse(" Mastra Create "));
+  const projectName = name ?? await p5.text({
     message: "What do you want to name your project?",
     placeholder: "my-mastra-app",
     defaultValue: "my-mastra-app",
@@ -1385,22 +1590,25 @@ var createMastraProject = async ({
       }
     }
   });
-  if (p.isCancel(projectName)) {
-    p.cancel("Operation cancelled");
+  if (p5.isCancel(projectName)) {
+    p5.cancel("Operation cancelled");
     process.exit(0);
   }
-  let result;
+  let result = void 0;
   if (needsInteractive) {
     result = await interactivePrompt({
       options: { showBanner: false },
       skip: { llmProvider: llmProvider !== void 0, llmApiKey: llmApiKey !== void 0 }
     });
   }
-  const s2 = p.spinner();
+  const s2 = p5.spinner();
+  const originalCwd = process.cwd();
+  let projectPath = null;
   try {
     s2.start("Creating project");
     try {
       await fs4.mkdir(projectName);
+      projectPath = path3.resolve(originalCwd, 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.`);
@@ -1415,9 +1623,7 @@ var createMastraProject = async ({
     const installCommand = getPackageManagerAddCommand(pm);
     s2.message("Initializing project structure");
     try {
-      await exec3(`npm init -y`);
-      await exec3(`npm pkg set type="module"`);
-      await exec3(`npm pkg set engines.node=">=20.9.0"`);
+      await initializePackageJson(pm);
       const depsService = new DepsService();
       await depsService.addScriptsToPackageJson({
         dev: "mastra dev",
@@ -1489,33 +1695,50 @@ var createMastraProject = async ({
       throw new Error(`Failed to create .gitignore: ${error instanceof Error ? error.message : "Unknown error"}`);
     }
     s2.stop(".gitignore added");
-    p.outro("Project created successfully");
+    p5.outro("Project created successfully");
     console.info("");
     return { projectName, result };
   } catch (error) {
     s2.stop();
     const errorMessage = error instanceof Error ? error.message : "An unexpected error occurred";
-    p.cancel(`Project creation failed: ${errorMessage}`);
+    p5.cancel(`Project creation failed: ${errorMessage}`);
+    if (projectPath && fs3__default.existsSync(projectPath)) {
+      try {
+        process.chdir(originalCwd);
+        await fs4.rm(projectPath, { recursive: true, force: true });
+      } catch (cleanupError) {
+        console.error(
+          `Warning: Failed to clean up project directory: ${cleanupError instanceof Error ? cleanupError.message : "Unknown error"}`
+        );
+      }
+    }
     process.exit(1);
   }
 };
 
 // src/commands/create/create.ts
-var create = async (args2) => {
-  if (args2.template !== void 0) {
-    await createFromTemplate({ ...args2, injectedAnalytics: args2.analytics });
+var version = package_default.version;
+var create = async (args) => {
+  if (args.template !== void 0) {
+    await createFromTemplate({
+      projectName: args.projectName,
+      template: args.template,
+      timeout: args.timeout,
+      injectedAnalytics: args.analytics,
+      llmProvider: args.llmProvider
+    });
     return;
   }
-  const needsInteractive = args2.components === void 0 || args2.llmProvider === void 0 || args2.addExample === void 0;
+  const needsInteractive = args.components === void 0 || args.llmProvider === void 0 || args.addExample === void 0;
   const { projectName, result } = await createMastraProject({
-    projectName: args2?.projectName,
-    createVersionTag: args2?.createVersionTag,
-    timeout: args2?.timeout,
-    llmProvider: args2?.llmProvider,
-    llmApiKey: args2?.llmApiKey,
+    projectName: args?.projectName,
+    createVersionTag: args?.createVersionTag,
+    timeout: args?.timeout,
+    llmProvider: args?.llmProvider,
+    llmApiKey: args?.llmApiKey,
     needsInteractive
   });
-  const directory = args2.directory || "src/";
+  const directory = args.directory || "src/";
   if (needsInteractive && result) {
     const analytics2 = getAnalytics();
     if (analytics2 && result?.llmProvider) {
@@ -1529,12 +1752,12 @@ var create = async (args2) => {
       llmApiKey: result?.llmApiKey,
       components: ["agents", "tools", "workflows", "scorers"],
       addExample: true,
-      versionTag: args2.createVersionTag
+      versionTag: args.createVersionTag
     });
     postCreate({ projectName });
     return;
   }
-  const { components = [], llmProvider = "openai", addExample = false, llmApiKey } = args2;
+  const { components = [], llmProvider = "openai", addExample = false, llmApiKey } = args;
   const analytics = getAnalytics();
   if (analytics) {
     analytics.trackEvent("cli_model_provider_selected", {
@@ -1548,14 +1771,14 @@ var create = async (args2) => {
     llmProvider,
     addExample,
     llmApiKey,
-    configureEditorWithDocsMCP: args2.mcpServer,
-    versionTag: args2.createVersionTag
+    configureEditorWithDocsMCP: args.mcpServer,
+    versionTag: args.createVersionTag
   });
   postCreate({ projectName });
 };
 var postCreate = ({ projectName }) => {
   const packageManager = getPackageManager();
-  p.outro(`
+  p5.outro(`
    ${color2.green("To start your project:")}
 
     ${color2.cyan("cd")} ${projectName}
@@ -1640,36 +1863,36 @@ async function createFromGitHubUrl(url) {
     workflows: []
   };
 }
-async function createFromTemplate(args2) {
+async function createFromTemplate(args) {
   let selectedTemplate;
-  if (args2.template === true) {
+  if (args.template === true) {
     const templates = await loadTemplates();
     const selected = await selectTemplate(templates);
     if (!selected) {
-      p.log.info("No template selected. Exiting.");
+      p5.log.info("No template selected. Exiting.");
       return;
     }
     selectedTemplate = selected;
-  } else if (args2.template && typeof args2.template === "string") {
-    if (isGitHubUrl(args2.template)) {
-      const spinner4 = p.spinner();
+  } else if (args.template && typeof args.template === "string") {
+    if (isGitHubUrl(args.template)) {
+      const spinner4 = p5.spinner();
       spinner4.start("Validating GitHub repository...");
-      const validation = await validateGitHubProject(args2.template);
+      const validation = await validateGitHubProject(args.template);
       if (!validation.isValid) {
         spinner4.stop("Validation failed");
-        p.log.error("This does not appear to be a valid Mastra project:");
-        validation.errors.forEach((error) => p.log.error(`  - ${error}`));
+        p5.log.error("This does not appear to be a valid Mastra project:");
+        validation.errors.forEach((error) => p5.log.error(`  - ${error}`));
         throw new Error("Invalid Mastra project");
       }
       spinner4.stop("Valid Mastra project \u2713");
-      selectedTemplate = await createFromGitHubUrl(args2.template);
+      selectedTemplate = await createFromGitHubUrl(args.template);
     } else {
       const templates = await loadTemplates();
-      const found = findTemplateByName(templates, args2.template);
+      const found = findTemplateByName(templates, args.template);
       if (!found) {
-        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`);
+        p5.log.error(`Template "${args.template}" not found. Available templates:`);
+        templates.forEach((t) => p5.log.info(`  - ${t.title} (use: ${t.slug.replace("template-", "")})`));
+        throw new Error(`Template "${args.template}" not found`);
       }
       selectedTemplate = found;
     }
@@ -1677,34 +1900,76 @@ async function createFromTemplate(args2) {
   if (!selectedTemplate) {
     throw new Error("No template selected");
   }
-  let projectName = args2.projectName;
+  let projectName = args.projectName;
   if (!projectName) {
     const defaultName = getDefaultProjectName(selectedTemplate);
-    const response = await p.text({
+    const response = await p5.text({
       message: "What is your project name?",
       defaultValue: defaultName,
       placeholder: defaultName
     });
-    if (p.isCancel(response)) {
-      p.log.info("Project creation cancelled.");
+    if (p5.isCancel(response)) {
+      p5.log.info("Project creation cancelled.");
       return;
     }
     projectName = response;
   }
+  let llmProvider = args.llmProvider;
+  if (!llmProvider) {
+    const providerResponse = await p5.select({
+      message: "Select a default provider:",
+      options: LLM_PROVIDERS
+    });
+    if (p5.isCancel(providerResponse)) {
+      p5.log.info("Project creation cancelled.");
+      return;
+    }
+    llmProvider = providerResponse;
+  }
+  let initGit = false;
+  const gitConfirmResult = await p5.confirm({
+    message: "Initialize a new git repository?",
+    initialValue: true
+  });
+  if (!p5.isCancel(gitConfirmResult)) {
+    initGit = gitConfirmResult;
+  }
+  let projectPath = null;
   try {
-    const analytics = args2.injectedAnalytics || getAnalytics();
+    const analytics = args.injectedAnalytics || getAnalytics();
     if (analytics) {
       analytics.trackEvent("cli_template_used", {
         template_slug: selectedTemplate.slug,
         template_title: selectedTemplate.title
       });
+      if (llmProvider) {
+        analytics.trackEvent("cli_model_provider_selected", {
+          provider: llmProvider,
+          selection_method: args.llmProvider ? "cli_args" : "interactive"
+        });
+      }
     }
-    const projectPath = await cloneTemplate({
+    const isBeta = version?.includes("beta") ?? false;
+    const isMastraTemplate = selectedTemplate.githubUrl.includes("github.com/mastra-ai/");
+    const branch = isBeta && isMastraTemplate ? "beta" : void 0;
+    projectPath = await cloneTemplate({
       template: selectedTemplate,
-      projectName
+      projectName,
+      branch,
+      llmProvider
     });
     await installDependencies(projectPath);
-    p.note(`
+    if (initGit) {
+      const s2 = p5.spinner();
+      try {
+        s2.start("Initializing git repository");
+        await gitInit({ cwd: projectPath });
+        s2.stop("Git repository initialized");
+      } catch {
+        s2.stop();
+      }
+    }
+    p5.note(`
       ${color2.green("Mastra template installed!")}
 
       Add the necessary environment
@@ -1712,11 +1977,22 @@ async function createFromTemplate(args2) {
       `);
     postCreate({ projectName });
   } catch (error) {
-    p.log.error(`Failed to create project from template: ${error instanceof Error ? error.message : "Unknown error"}`);
+    if (projectPath) {
+      try {
+        if (fs3__default.existsSync(projectPath)) {
+          await fs4.rm(projectPath, { recursive: true, force: true });
+        }
+      } catch (cleanupError) {
+        console.error(
+          `Warning: Failed to clean up project directory: ${cleanupError instanceof Error ? cleanupError.message : "Unknown error"}`
+        );
+      }
+    }
+    p5.log.error(`Failed to create project from template: ${error instanceof Error ? error.message : "Unknown error"}`);
     throw error;
   }
 }
 
-export { COMPONENTS, DepsService, FileService, LLMProvider, checkAndInstallCoreDeps, checkForPkgJson, create, createLogger, init, interactivePrompt, logger, parseComponents, parseLlmProvider, parseMcp };
-//# sourceMappingURL=chunk-NHL3S2MZ.js.map
-//# sourceMappingURL=chunk-NHL3S2MZ.js.map
+export { COMPONENTS, DepsService, FileService, LLMProvider, checkAndInstallCoreDeps, checkForPkgJson, create, createLogger, getVersionTag, init, interactivePrompt, logger, package_default, parseComponents, parseLlmProvider, parseMcp, shouldSkipDotenvLoading };
+//# sourceMappingURL=chunk-THUIZ4X5.js.map
+//# sourceMappingURL=chunk-THUIZ4X5.js.map