create-mastra 0.0.0-sidebar-window-undefined-fix-20251029233656 → 0.0.0-span-scorring-test-20251124132129

package/dist/index.js

@@ -4,15 +4,15 @@ import { randomUUID } from 'node:crypto';
 import * as fs3__default from 'node:fs';
 import fs3__default__default, { existsSync, readFileSync, writeFileSync } from 'node:fs';
 import os from 'node:os';
-import path, { dirname } from 'node:path';
+import path3, { dirname } from 'node:path';
 import { fileURLToPath } from 'node:url';
 import { PostHog } from 'posthog-node';
+import fs4 from 'node:fs/promises';
 import util, { stripVTControlCharacters } from 'node:util';
 import y$1, { stdout, stdin } from 'node:process';
 import * as g from 'node:readline';
 import g__default from 'node:readline';
 import { Writable } from 'node:stream';
-import fs4 from 'node:fs/promises';
 import child_process from 'node:child_process';
 import tty from 'node:tty';
 import fsExtra, { readJSON, ensureFile, writeJSON } from 'fs-extra/esm';
@@ -23,7 +23,7 @@ import pretty from 'pino-pretty';
 import fsExtra$1 from 'fs-extra';
 
 var __filename = fileURLToPath(import.meta.url);
-var __dirname = path.dirname(__filename);
+var __dirname = path3.dirname(__filename);
 var analyticsInstance = null;
 function getAnalytics() {
   return analyticsInstance;
@@ -39,7 +39,7 @@ var PosthogAnalytics = class {
     host = "https://app.posthog.com"
   }) {
     this.version = version;
-    const cliConfigPath = path.join(__dirname, "mastra-cli.json");
+    const cliConfigPath = path3.join(__dirname, "mastra-cli.json");
     if (existsSync(cliConfigPath)) {
       try {
         const { distinctId, sessionId } = JSON.parse(readFileSync(cliConfigPath, "utf-8"));
@@ -67,7 +67,7 @@ var PosthogAnalytics = class {
   }
   writeCliConfig({ distinctId, sessionId }) {
     try {
-      writeFileSync(path.join(__dirname, "mastra-cli.json"), JSON.stringify({ distinctId, sessionId }));
+      writeFileSync(path3.join(__dirname, "mastra-cli.json"), JSON.stringify({ distinctId, sessionId }));
     } catch {
     }
   }
@@ -887,6 +887,7 @@ class YoctoSpinner {
 	#exitHandlerBound;
 	#isInteractive;
 	#lastSpinnerFrameTime = 0;
+	#isSpinning = false;
 
 	constructor(options = {}) {
 		const spinner = options.spinner ?? defaultSpinner;
@@ -908,13 +909,17 @@ class YoctoSpinner {
 			return this;
 		}
 
+		this.#isSpinning = true;
 		this.#hideCursor();
 		this.#render();
 		this.#subscribeToProcessEvents();
 
-		this.#timer = setInterval(() => {
-			this.#render();
-		}, this.#interval);
+		// Only start the timer in interactive mode
+		if (this.#isInteractive) {
+			this.#timer = setInterval(() => {
+				this.#render();
+			}, this.#interval);
+		}
 
 		return this;
 	}
@@ -924,8 +929,12 @@ class YoctoSpinner {
 			return this;
 		}
 
-		clearInterval(this.#timer);
-		this.#timer = undefined;
+		this.#isSpinning = false;
+		if (this.#timer) {
+			clearInterval(this.#timer);
+			this.#timer = undefined;
+		}
+
 		this.#showCursor();
 		this.clear();
 		this.#unsubscribeFromProcessEvents();
@@ -958,7 +967,7 @@ class YoctoSpinner {
 	}
 
 	get isSpinning() {
-		return this.#timer !== undefined;
+		return this.#isSpinning;
 	}
 
 	get text() {
@@ -1095,11 +1104,11 @@ var MastraLogger = class {
   }
   trackException(_error) {
   }
-  async getLogs(transportId, params) {
+  async listLogs(transportId, params) {
     if (!transportId || !this.transports.has(transportId)) {
       return { logs: [], total: 0, page: params?.page ?? 1, perPage: params?.perPage ?? 100, hasMore: false };
     }
-    return this.transports.get(transportId).getLogs(params) ?? {
+    return this.transports.get(transportId).listLogs(params) ?? {
       logs: [],
       total: 0,
       page: params?.page ?? 1,
@@ -1107,7 +1116,7 @@ var MastraLogger = class {
       hasMore: false
     };
   }
-  async getLogsByRunId({
+  async listLogsByRunId({
     transportId,
     runId,
     fromDate,
@@ -1120,7 +1129,7 @@ var MastraLogger = class {
     if (!transportId || !this.transports.has(transportId) || !runId) {
       return { logs: [], total: 0, page: page ?? 1, perPage: perPage ?? 100, hasMore: false };
     }
-    return this.transports.get(transportId).getLogsByRunId({ runId, fromDate, toDate, logLevel, filters, page, perPage }) ?? {
+    return this.transports.get(transportId).listLogsByRunId({ runId, fromDate, toDate, logLevel, filters, page, perPage }) ?? {
       logs: [],
       total: 0,
       page: page ?? 1,
@@ -1178,118 +1187,8 @@ var PinoLogger = class extends MastraLogger {
   }
 };
 
-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 = 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")
-);
-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;
-  }
-}
+var package_default = {
+  version: "1.0.0-beta.3"};
 function getPackageManagerAddCommand(pm) {
   switch (pm) {
     case "npm":
@@ -1312,11 +1211,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__default.existsSync(path.join(dir, file))) {
+      if (fs3__default__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);
     }
@@ -1349,7 +1248,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 {
@@ -1369,7 +1268,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;
@@ -1457,8 +1356,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__default.readFileSync(filePath, "utf8");
     if (fs3__default__default.existsSync(outputFilePath) && !replaceIfExists) {
       console.info(`${outputFilePath} already exists`);
@@ -1468,7 +1367,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);
@@ -1492,21 +1391,142 @@ var FileService = class {
     fs3__default__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")
+);
+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;
+  }
+}
 var exec = util.promisify(child_process.exec);
 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);
@@ -1532,9 +1552,10 @@ ${addExampleTool ? `import { weatherTool } from '../tools/weather-tool';` : ""}
 ${addScorers ? `import { scorers } from '../scorers/weather-scorer';` : ""}
 
 export const weatherAgent = new Agent({
+  id: 'weather-agent',
   name: 'Weather Agent',
   instructions: \`${instructions}\`,
-  model: ${modelString},
+  model: '${modelString}',
   ${addExampleTool ? "tools: { weatherTool }," : ""}
   ${addScorers ? `scorers: {
     toolCallAppropriateness: {
@@ -1561,6 +1582,7 @@ export const weatherAgent = new Agent({
   },` : ""}
   memory: new Memory({
     storage: new LibSQLStore({
+      id: "memory-storage",
       url: "file:../mastra.db", // path is relative to the .mastra/output directory
     })
   })
@@ -1773,9 +1795,10 @@ async function writeToolSample(destPath) {
 async function writeScorersSample(llmProvider, destPath) {
   const modelString = getModelIdentifier(llmProvider);
   const content = `import { z } from 'zod';
-import { createToolCallAccuracyScorerCode } from '@mastra/evals/scorers/code';
-import { createCompletenessScorer } from '@mastra/evals/scorers/code';
-import { createScorer } from '@mastra/core/scores';
+import { createToolCallAccuracyScorerCode } from '@mastra/evals/scorers/prebuilt';
+import { createCompletenessScorer } from '@mastra/evals/scorers/prebuilt';
+import { getAssistantMessageFromRunOutput, getUserMessageFromRunInput } from '@mastra/evals/scorers/utils';
+import { createScorer } from '@mastra/core/evals';
 
 export const toolCallAppropriatenessScorer = createToolCallAccuracyScorerCode({
   expectedTool: 'weatherTool',
@@ -1786,11 +1809,12 @@ export const completenessScorer = createCompletenessScorer();
 
 // Custom LLM-judged scorer: evaluates if non-English locations are translated appropriately
 export const translationScorer = createScorer({
+  id: 'translation-quality-scorer',
   name: 'Translation Quality',
   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. ' +
@@ -1799,8 +1823,8 @@ export const translationScorer = createScorer({
   },
 })
   .preprocess(({ run }) => {
-    const userText = (run.input?.inputMessages?.[0]?.content as string) || '';
-    const assistantText = (run.output?.[0]?.content as string) || '';
+    const userText = getUserMessageFromRunInput(run.input) || '';
+    const assistantText = getAssistantMessageFromRunOutput(run.output) || '';
     return { userText, assistantText };
   })
   .analyze({
@@ -1887,7 +1911,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 = [
@@ -1899,7 +1923,7 @@ var writeIndexFile = async ({
       await fs4.writeFile(
         destPath,
         `
-import { Mastra } from '@mastra/core';
+import { Mastra } from '@mastra/core/mastra';
 
 export const mastra = new Mastra()
         `
@@ -1912,6 +1936,7 @@ export const mastra = new Mastra()
 import { Mastra } from '@mastra/core/mastra';
 import { PinoLogger } from '@mastra/loggers';
 import { LibSQLStore } from '@mastra/libsql';
+import { Observability } from '@mastra/observability';
 ${addWorkflow ? `import { weatherWorkflow } from './workflows/weather-workflow';` : ""}
 ${addAgent ? `import { weatherAgent } from './agents/weather-agent';` : ""}
 ${addScorers ? `import { toolCallAppropriatenessScorer, completenessScorer, translationScorer } from './scorers/weather-scorer';` : ""}
@@ -1919,6 +1944,7 @@ ${addScorers ? `import { toolCallAppropriatenessScorer, completenessScorer, tran
 export const mastra = new Mastra({
   ${filteredExports.join("\n  ")}
   storage: new LibSQLStore({
+    id: "mastra-storage",
     // stores observability, scores, ... into memory storage, if it needs to persist, change to file:../mastra.db
     url: ":memory:",
   }),
@@ -1926,10 +1952,10 @@ export const mastra = new Mastra({
     name: 'Mastra',
     level: 'info',
   }),
-  observability: {
-    // Enables DefaultExporter and CloudExporter for AI tracing
+  observability: new Observability({
+    // Enables DefaultExporter and CloudExporter for tracing
     default: { enabled: true },
-  },
+    }),
 });
 `
     );
@@ -1968,7 +1994,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 };
@@ -1993,8 +2019,8 @@ 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) {
     Ie(color2.inverse(" Mastra Init "));
   }
@@ -2032,46 +2058,29 @@ 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 ve({
           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) {
-          M.message(`
-Windsurf is already installed, skipping.`);
-          return void 0;
-        }
-        if (editor === `vscode` && vscodeIsAlreadyInstalled) {
-          M.message(`
-VSCode is already installed, skipping.`);
-          return void 0;
-        }
         if (editor === `cursor`) {
           M.message(
             `
@@ -2119,6 +2128,9 @@ This means the Mastra docs MCP server will be available in all your Windsurf pro
 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";
   }
@@ -2128,6 +2140,9 @@ function getPackageManager() {
   if (userAgent.includes("npm")) {
     return "npm";
   }
+  if (execPath.includes("bun")) {
+    return "bun";
+  }
   if (execPath.includes("yarn")) {
     return "yarn";
   }
@@ -2148,19 +2163,23 @@ function createLogger(debug = false) {
 }
 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 = yoctoSpinner({ 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;
@@ -2185,21 +2204,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 });
       }
@@ -2209,7 +2234,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);
@@ -2219,6 +2244,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 = yoctoSpinner({ text: "Installing dependencies..." }).start();
   try {
@@ -2303,9 +2344,11 @@ var init = async ({
   llmProvider = "openai",
   llmApiKey,
   addExample = false,
-  configureEditorWithDocsMCP
+  configureEditorWithDocsMCP,
+  versionTag
 }) => {
   s.start("Initializing Mastra");
+  const packageVersionTag = versionTag ? `@${versionTag}` : "";
   try {
     const result = await createMastraDir(directory);
     if (!result.ok) {
@@ -2333,30 +2376,31 @@ var init = async ({
       const depService = new DepsService();
       const needsLibsql = await depService.checkDependencies(["@mastra/libsql"]) !== `ok`;
       if (needsLibsql) {
-        await depService.installPackages(["@mastra/libsql"]);
+        await depService.installPackages([`@mastra/libsql${packageVersionTag}`]);
       }
       const needsMemory = components.includes(`agents`) && await depService.checkDependencies(["@mastra/memory"]) !== `ok`;
       if (needsMemory) {
-        await depService.installPackages(["@mastra/memory"]);
+        await depService.installPackages([`@mastra/memory${packageVersionTag}`]);
       }
       const needsLoggers = await depService.checkDependencies(["@mastra/loggers"]) !== `ok`;
       if (needsLoggers) {
-        await depService.installPackages(["@mastra/loggers"]);
+        await depService.installPackages([`@mastra/loggers${packageVersionTag}`]);
       }
       const needsObservability = await depService.checkDependencies(["@mastra/observability"]) !== `ok`;
       if (needsObservability) {
-        await depService.installPackages(["@mastra/observability"]);
+        await depService.installPackages([`@mastra/observability${packageVersionTag}`]);
       }
       const needsEvals = components.includes(`scorers`) && await depService.checkDependencies(["@mastra/evals"]) !== `ok`;
       if (needsEvals) {
-        await depService.installPackages(["@mastra/evals"]);
+        await depService.installPackages([`@mastra/evals${packageVersionTag}`]);
       }
     }
     const key = await getAPIKey(llmProvider || "openai");
     if (configureEditorWithDocsMCP) {
       await installMastraDocsMCPServer({
         editor: configureEditorWithDocsMCP,
-        directory: process.cwd()
+        directory: process.cwd(),
+        versionTag
       });
     }
     s.stop();
@@ -2405,6 +2449,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) {
@@ -2459,10 +2529,13 @@ var createMastraProject = async ({
     });
   }
   const s2 = Y();
+  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.`);
@@ -2477,9 +2550,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",
@@ -2495,7 +2566,7 @@ var createMastraProject = async ({
     s2.start(`Installing ${pm} dependencies`);
     try {
       await exec3(`${pm} ${installCommand} zod@^4`);
-      await exec3(`${pm} ${installCommand} typescript @types/node --save-dev`);
+      await exec3(`${pm} ${installCommand} -D typescript @types/node`);
       await exec3(`echo '{
   "compilerOptions": {
     "target": "ES2022",
@@ -2558,42 +2629,61 @@ var createMastraProject = async ({
     s2.stop();
     const errorMessage = error instanceof Error ? error.message : "An unexpected error occurred";
     xe(`Project creation failed: ${errorMessage}`);
+    if (projectPath && fs3__default__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);
   }
 };
-var create = async (args2) => {
-  if (args2.template !== void 0) {
-    await createFromTemplate({ ...args2, injectedAnalytics: args2.analytics });
+var version$1 = 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) {
     await init({
       ...result,
       llmApiKey: result?.llmApiKey,
       components: ["agents", "tools", "workflows", "scorers"],
-      addExample: true
+      addExample: true,
+      versionTag: args.createVersionTag
     });
     postCreate({ projectName });
     return;
   }
-  const { components = [], llmProvider = "openai", addExample = false, llmApiKey } = args2;
+  const { components = [], llmProvider = "openai", addExample = false, llmApiKey } = args;
   await init({
     directory,
     components,
     llmProvider,
     addExample,
     llmApiKey,
-    configureEditorWithDocsMCP: args2.mcpServer
+    configureEditorWithDocsMCP: args.mcpServer,
+    versionTag: args.createVersionTag
   });
   postCreate({ projectName });
 };
@@ -2684,9 +2774,9 @@ 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) {
@@ -2694,11 +2784,11 @@ async function createFromTemplate(args2) {
       return;
     }
     selectedTemplate = selected;
-  } else if (args2.template && typeof args2.template === "string") {
-    if (isGitHubUrl(args2.template)) {
+  } else if (args.template && typeof args.template === "string") {
+    if (isGitHubUrl(args.template)) {
       const spinner4 = Y();
       spinner4.start("Validating GitHub repository...");
-      const validation = await validateGitHubProject(args2.template);
+      const validation = await validateGitHubProject(args.template);
       if (!validation.isValid) {
         spinner4.stop("Validation failed");
         M.error("This does not appear to be a valid Mastra project:");
@@ -2706,14 +2796,14 @@ async function createFromTemplate(args2) {
         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) {
-        M.error(`Template "${args2.template}" not found. Available templates:`);
+        M.error(`Template "${args.template}" not found. Available templates:`);
         templates.forEach((t) => M.info(`  - ${t.title} (use: ${t.slug.replace("template-", "")})`));
-        throw new Error(`Template "${args2.template}" not found`);
+        throw new Error(`Template "${args.template}" not found`);
       }
       selectedTemplate = found;
     }
@@ -2721,7 +2811,7 @@ 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 he({
@@ -2735,17 +2825,41 @@ async function createFromTemplate(args2) {
     }
     projectName = response;
   }
+  let llmProvider = args.llmProvider;
+  if (!llmProvider) {
+    const providerResponse = await ve({
+      message: "Select a default provider:",
+      options: LLM_PROVIDERS
+    });
+    if (pD(providerResponse)) {
+      M.info("Project creation cancelled.");
+      return;
+    }
+    llmProvider = providerResponse;
+  }
+  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$1?.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);
     Me(`
@@ -2756,6 +2870,17 @@ async function createFromTemplate(args2) {
       `);
     postCreate({ projectName });
   } catch (error) {
+    if (projectPath) {
+      try {
+        if (fs3__default__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"}`
+        );
+      }
+    }
     M.error(`Failed to create project from template: ${error instanceof Error ? error.message : "Unknown error"}`);
     throw error;
   }
@@ -2764,7 +2889,7 @@ async function createFromTemplate(args2) {
 async function getPackageVersion() {
   const __filename = fileURLToPath(import.meta.url);
   const __dirname = dirname(__filename);
-  const pkgJsonPath = path.join(__dirname, "..", "package.json");
+  const pkgJsonPath = path3.join(__dirname, "..", "package.json");
   const content = await fsExtra$1.readJSON(pkgJsonPath);
   return content.version;
 }