create-mastra 0.0.0-taofeeq-fix-tool-call-showing-after-message-20250806184630 → 0.0.0-testing-cloud-studios-20260114234039

package/dist/index.js

@@ -1,26 +1,26 @@
 #! /usr/bin/env node
 import { Command } from 'commander';
 import { randomUUID } from 'node:crypto';
-import * as fs4__default from 'node:fs';
-import fs4__default__default, { existsSync, readFileSync, writeFileSync } from 'node:fs';
+import * as fs3__default from 'node:fs';
+import fs3__default__default, { existsSync, readFileSync, writeFileSync } from 'node:fs';
 import os from 'node:os';
 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 fs 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';
+import prettier from 'prettier';
+import { execa } from 'execa';
+import fsExtra$1 from 'fs-extra';
 import pino from 'pino';
 import pretty from 'pino-pretty';
-import { execa } from 'execa';
-import fsExtra3, { readJSON, ensureFile, writeJSON } from 'fs-extra/esm';
-import prettier from 'prettier';
-import fsExtra from 'fs-extra';
 
 var __filename = fileURLToPath(import.meta.url);
 var __dirname = path3.dirname(__filename);
@@ -105,6 +105,10 @@ var PosthogAnalytics = class {
       machine_id: os.hostname()
     };
   }
+  getDurationMs(startTime) {
+    const [seconds, nanoseconds] = process.hrtime(startTime);
+    return seconds * 1e3 + nanoseconds / 1e6;
+  }
   captureSessionStart() {
     if (!this.client) {
       return;
@@ -173,8 +177,7 @@ var PosthogAnalytics = class {
     const startTime = process.hrtime();
     try {
       const result = await execution();
-      const [seconds, nanoseconds] = process.hrtime(startTime);
-      const durationMs = seconds * 1e3 + nanoseconds / 1e6;
+      const durationMs = this.getDurationMs(startTime);
       this.trackCommand({
         command,
         args,
@@ -184,8 +187,7 @@ var PosthogAnalytics = class {
       });
       return result;
     } catch (error) {
-      const [seconds, nanoseconds] = process.hrtime(startTime);
-      const durationMs = seconds * 1e3 + nanoseconds / 1e6;
+      const durationMs = this.getDurationMs(startTime);
       this.trackCommand({
         command,
         args,
@@ -382,7 +384,7 @@ function DD({onlyFirst:e=false}={}){const t=["[\\u001B\\u009B][[\\]()#;?]*(?:(?:
 `).length-1;this.output.write(srcExports.cursor.move(-999,u*-1));}render(){const u=Y$1(this._render(this)??"",process.stdout.columns,{hard:true});if(u!==this._prevFrame){if(this.state==="initial")this.output.write(srcExports.cursor.hide);else {const t=BD(this._prevFrame,u);if(this.restoreCursor(),t&&t?.length===1){const F=t[0];this.output.write(srcExports.cursor.move(0,F)),this.output.write(srcExports.erase.lines(1));const s=u.split(`
 `);this.output.write(s[F]),this._prevFrame=u,this.output.write(srcExports.cursor.move(0,s.length-F-1));return}if(t&&t?.length>1){const F=t[0];this.output.write(srcExports.cursor.move(0,F)),this.output.write(srcExports.erase.down());const s=u.split(`
 `).slice(F);this.output.write(s.join(`
-`)),this._prevFrame=u;return}this.output.write(srcExports.erase.down());}this.output.write(u),this.state==="initial"&&(this.state="active"),this._prevFrame=u;}}}var OD=Object.defineProperty,PD=(e,u,t)=>u in e?OD(e,u,{enumerable:true,configurable:true,writable:true,value:t}):e[u]=t,J=(e,u,t)=>(PD(e,typeof u!="symbol"?u+"":u,t),t);class LD extends x{constructor(u){super(u,false),J(this,"options"),J(this,"cursor",0),this.options=u.options,this.cursor=this.options.findIndex(({value:t})=>t===u.initialValue),this.cursor===-1&&(this.cursor=0),this.changeValue(),this.on("cursor",t=>{switch(t){case "left":case "up":this.cursor=this.cursor===0?this.options.length-1:this.cursor-1;break;case "down":case "right":this.cursor=this.cursor===this.options.length-1?0:this.cursor+1;break}this.changeValue();});}get _value(){return this.options[this.cursor]}changeValue(){this.value=this._value.value;}}class RD extends x{get valueWithCursor(){if(this.state==="submit")return this.value;if(this.cursor>=this.value.length)return `${this.value}\u2588`;const u=this.value.slice(0,this.cursor),[t,...F]=this.value.slice(this.cursor);return `${u}${color2.inverse(t)}${F.join("")}`}get cursor(){return this._cursor}constructor(u){super(u),this.on("finalize",()=>{this.value||(this.value=u.defaultValue);});}}
+`)),this._prevFrame=u;return}this.output.write(srcExports.erase.down());}this.output.write(u),this.state==="initial"&&(this.state="active"),this._prevFrame=u;}}}class dD extends x{get cursor(){return this.value?0:1}get _value(){return this.cursor===0}constructor(u){super(u,false),this.value=!!u.initialValue,this.on("value",()=>{this.value=this._value;}),this.on("confirm",t=>{this.output.write(srcExports.cursor.move(0,-1)),this.value=t,this.state="submit",this.close();}),this.on("cursor",()=>{this.value=!this.value;});}}var OD=Object.defineProperty,PD=(e,u,t)=>u in e?OD(e,u,{enumerable:true,configurable:true,writable:true,value:t}):e[u]=t,J=(e,u,t)=>(PD(e,typeof u!="symbol"?u+"":u,t),t);class LD extends x{constructor(u){super(u,false),J(this,"options"),J(this,"cursor",0),this.options=u.options,this.cursor=this.options.findIndex(({value:t})=>t===u.initialValue),this.cursor===-1&&(this.cursor=0),this.changeValue(),this.on("cursor",t=>{switch(t){case "left":case "up":this.cursor=this.cursor===0?this.options.length-1:this.cursor-1;break;case "down":case "right":this.cursor=this.cursor===this.options.length-1?0:this.cursor+1;break}this.changeValue();});}get _value(){return this.options[this.cursor]}changeValue(){this.value=this._value.value;}}class RD extends x{get valueWithCursor(){if(this.state==="submit")return this.value;if(this.cursor>=this.value.length)return `${this.value}\u2588`;const u=this.value.slice(0,this.cursor),[t,...F]=this.value.slice(this.cursor);return `${u}${color2.inverse(t)}${F.join("")}`}get cursor(){return this._cursor}constructor(u){super(u),this.on("finalize",()=>{this.value||(this.value=u.defaultValue);});}}
 
 function ce(){return y$1.platform!=="win32"?y$1.env.TERM!=="linux":!!y$1.env.CI||!!y$1.env.WT_SESSION||!!y$1.env.TERMINUS_SUBLIME||y$1.env.ConEmuTask==="{cmd::Cmder}"||y$1.env.TERM_PROGRAM==="Terminus-Sublime"||y$1.env.TERM_PROGRAM==="vscode"||y$1.env.TERM==="xterm-256color"||y$1.env.TERM==="alacritty"||y$1.env.TERMINAL_EMULATOR==="JetBrains-JediTerm"}const V=ce(),u=(t,n)=>V?t:n,le=u("\u25C6","*"),L=u("\u25A0","x"),W=u("\u25B2","x"),C=u("\u25C7","o"),ue=u("\u250C","T"),o=u("\u2502","|"),d=u("\u2514","\u2014"),k=u("\u25CF",">"),P=u("\u25CB"," "),_=u("\u2500","-"),me=u("\u256E","+"),de=u("\u251C","+"),pe=u("\u256F","+"),q=u("\u25CF","\u2022"),D=u("\u25C6","*"),U=u("\u25B2","!"),K=u("\u25A0","x"),b=t=>{switch(t){case "initial":case "active":return color2.cyan(le);case "cancel":return color2.red(L);case "error":return color2.yellow(W);case "submit":return color2.green(C)}},G=t=>{const{cursor:n,options:r,style:i}=t,s=t.maxItems??Number.POSITIVE_INFINITY,c=Math.max(process.stdout.rows-4,0),a=Math.min(c,Math.max(s,5));let l=0;n>=l+a-3?l=Math.max(Math.min(n-a+3,r.length-a),0):n<l+2&&(l=Math.max(n-2,0));const $=a<r.length&&l>0,g=a<r.length&&l+a<r.length;return r.slice(l,l+a).map((p,v,f)=>{const j=v===0&&$,E=v===f.length-1&&g;return j||E?color2.dim("..."):i(p,v+l===n)})},he=t=>new RD({validate:t.validate,placeholder:t.placeholder,defaultValue:t.defaultValue,initialValue:t.initialValue,render(){const n=`${color2.gray(o)}
 ${b(this.state)}  ${t.message}
@@ -392,7 +394,12 @@ ${color2.yellow(d)}  ${color2.yellow(this.error)}
 `;case "submit":return `${n}${color2.gray(o)}  ${color2.dim(this.value||t.placeholder)}`;case "cancel":return `${n}${color2.gray(o)}  ${color2.strikethrough(color2.dim(this.value??""))}${this.value?.trim()?`
 ${color2.gray(o)}`:""}`;default:return `${n}${color2.cyan(o)}  ${i}
 ${color2.cyan(d)}
-`}}}).prompt(),ve=t=>{const n=(r,i)=>{const s=r.label??String(r.value);switch(i){case "selected":return `${color2.dim(s)}`;case "active":return `${color2.green(k)} ${s} ${r.hint?color2.dim(`(${r.hint})`):""}`;case "cancelled":return `${color2.strikethrough(color2.dim(s))}`;default:return `${color2.dim(P)} ${color2.dim(s)}`}};return new LD({options:t.options,initialValue:t.initialValue,render(){const r=`${color2.gray(o)}
+`}}}).prompt(),ye=t=>{const n=t.active??"Yes",r=t.inactive??"No";return new dD({active:n,inactive:r,initialValue:t.initialValue??true,render(){const i=`${color2.gray(o)}
+${b(this.state)}  ${t.message}
+`,s=this.value?n:r;switch(this.state){case "submit":return `${i}${color2.gray(o)}  ${color2.dim(s)}`;case "cancel":return `${i}${color2.gray(o)}  ${color2.strikethrough(color2.dim(s))}
+${color2.gray(o)}`;default:return `${i}${color2.cyan(o)}  ${this.value?`${color2.green(k)} ${n}`:`${color2.dim(P)} ${color2.dim(n)}`} ${color2.dim("/")} ${this.value?`${color2.dim(P)} ${color2.dim(r)}`:`${color2.green(k)} ${r}`}
+${color2.cyan(d)}
+`}}}).prompt()},ve=t=>{const n=(r,i)=>{const s=r.label??String(r.value);switch(i){case "selected":return `${color2.dim(s)}`;case "active":return `${color2.green(k)} ${s} ${r.hint?color2.dim(`(${r.hint})`):""}`;case "cancelled":return `${color2.strikethrough(color2.dim(s))}`;default:return `${color2.dim(P)} ${color2.dim(s)}`}};return new LD({options:t.options,initialValue:t.initialValue,render(){const r=`${color2.gray(o)}
 ${b(this.state)}  ${t.message}
 `;switch(this.state){case "submit":return `${r}${color2.gray(o)}  ${n(this.options[this.cursor],"selected")}`;case "cancel":return `${r}${color2.gray(o)}  ${n(this.options[this.cursor],"cancelled")}
 ${color2.gray(o)}`;default:return `${r}${color2.cyan(o)}  ${G({cursor:this.cursor,options:this.options,maxItems:t.maxItems,style:(i,s)=>n(i,s?"active":"inactive")}).join(`
@@ -422,7 +429,7 @@ ${color2.gray(d)}  ${t}
 `):process.stdout.write(`${w}  ${l}
 `),E(),s();};return {start:H,stop:N,message:(m="")=>{l=R(m??l);}}},Ce=async(t,n)=>{const r={},i=Object.keys(t);for(const s of i){const c=t[s],a=await c({results:r})?.catch(l=>{throw l});if(typeof n?.onCancel=="function"&&pD(a)){r[s]="canceled",n.onCancel({results:r});continue}r[s]=a;}return r};
 
-var shellQuote$1 = {};
+var shellQuote = {};
 
 var quote;
 var hasRequiredQuote;
@@ -688,16 +695,16 @@ function requireParse () {
 var hasRequiredShellQuote;
 
 function requireShellQuote () {
-	if (hasRequiredShellQuote) return shellQuote$1;
+	if (hasRequiredShellQuote) return shellQuote;
 	hasRequiredShellQuote = 1;
 
-	shellQuote$1.quote = requireQuote();
-	shellQuote$1.parse = requireParse();
-	return shellQuote$1;
+	shellQuote.quote = requireQuote();
+	shellQuote.parse = requireParse();
+	return shellQuote;
 }
 
 var shellQuoteExports = requireShellQuote();
-var shellQuote = /*@__PURE__*/getDefaultExportFromCjs(shellQuoteExports);
+var shellQuote2 = /*@__PURE__*/getDefaultExportFromCjs(shellQuoteExports);
 
 // eslint-disable-next-line no-warning-comments
 // TODO: Use a better method when it's added to Node.js (https://github.com/nodejs/node/pull/40240)
@@ -724,13 +731,18 @@ const format = (open, close) => {
 		// Handle nested colors.
 
 		// We could have done this, but it's too slow (as of Node.js 22).
-		// return openCode + string.replaceAll(closeCode, openCode) + closeCode;
+		// return openCode + string.replaceAll(closeCode, (close === 22 ? closeCode : '') + openCode) + closeCode;
 
 		let result = openCode;
 		let lastIndex = 0;
 
+		// SGR 22 resets both bold (1) and dim (2). When we encounter a nested
+		// close for styles that use 22, we need to re-open the outer style.
+		const reopenOnNestedClose = close === 22;
+		const replaceCode = (reopenOnNestedClose ? closeCode : '') + openCode;
+
 		while (index !== -1) {
-			result += string.slice(lastIndex, index) + openCode;
+			result += string.slice(lastIndex, index) + replaceCode;
 			lastIndex = index + closeCode.length;
 			index = string.indexOf(closeCode, lastIndex);
 		}
@@ -882,6 +894,7 @@ class YoctoSpinner {
 	#exitHandlerBound;
 	#isInteractive;
 	#lastSpinnerFrameTime = 0;
+	#isSpinning = false;
 
 	constructor(options = {}) {
 		const spinner = options.spinner ?? defaultSpinner;
@@ -903,13 +916,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;
 	}
@@ -919,8 +936,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();
@@ -953,7 +974,7 @@ class YoctoSpinner {
 	}
 
 	get isSpinning() {
-		return this.#timer !== undefined;
+		return this.#isSpinning;
 	}
 
 	get text() {
@@ -1090,11 +1111,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,
@@ -1102,7 +1123,7 @@ var MastraLogger = class {
       hasMore: false
     };
   }
-  async getLogsByRunId({
+  async listLogsByRunId({
     transportId,
     runId,
     fromDate,
@@ -1115,7 +1136,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,
@@ -1125,10 +1146,15 @@ var MastraLogger = class {
   }
 };
 
-var PinoLogger = class extends MastraLogger {
+var PinoLogger = class _PinoLogger extends MastraLogger {
   logger;
   constructor(options = {}) {
     super(options);
+    const internalOptions = options;
+    if (internalOptions._logger) {
+      this.logger = internalOptions._logger;
+      return;
+    }
     let prettyStream = void 0;
     if (!options.overrideDefaultTransports) {
       prettyStream = pretty({
@@ -1145,7 +1171,8 @@ var PinoLogger = class extends MastraLogger {
       {
         name: options.name || "app",
         level: options.level || LogLevel.INFO,
-        formatters: options.formatters
+        formatters: options.formatters,
+        redact: options.redact
       },
       options.overrideDefaultTransports ? options?.transports?.default : transportsAry.length === 0 ? prettyStream : pino.multistream([
         ...transportsAry.map(([, transport]) => ({
@@ -1159,6 +1186,38 @@ var PinoLogger = class extends MastraLogger {
       ])
     );
   }
+  /**
+   * Creates a child logger with additional bound context.
+   * All logs from the child logger will include the bound context.
+   *
+   * @param bindings - Key-value pairs to include in all logs from this child logger
+   * @returns A new PinoLogger instance with the bound context
+   *
+   * @example
+   * ```typescript
+   * const baseLogger = new PinoLogger({ name: 'MyApp' });
+   *
+   * // Create module-scoped logger
+   * const serviceLogger = baseLogger.child({ module: 'UserService' });
+   * serviceLogger.info('User created', { userId: '123' });
+   * // Output includes: { module: 'UserService', userId: '123', msg: 'User created' }
+   *
+   * // Create request-scoped logger
+   * const requestLogger = baseLogger.child({ requestId: req.id });
+   * requestLogger.error('Request failed', { err: error });
+   * // Output includes: { requestId: 'abc', msg: 'Request failed', err: {...} }
+   * ```
+   */
+  child(bindings) {
+    const childPino = this.logger.child(bindings);
+    const childOptions = {
+      name: this.name,
+      level: this.level,
+      transports: Object.fromEntries(this.transports),
+      _logger: childPino
+    };
+    return new _PinoLogger(childOptions);
+  }
   debug(message, args = {}) {
     this.logger.debug(args, message);
   }
@@ -1173,194 +1232,21 @@ var PinoLogger = class extends MastraLogger {
   }
 };
 
-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 getPackageManagerInstallCommand(pm) {
+var package_default = {
+  version: "1.0.0-beta.13"};
+function getPackageManagerAddCommand(pm) {
   switch (pm) {
     case "npm":
-      return "install";
+      return "install --audit=false --fund=false --loglevel=error --progress=false --update-notifier=false";
     case "yarn":
       return "add";
     case "pnpm":
+      return "add --loglevel=error";
+    case "bun":
       return "add";
     default:
-      return "install";
-  }
-}
-var logger = new PinoLogger({
-  name: "Mastra CLI",
-  level: "info"
-});
-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 fs.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;
-  }
-}
-async function directoryExists(dirPath) {
-  try {
-    const stat = await fs.stat(dirPath);
-    return stat.isDirectory();
-  } catch {
-    return false;
-  }
-}
-async function fileExists(filePath) {
-  try {
-    const stat = await fs.stat(filePath);
-    return stat.isFile();
-  } catch {
-    return false;
-  }
-}
-async function cloneRepositoryWithoutGit(repoUrl, targetPath) {
-  await fs.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 fs.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 = path3.join(projectPath, "package.json");
-  try {
-    const packageJsonContent = await fs.readFile(packageJsonPath, "utf-8");
-    const packageJson = JSON.parse(packageJsonContent);
-    packageJson.name = projectName;
-    await fs.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 = 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;
-  }
-}
-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 ve({
-    message: "Select a template:",
-    options: choices
-  });
-  if (pD(selected)) {
-    return null;
+      return "add";
   }
-  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 DepsService = class {
   packageManager;
@@ -1370,7 +1256,7 @@ 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__default.existsSync(path3.join(dir, file))) {
+      if (fs3__default__default.existsSync(path3.join(dir, file))) {
         return file;
       }
     }
@@ -1396,14 +1282,10 @@ var DepsService = class {
     }
   }
   async installPackages(packages) {
-    let runCommand = this.packageManager;
-    if (this.packageManager === "npm") {
-      runCommand = `${this.packageManager} i`;
-    } else {
-      runCommand = `${this.packageManager} add`;
-    }
+    const pm = this.packageManager;
+    const installCommand = getPackageManagerAddCommand(pm);
     const packageList = packages.join(" ");
-    return execa(`${runCommand} ${packageList}`, {
+    return execa(`${pm} ${installCommand} ${packageList}`, {
       all: true,
       shell: true,
       stdio: "inherit"
@@ -1413,11 +1295,11 @@ var DepsService = class {
     try {
       const packageJsonPath = path3.join(process.cwd(), "package.json");
       try {
-        await fs.access(packageJsonPath);
+        await fs4.access(packageJsonPath);
       } catch {
         return "No package.json file found in the current directory";
       }
-      const packageJson = JSON.parse(await fs.readFile(packageJsonPath, "utf-8"));
+      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})`;
@@ -1432,164 +1314,45 @@ var DepsService = class {
   async getProjectName() {
     try {
       const packageJsonPath = path3.join(process.cwd(), "package.json");
-      const packageJson = await fs.readFile(packageJsonPath, "utf-8");
+      const packageJson = await fs4.readFile(packageJsonPath, "utf-8");
       const pkg = JSON.parse(packageJson);
       return pkg.name;
     } catch (err) {
       throw err;
     }
   }
-  async getPackageVersion() {
-    const __filename = fileURLToPath(import.meta.url);
-    const __dirname = dirname(__filename);
-    const pkgJsonPath = path3.join(__dirname, "..", "package.json");
-    const content = await fsExtra3.readJSON(pkgJsonPath);
-    return content.version;
-  }
   async addScriptsToPackageJson(scripts) {
-    const packageJson = JSON.parse(await fs.readFile("package.json", "utf-8"));
+    const packageJson = JSON.parse(await fs4.readFile("package.json", "utf-8"));
     packageJson.scripts = {
       ...packageJson.scripts,
       ...scripts
     };
-    await fs.writeFile("package.json", JSON.stringify(packageJson, null, 2));
+    await fs4.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
-      }
-    }
-  };
+var EnvService = class {
 };
-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");
+var FileEnvService = class extends EnvService {
+  filePath;
+  constructor(filePath) {
+    super();
+    this.filePath = filePath;
   }
-  if (editor === `vscode`) {
-    await writeMergedConfig(path3.join(directory, ".vscode", "mcp.json"), "vscode");
+  readFile(filePath) {
+    return new Promise((resolve, reject) => {
+      fs3__default.readFile(filePath, "utf8", (err, data) => {
+        if (err) reject(err);
+        else resolve(data);
+      });
+    });
   }
-  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 EnvService = class {
-};
-var FileEnvService = class extends EnvService {
-  filePath;
-  constructor(filePath) {
-    super();
-    this.filePath = filePath;
-  }
-  readFile(filePath) {
-    return new Promise((resolve, reject) => {
-      fs4__default.readFile(filePath, "utf8", (err, data) => {
-        if (err) reject(err);
-        else resolve(data);
-      });
-    });
-  }
-  writeFile({ filePath, data }) {
-    return new Promise((resolve, reject) => {
-      fs4__default.writeFile(filePath, data, "utf8", (err) => {
-        if (err) reject(err);
-        else resolve();
-      });
-    });
+  writeFile({ filePath, data }) {
+    return new Promise((resolve, reject) => {
+      fs3__default.writeFile(filePath, data, "utf8", (err) => {
+        if (err) reject(err);
+        else resolve();
+      });
+    });
   }
   async updateEnvData({
     key,
@@ -1605,7 +1368,7 @@ var FileEnvService = class extends EnvService {
 ${key}=${value}`;
     }
     await this.writeFile({ filePath, data });
-    console.log(`${key} set to ${value} in ENV file.`);
+    console.info(`${key} set to ${value} in ENV file.`);
     return data;
   }
   async getEnvValue(key) {
@@ -1640,23 +1403,23 @@ var FileService = class {
     const __filename = fileURLToPath(import.meta.url);
     const __dirname = path3.dirname(__filename);
     const filePath = path3.resolve(__dirname, "starter-files", inputFile);
-    const fileString = fs4__default__default.readFileSync(filePath, "utf8");
-    if (fs4__default__default.existsSync(outputFilePath) && !replaceIfExists) {
-      console.log(`${outputFilePath} already exists`);
+    const fileString = fs3__default__default.readFileSync(filePath, "utf8");
+    if (fs3__default__default.existsSync(outputFilePath) && !replaceIfExists) {
+      console.info(`${outputFilePath} already exists`);
       return false;
     }
-    await fsExtra3.outputFile(outputFilePath, fileString);
+    await fsExtra.outputFile(outputFilePath, fileString);
     return true;
   }
   async setupEnvFile({ dbUrl }) {
     const envPath = path3.join(process.cwd(), ".env.development");
-    await fsExtra3.ensureFile(envPath);
+    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__default.existsSync(f)) {
+      if (fs3__default__default.existsSync(f)) {
         return f;
       }
     }
@@ -1666,61 +1429,162 @@ var FileService = class {
     filePath,
     replacements
   }) {
-    let fileContent = fs4__default__default.readFileSync(filePath, "utf8");
+    let fileContent = fs3__default__default.readFileSync(filePath, "utf8");
     replacements.forEach(({ search, replace }) => {
       fileContent = fileContent.replaceAll(search, replace);
     });
-    fs4__default__default.writeFileSync(filePath, fileContent);
+    fs3__default__default.writeFileSync(filePath, fileContent);
   }
 };
-var exec2 = util.promisify(child_process.exec);
-var getAISDKPackageVersion = (llmProvider) => {
-  switch (llmProvider) {
-    case "cerebras":
-      return "^0.2.14";
-    default:
-      return "^1.0.0";
-  }
+var createArgs = (versionTag) => {
+  const packageName = versionTag ? `@mastra/mcp-docs-server@${versionTag}` : "@mastra/mcp-docs-server";
+  return ["-y", packageName];
 };
-var getAISDKPackage = (llmProvider) => {
-  switch (llmProvider) {
-    case "openai":
-      return "@ai-sdk/openai";
-    case "anthropic":
-      return "@ai-sdk/anthropic";
-    case "groq":
-      return "@ai-sdk/groq";
-    case "google":
-      return "@ai-sdk/google";
-    case "cerebras":
-      return "@ai-sdk/cerebras";
-    default:
-      return "@ai-sdk/openai";
+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
+      }
+    }
+  };
 };
-var getProviderImportAndModelItem = (llmProvider) => {
-  let providerImport = "";
-  let modelItem = "";
-  if (llmProvider === "openai") {
-    providerImport = `import { openai } from '${getAISDKPackage(llmProvider)}';`;
-    modelItem = `openai('gpt-4o-mini')`;
-  } else if (llmProvider === "anthropic") {
-    providerImport = `import { anthropic } from '${getAISDKPackage(llmProvider)}';`;
-    modelItem = `anthropic('claude-3-5-sonnet-20241022')`;
+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 antigravityGlobalMCPConfigPath = path3.join(os.homedir(), ".gemini", "antigravity", "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);
+  }
+  if (editor === `antigravity`) {
+    const alreadyInstalled = await globalMCPIsAlreadyInstalled(editor, versionTag);
+    if (alreadyInstalled) {
+      return;
+    }
+    await writeMergedConfig(antigravityGlobalMCPConfigPath, editor, versionTag);
+  }
+}
+async function globalMCPIsAlreadyInstalled(editor, versionTag) {
+  let configPath = ``;
+  if (editor === "windsurf") {
+    configPath = windsurfGlobalMCPConfigPath;
+  } else if (editor === "antigravity") {
+    configPath = antigravityGlobalMCPConfigPath;
+  } 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) => {
+  let model = "openai/gpt-4o";
+  if (llmProvider === "anthropic") {
+    model = "anthropic/claude-sonnet-4-5";
   } else if (llmProvider === "groq") {
-    providerImport = `import { groq } from '${getAISDKPackage(llmProvider)}';`;
-    modelItem = `groq('llama-3.3-70b-versatile')`;
+    model = "groq/llama-3.3-70b-versatile";
   } else if (llmProvider === "google") {
-    providerImport = `import { google } from '${getAISDKPackage(llmProvider)}';`;
-    modelItem = `google('gemini-2.5-pro')`;
+    model = "google/gemini-2.5-pro";
   } else if (llmProvider === "cerebras") {
-    providerImport = `import { cerebras } from '${getAISDKPackage(llmProvider)}';`;
-    modelItem = `cerebras('llama-3.3-70b')`;
+    model = "cerebras/llama-3.3-70b";
+  } else if (llmProvider === "mistral") {
+    model = "mistral/mistral-medium-2508";
   }
-  return { providerImport, modelItem };
+  return model;
 };
-async function writeAgentSample(llmProvider, destPath, addExampleTool) {
-  const { providerImport, modelItem } = getProviderImportAndModelItem(llmProvider);
+async function writeAgentSample(llmProvider, destPath, addExampleTool, addScorers) {
+  const modelString = getModelIdentifier(llmProvider);
   const instructions = `
       You are a helpful weather assistant that provides accurate weather information and can help planning activities based on the weather.
 
@@ -1736,30 +1600,49 @@ async function writeAgentSample(llmProvider, destPath, addExampleTool) {
       ${addExampleTool ? "Use the weatherTool to fetch current weather data." : ""}
 `;
   const content = `
-${providerImport}
 import { Agent } from '@mastra/core/agent';
 import { Memory } from '@mastra/memory';
-import { LibSQLStore } from '@mastra/libsql';
 ${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: ${modelItem},
+  model: '${modelString}',
   ${addExampleTool ? "tools: { weatherTool }," : ""}
-  memory: new Memory({
-    storage: new LibSQLStore({
-      url: "file:../mastra.db", // path is relative to the .mastra/output directory
-    })
-  })
+  ${addScorers ? `scorers: {
+    toolCallAppropriateness: {
+      scorer: scorers.toolCallAppropriatenessScorer,
+      sampling: {
+        type: 'ratio',
+        rate: 1,
+      },
+    },
+    completeness: {
+      scorer: scorers.completenessScorer,
+      sampling: {
+        type: 'ratio',
+        rate: 1,
+      },
+    },
+    translation: {
+      scorer: scorers.translationScorer,
+      sampling: {
+        type: 'ratio',
+        rate: 1,
+      },
+    },
+  },` : ""}
+  memory: new Memory()
 });
     `;
   const formattedContent = await prettier.format(content, {
     parser: "typescript",
     singleQuote: true
   });
-  await fs.writeFile(destPath, "");
-  await fs.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';
@@ -1952,72 +1835,176 @@ export { weatherWorkflow };`;
     semi: true,
     singleQuote: true
   });
-  await fs.writeFile(destPath, formattedContent);
+  await fs4.writeFile(destPath, formattedContent);
 }
 async function writeToolSample(destPath) {
   const fileService = new FileService();
   await fileService.copyStarterFile("tools.ts", destPath);
 }
+async function writeScorersSample(llmProvider, destPath) {
+  const modelString = getModelIdentifier(llmProvider);
+  const content = `import { z } from 'zod';
+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',
+  strictMode: false,
+});
+
+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}',
+    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. ' +
+      'Be lenient with transliteration differences and diacritics. ' +
+      'Return only the structured JSON matching the provided schema.',
+  },
+})
+  .preprocess(({ run }) => {
+    const userText = getUserMessageFromRunInput(run.input) || '';
+    const assistantText = getAssistantMessageFromRunOutput(run.output) || '';
+    return { userText, assistantText };
+  })
+  .analyze({
+    description: 'Extract location names and detect language/translation adequacy',
+    outputSchema: z.object({
+      nonEnglish: z.boolean(),
+      translated: z.boolean(),
+      confidence: z.number().min(0).max(1).default(1),
+      explanation: z.string().default(''),
+    }),
+    createPrompt: ({ results }) => \`
+            You are evaluating if a weather assistant correctly handled translation of a non-English location.
+            User text:
+            """
+            \${results.preprocessStepResult.userText}
+            """
+            Assistant response:
+            """
+            \${results.preprocessStepResult.assistantText}
+            """
+            Tasks:
+            1) Identify if the user mentioned a location that appears non-English.
+            2) If non-English, check whether the assistant used a correct English translation of that location in its response.
+            3) Be lenient with transliteration differences (e.g., accents/diacritics).
+            Return JSON with fields:
+            {
+            "nonEnglish": boolean,
+            "translated": boolean,
+            "confidence": number, // 0-1
+            "explanation": string
+            }
+        \`,
+  })
+  .generateScore(({ results }) => {
+    const r = (results as any)?.analyzeStepResult || {};
+    if (!r.nonEnglish) return 1; // If not applicable, full credit
+    if (r.translated) return Math.max(0, Math.min(1, 0.7 + 0.3 * (r.confidence ?? 1)));
+    return 0; // Non-English but not translated
+  })
+  .generateReason(({ results, score }) => {
+    const r = (results as any)?.analyzeStepResult || {};
+    return \`Translation scoring: nonEnglish=\${r.nonEnglish ?? false}, translated=\${r.translated ?? false}, confidence=\${r.confidence ?? 0}. Score=\${score}. \${r.explanation ?? ''}\`;
+  });
+
+export const scorers = {
+  toolCallAppropriatenessScorer,
+  completenessScorer,
+  translationScorer,
+};`;
+  const formattedContent = await prettier.format(content, {
+    parser: "typescript",
+    singleQuote: true
+  });
+  await fs4.writeFile(destPath, formattedContent);
+}
 async function writeCodeSampleForComponents(llmprovider, component, destPath, importComponents) {
   switch (component) {
     case "agents":
-      return writeAgentSample(llmprovider, destPath, importComponents.includes("tools"));
+      return writeAgentSample(
+        llmprovider,
+        destPath,
+        importComponents.includes("tools"),
+        importComponents.includes("scorers")
+      );
     case "tools":
       return writeToolSample(destPath);
     case "workflows":
       return writeWorkflowSample(destPath);
+    case "scorers":
+      return writeScorersSample(llmprovider, destPath);
     default:
       return "";
   }
 }
 var createComponentsDir = async (dirPath, component) => {
   const componentPath = dirPath + `/${component}`;
-  await fsExtra3.ensureDir(componentPath);
+  await fsExtra.ensureDir(componentPath);
 };
 var writeIndexFile = async ({
   dirPath,
   addAgent,
   addExample,
-  addWorkflow
+  addWorkflow,
+  addScorers
 }) => {
   const indexPath = dirPath + "/index.ts";
   const destPath = path3.join(indexPath);
   try {
-    await fs.writeFile(destPath, "");
+    await fs4.writeFile(destPath, "");
     const filteredExports = [
       addWorkflow ? `workflows: { weatherWorkflow },` : "",
-      addAgent ? `agents: { weatherAgent },` : ""
+      addAgent ? `agents: { weatherAgent },` : "",
+      addScorers ? `scorers: { toolCallAppropriatenessScorer, completenessScorer, translationScorer },` : ""
     ].filter(Boolean);
     if (!addExample) {
-      await fs.writeFile(
+      await fs4.writeFile(
         destPath,
         `
-import { Mastra } from '@mastra/core';
+import { Mastra } from '@mastra/core/mastra';
 
 export const mastra = new Mastra()
         `
       );
       return;
     }
-    await fs.writeFile(
+    await fs4.writeFile(
       destPath,
       `
 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';` : ""}
 
 export const mastra = new Mastra({
   ${filteredExports.join("\n  ")}
   storage: new LibSQLStore({
-    // stores telemetry, evals, ... into memory storage, if it needs to persist, change to file:../mastra.db
+    id: "mastra-storage",
+    // stores observability, scores, ... into memory storage, if it needs to persist, change to file:../mastra.db
     url: ":memory:",
   }),
   logger: new PinoLogger({
     name: 'Mastra',
     level: 'info',
   }),
+  observability: new Observability({
+    // Enables DefaultExporter and CloudExporter for tracing
+    default: { enabled: true },
+  }),
 });
 `
     );
@@ -2025,7 +2012,6 @@ export const mastra = new Mastra({
     throw err;
   }
 };
-yoctoSpinner({ text: "Installing Mastra core dependencies\n" });
 var getAPIKey = async (provider) => {
   let key = "OPENAI_API_KEY";
   switch (provider) {
@@ -2041,27 +2027,28 @@ var getAPIKey = async (provider) => {
     case "cerebras":
       key = "CEREBRAS_API_KEY";
       return key;
+    case "mistral":
+      key = "MISTRAL_API_KEY";
+      return key;
     default:
       return key;
   }
 };
-var writeAPIKey = async ({
-  provider,
-  apiKey = "your-api-key"
-}) => {
+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]);
-  await exec2(`echo ${escapedKey}=${escapedApiKey} >> .env`);
+  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");
   try {
-    await fs.access(dirPath);
+    await fs4.access(dirPath);
     return { ok: false };
   } catch {
-    await fsExtra3.ensureDir(dirPath);
+    await fsExtra.ensureDir(dirPath);
     return { ok: true, dirPath };
   }
 };
@@ -2073,8 +2060,19 @@ var writeCodeSample = async (dirPath, component, llmProvider, importComponents)
     throw err;
   }
 };
-var interactivePrompt = async () => {
-  Ie(color2.inverse(" Mastra Init "));
+var LLM_PROVIDERS = [
+  { value: "openai", label: "OpenAI", hint: "recommended" },
+  { value: "anthropic", label: "Anthropic" },
+  { value: "groq", label: "Groq" },
+  { value: "google", label: "Google" },
+  { value: "cerebras", label: "Cerebras" },
+  { value: "mistral", label: "Mistral" }
+];
+var interactivePrompt = async (args = {}) => {
+  const { skip = {}, options: { showBanner = true } = {} } = args;
+  if (showBanner) {
+    Ie(color2.inverse(" Mastra Init "));
+  }
   const mastraProject = await Ce(
     {
       directory: () => he({
@@ -2082,19 +2080,15 @@ var interactivePrompt = async () => {
         placeholder: "src/",
         defaultValue: "src/"
       }),
-      llmProvider: () => ve({
-        message: "Select default provider:",
-        options: [
-          { value: "openai", label: "OpenAI", hint: "recommended" },
-          { value: "anthropic", label: "Anthropic" },
-          { value: "groq", label: "Groq" },
-          { value: "google", label: "Google" },
-          { value: "cerebras", label: "Cerebras" }
-        ]
+      llmProvider: () => skip?.llmProvider ? void 0 : ve({
+        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 ve({
-          message: `Enter your ${llmProvider} API key?`,
+          message: `Enter your ${llmName} API key?`,
           options: [
             { value: "skip", label: "Skip for now", hint: "default" },
             { value: "enter", label: "Enter API key" }
@@ -2104,52 +2098,42 @@ var interactivePrompt = async () => {
         if (keyChoice === "enter") {
           return he({
             message: "Enter your API key:",
-            placeholder: "sk-..."
+            placeholder: "sk-...",
+            validate: (value) => {
+              if (value.length === 0) return "API key cannot be empty";
+            }
           });
         }
         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 AI IDE into a Mastra expert? (installs Mastra docs MCP server)`,
+          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"
+            },
+            {
+              value: "antigravity",
+              label: "Antigravity"
             }
           ]
         });
         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(
             `
@@ -2158,19 +2142,19 @@ Note: you will need to go into Cursor Settings -> MCP Settings and manually enab
           );
         }
         if (editor === `cursor-global`) {
-          const confirm2 = await ve({
+          const confirm3 = await ve({
             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 (confirm2 !== `yes`) {
+          if (confirm3 !== `yes`) {
             return void 0;
           }
         }
         if (editor === `windsurf`) {
-          const confirm2 = await ve({
+          const confirm3 = await ve({
             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: [
@@ -2178,11 +2162,31 @@ This means the Mastra docs MCP server will be available in all your Windsurf pro
               { value: "skip", label: "No, skip for now" }
             ]
           });
-          if (confirm2 !== `yes`) {
+          if (confirm3 !== `yes`) {
+            return void 0;
+          }
+        }
+        if (editor === `antigravity`) {
+          const confirm3 = await ve({
+            message: `Antigravity only supports a global MCP config (at ${antigravityGlobalMCPConfigPath}). Is it ok to add/update that global config?
+This will make the Mastra docs MCP server available in all Antigravity projects.`,
+            options: [
+              { value: "yes", label: "Yes, I understand" },
+              { value: "skip", label: "No, skip for now" }
+            ]
+          });
+          if (confirm3 !== `yes`) {
             return void 0;
           }
         }
         return editor;
+      },
+      initGit: async () => {
+        if (skip?.gitInit) return false;
+        return ye({
+          message: "Initialize a new git repository?",
+          initialValue: true
+        });
       }
     },
     {
@@ -2194,17 +2198,245 @@ This means the Mastra docs MCP server will be available in all your Windsurf pro
   );
   return mastraProject;
 };
+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";
+  }
+  if (userAgent.includes("pnpm")) {
+    return "pnpm";
+  }
+  if (userAgent.includes("npm")) {
+    return "npm";
+  }
+  if (execPath.includes("bun")) {
+    return "bun";
+  }
+  if (execPath.includes("yarn")) {
+    return "yarn";
+  }
+  if (execPath.includes("pnpm")) {
+    return "pnpm";
+  }
+  if (execPath.includes("npm")) {
+    return "npm";
+  }
+  return "npm";
+}
+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({
+    name: "Mastra CLI",
+    level: debug ? "debug" : "info"
+  });
+}
+var exec2 = util.promisify(child_process.exec);
+async function cloneTemplate(options) {
+  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, branch);
+    await updatePackageJson(projectPath, projectName);
+    const envExamplePath = path3.join(projectPath, ".env.example");
+    if (await fileExists(envExamplePath)) {
+      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;
+  } catch (error) {
+    spinner4.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, branch) {
+  await fs4.mkdir(targetPath, { recursive: true });
+  try {
+    const degitRepo = repoUrl.replace("https://github.com/", "");
+    const degitRepoWithBranch = branch ? `${degitRepo}#${branch}` : degitRepo;
+    const degitCommand = shellQuote2.quote(["npx", "degit", degitRepoWithBranch, targetPath]);
+    await exec2(degitCommand, {
+      cwd: process.cwd()
+    });
+  } catch {
+    try {
+      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 = path3.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 = path3.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 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 {
+    const pm = packageManager || getPackageManager();
+    const installCommand = shellQuote2.quote([pm, "install"]);
+    await exec2(installCommand, {
+      cwd: projectPath
+    });
+    spinner4.success("Dependencies installed successfully");
+  } catch (error) {
+    spinner4.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 ve({
+    message: "Select a template:",
+    options: choices
+  });
+  if (pD(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 = Y();
-var exec3 = util.promisify(child_process.exec);
 var init = async ({
-  directory,
-  addExample = false,
+  directory = "src/",
   components,
   llmProvider = "openai",
   llmApiKey,
-  configureEditorWithDocsMCP
+  addExample = false,
+  configureEditorWithDocsMCP,
+  versionTag,
+  initGit = false
 }) => {
   s.start("Initializing Mastra");
+  const packageVersionTag = versionTag ? `@${versionTag}` : "";
   try {
     const result = await createMastraDir(directory);
     if (!result.ok) {
@@ -2217,7 +2449,8 @@ var init = async ({
         dirPath,
         addExample,
         addWorkflow: components.includes("workflows"),
-        addAgent: components.includes("agents")
+        addAgent: components.includes("agents"),
+        addScorers: components.includes("scorers")
       }),
       ...components.map((component) => createComponentsDir(dirPath, component)),
       writeAPIKey({ provider: llmProvider, apiKey: llmApiKey })
@@ -2231,31 +2464,44 @@ 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${packageVersionTag}`]);
+      }
+      const needsEvals = components.includes(`scorers`) && await depService.checkDependencies(["@mastra/evals"]) !== `ok`;
+      if (needsEvals) {
+        await depService.installPackages([`@mastra/evals${packageVersionTag}`]);
       }
     }
     const key = await getAPIKey(llmProvider || "openai");
-    const aiSdkPackage = getAISDKPackage(llmProvider);
-    const aiSdkPackageVersion = getAISDKPackageVersion(llmProvider);
-    const depsService = new DepsService();
-    const pm = depsService.packageManager;
-    const installCommand = getPackageManagerInstallCommand(pm);
-    await exec3(`${pm} ${installCommand} ${aiSdkPackage}@${aiSdkPackageVersion}`);
     if (configureEditorWithDocsMCP) {
       await installMastraDocsMCPServer({
         editor: configureEditorWithDocsMCP,
-        directory: process.cwd()
+        directory: process.cwd(),
+        versionTag
       });
     }
     s.stop();
+    if (initGit) {
+      const s2 = Y();
+      try {
+        s2.start("Initializing git repository");
+        await gitInit({ cwd: process.cwd() });
+        s2.stop("Git repository initialized");
+      } catch {
+        s2.stop();
+      }
+    }
     if (!llmApiKey) {
       Me(`
       ${color2.green("Mastra initialized successfully!")}
@@ -2275,10 +2521,10 @@ var init = async ({
     return { success: false };
   }
 };
-var exec4 = util.promisify(child_process.exec);
+var exec3 = util.promisify(child_process.exec);
 var execWithTimeout = async (command, timeoutMs) => {
   try {
-    const promise = exec4(command, { killSignal: "SIGTERM" });
+    const promise = exec3(command, { killSignal: "SIGTERM" });
     if (!timeoutMs) {
       return await promise;
     }
@@ -2301,10 +2547,36 @@ 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 = getPackageManagerInstallCommand(pm);
+  let installCommand = getPackageManagerAddCommand(pm);
   if (isDev) {
-    installCommand = `${installCommand} --save-dev`;
+    installCommand = `${installCommand} -D`;
   }
   try {
     await execWithTimeout(`${pm} ${installCommand} ${dependency}${versionTag}`, timeout);
@@ -2326,23 +2598,42 @@ async function installMastraDependency(pm, dependency, versionTag, isDev, timeou
 var createMastraProject = async ({
   projectName: name,
   createVersionTag,
-  timeout
+  timeout,
+  llmProvider,
+  llmApiKey,
+  needsInteractive
 }) => {
   Ie(color2.inverse(" Mastra Create "));
   const projectName = name ?? await he({
     message: "What do you want to name your project?",
     placeholder: "my-mastra-app",
-    defaultValue: "my-mastra-app"
+    defaultValue: "my-mastra-app",
+    validate: (value) => {
+      if (value.length === 0) return "Project name cannot be empty";
+      if (fs3__default__default.existsSync(value)) {
+        return `A directory named "${value}" already exists. Please choose a different name.`;
+      }
+    }
   });
   if (pD(projectName)) {
     xe("Operation cancelled");
     process.exit(0);
   }
+  let result = void 0;
+  if (needsInteractive) {
+    result = await interactivePrompt({
+      options: { showBanner: false },
+      skip: { llmProvider: llmProvider !== void 0, llmApiKey: llmApiKey !== void 0 }
+    });
+  }
   const s2 = Y();
+  const originalCwd = process.cwd();
+  let projectPath = null;
   try {
     s2.start("Creating project");
     try {
-      await fs.mkdir(projectName);
+      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.`);
@@ -2354,12 +2645,10 @@ var createMastraProject = async ({
     }
     process.chdir(projectName);
     const pm = getPackageManager();
-    const installCommand = getPackageManagerInstallCommand(pm);
+    const installCommand = getPackageManagerAddCommand(pm);
     s2.message("Initializing project structure");
     try {
-      await exec4(`npm init -y`);
-      await exec4(`npm pkg set type="module"`);
-      await exec4(`npm pkg set engines.node=">=20.9.0"`);
+      await initializePackageJson(pm);
       const depsService = new DepsService();
       await depsService.addScriptsToPackageJson({
         dev: "mastra dev",
@@ -2374,9 +2663,9 @@ var createMastraProject = async ({
     s2.stop("Project structure created");
     s2.start(`Installing ${pm} dependencies`);
     try {
-      await exec4(`${pm} ${installCommand} zod@^3`);
-      await exec4(`${pm} ${installCommand} typescript @types/node --save-dev`);
-      await exec4(`echo '{
+      await exec3(`${pm} ${installCommand} zod@^4`);
+      await exec3(`${pm} ${installCommand} -D typescript @types/node`);
+      await exec3(`echo '{
   "compilerOptions": {
     "target": "ES2022",
     "module": "ES2022",
@@ -2398,15 +2687,15 @@ var createMastraProject = async ({
       );
     }
     s2.stop(`${pm} dependencies installed`);
-    s2.start("Installing mastra");
+    s2.start("Installing Mastra CLI");
     const versionTag = createVersionTag ? `@${createVersionTag}` : "@latest";
     try {
       await installMastraDependency(pm, "mastra", versionTag, true, timeout);
     } catch (error) {
       throw new Error(`Failed to install Mastra CLI: ${error instanceof Error ? error.message : "Unknown error"}`);
     }
-    s2.stop("mastra installed");
-    s2.start("Installing dependencies");
+    s2.stop("Mastra CLI installed");
+    s2.start("Installing Mastra dependencies");
     try {
       await installMastraDependency(pm, "@mastra/core", versionTag, false, timeout);
       await installMastraDependency(pm, "@mastra/libsql", versionTag, false, timeout);
@@ -2419,58 +2708,80 @@ var createMastraProject = async ({
     s2.stop("Mastra dependencies installed");
     s2.start("Adding .gitignore");
     try {
-      await exec4(`echo output.txt >> .gitignore`);
-      await exec4(`echo node_modules >> .gitignore`);
-      await exec4(`echo dist >> .gitignore`);
-      await exec4(`echo .mastra >> .gitignore`);
-      await exec4(`echo .env.development >> .gitignore`);
-      await exec4(`echo .env >> .gitignore`);
-      await exec4(`echo *.db >> .gitignore`);
-      await exec4(`echo *.db-* >> .gitignore`);
+      await exec3(`echo output.txt >> .gitignore`);
+      await exec3(`echo node_modules >> .gitignore`);
+      await exec3(`echo dist >> .gitignore`);
+      await exec3(`echo .mastra >> .gitignore`);
+      await exec3(`echo .env.development >> .gitignore`);
+      await exec3(`echo .env >> .gitignore`);
+      await exec3(`echo *.db >> .gitignore`);
+      await exec3(`echo *.db-* >> .gitignore`);
     } catch (error) {
       throw new Error(`Failed to create .gitignore: ${error instanceof Error ? error.message : "Unknown error"}`);
     }
     s2.stop(".gitignore added");
     Se("Project created successfully");
-    console.log("");
-    return { projectName };
+    console.info("");
+    return { projectName, result };
   } catch (error) {
     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);
+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 { projectName } = await createMastraProject({
-    projectName: args2?.projectName,
-    createVersionTag: args2?.createVersionTag,
-    timeout: args2?.timeout
+  const needsInteractive = args.components === void 0 || args.llmProvider === void 0 || args.addExample === void 0;
+  const { projectName, result } = await createMastraProject({
+    projectName: args?.projectName,
+    createVersionTag: args?.createVersionTag,
+    timeout: args?.timeout,
+    llmProvider: args?.llmProvider,
+    llmApiKey: args?.llmApiKey,
+    needsInteractive
   });
-  const directory = args2.directory || "src/";
-  if (args2.components === void 0 || args2.llmProvider === void 0 || args2.addExample === void 0) {
-    const result = await interactivePrompt();
+  const directory = args.directory || "src/";
+  if (needsInteractive && result) {
     await init({
       ...result,
       llmApiKey: result?.llmApiKey,
-      components: ["agents", "tools", "workflows"],
-      addExample: true
+      components: ["agents", "tools", "workflows", "scorers"],
+      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 });
 };
@@ -2561,9 +2872,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) {
@@ -2571,26 +2882,26 @@ async function createFromTemplate(args2) {
       return;
     }
     selectedTemplate = selected;
-  } else if (args2.template && typeof args2.template === "string") {
-    if (isGitHubUrl(args2.template)) {
-      const spinner5 = Y();
-      spinner5.start("Validating GitHub repository...");
-      const validation = await validateGitHubProject(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(args.template);
       if (!validation.isValid) {
-        spinner5.stop("Validation failed");
+        spinner4.stop("Validation failed");
         M.error("This does not appear to be a valid Mastra project:");
         validation.errors.forEach((error) => M.error(`  - ${error}`));
         throw new Error("Invalid Mastra project");
       }
-      spinner5.stop("Valid Mastra project \u2713");
-      selectedTemplate = await createFromGitHubUrl(args2.template);
+      spinner4.stop("Valid Mastra project \u2713");
+      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;
     }
@@ -2598,7 +2909,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({
@@ -2612,22 +2923,80 @@ 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 initGit = false;
+  const gitConfirmResult = await ye({
+    message: "Initialize a new git repository?",
+    initialValue: true
+  });
+  if (!pD(gitConfirmResult)) {
+    initGit = gitConfirmResult;
+  }
+  let projectPath = null;
   try {
-    const analytics = getAnalytics();
-    if (analytics) ;
-    const projectPath = await cloneTemplate({
+    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 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);
+    if (initGit) {
+      const s2 = Y();
+      try {
+        s2.start("Initializing git repository");
+        await gitInit({ cwd: projectPath });
+        s2.stop("Git repository initialized");
+      } catch {
+        s2.stop();
+      }
+    }
     Me(`
       ${color2.green("Mastra template installed!")}
 
-      Add the necessary environment 
+      Add the necessary environment
       variables in your ${color2.cyan(".env")} file
       `);
     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;
   }
@@ -2637,13 +3006,13 @@ async function getPackageVersion() {
   const __filename = fileURLToPath(import.meta.url);
   const __dirname = dirname(__filename);
   const pkgJsonPath = path3.join(__dirname, "..", "package.json");
-  const content = await fsExtra.readJSON(pkgJsonPath);
+  const content = await fsExtra$1.readJSON(pkgJsonPath);
   return content.version;
 }
 async function getCreateVersionTag() {
   try {
     const pkgPath = fileURLToPath(import.meta.resolve("create-mastra/package.json"));
-    const json = await fsExtra.readJSON(pkgPath);
+    const json = await fsExtra$1.readJSON(pkgPath);
     const { stdout } = await execa("npm", ["dist-tag", "create-mastra"]);
     const tagLine = stdout.split("\n").find((distLine) => distLine.endsWith(`: ${json.version}`));
     const tag = tagLine ? tagLine.split(":")[0].trim() : "latest";
@@ -2667,14 +3036,14 @@ program.version(`${version}`, "-v, --version").description(`create-mastra ${vers
     analytics.trackCommand({
       command: "version"
     });
-    console.log(`create-mastra ${version}`);
+    console.info(`create-mastra ${version}`);
   } catch {
   }
 });
 program.name("create-mastra").description("Create a new Mastra project").argument("[project-name]", "Directory name of the project").option(
   "-p, --project-name <string>",
   "Project name that will be used in package.json and as the project directory name."
-).option("--default", "Quick start with defaults(src, OpenAI, examples)").option("-c, --components <components>", "Comma-separated list of components (agents, tools, workflows)").option("-l, --llm <model-provider>", "Default model provider (openai, anthropic, groq, google, or cerebras)").option("-k, --llm-api-key <api-key>", "API key for the model provider").option("-e, --example", "Include example code").option("-n, --no-example", "Do not include example code").option("-t, --timeout [timeout]", "Configurable timeout for package installation, defaults to 60000 ms").option("-d, --dir <directory>", "Target directory for Mastra source code (default: src/)").option("-m, --mcp <mcp>", "MCP Server for code editor (cursor, cursor-global, windsurf, vscode)").option(
+).option("--default", "Quick start with defaults (src, OpenAI, examples)").option("-c, --components <components>", "Comma-separated list of components (agents, tools, workflows, scorers)").option("-l, --llm <model-provider>", "Default model provider (openai, anthropic, groq, google, or cerebras)").option("-k, --llm-api-key <api-key>", "API key for the model provider").option("-e, --example", "Include example code").option("-n, --no-example", "Do not include example code").option("-t, --timeout [timeout]", "Configurable timeout for package installation, defaults to 60000 ms").option("-d, --dir <directory>", "Target directory for Mastra source code (default: src/)").option("-m, --mcp <mcp>", "MCP Server for code editor (cursor, cursor-global, windsurf, vscode, antigravity)").option(
   "--template [template-name]",
   "Create project from a template (use template name, public GitHub URL, or leave blank to select from list)"
 ).action(async (projectNameArg, args) => {
@@ -2682,14 +3051,15 @@ program.name("create-mastra").description("Create a new Mastra project").argumen
   const timeout = args?.timeout ? args?.timeout === true ? 6e4 : parseInt(args?.timeout, 10) : void 0;
   if (args.default) {
     await create({
-      components: ["agents", "tools", "workflows"],
+      components: ["agents", "tools", "workflows", "scorers"],
       llmProvider: "openai",
       addExample: true,
       createVersionTag,
       timeout,
       mcpServer: args.mcp,
       directory: "src/",
-      template: args.template
+      template: args.template,
+      analytics
     });
     return;
   }
@@ -2697,13 +3067,14 @@ program.name("create-mastra").description("Create a new Mastra project").argumen
     components: args.components ? args.components.split(",") : [],
     llmProvider: args.llm,
     addExample: args.example,
-    llmApiKey: args["llm-api-key"],
+    llmApiKey: args.llmApiKey,
     createVersionTag,
     timeout,
     projectName,
     directory: args.dir,
     mcpServer: args.mcp,
-    template: args.template
+    template: args.template,
+    analytics
   });
 });
 program.parse(process.argv);