create-mastra 0.0.0-agui-20250501191909 → 0.0.0-cli-debug-2-20250611100354

package/dist/index.js

@@ -4,7 +4,7 @@ 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 path2, { dirname } from 'node:path';
 import { fileURLToPath } from 'node:url';
 import { PostHog } from 'posthog-node';
 import h, { stdin, stdout } from 'node:process';
@@ -17,13 +17,12 @@ import fs4 from 'node:fs/promises';
 import { execa } from 'execa';
 import fsExtra3, { readJSON, ensureFile, writeJSON } from 'fs-extra/esm';
 import prettier from 'prettier';
-import { Transform } from 'node:stream';
 import pino from 'pino';
 import pretty from 'pino-pretty';
 import fsExtra from 'fs-extra';
 
 var __filename = fileURLToPath(import.meta.url);
-var __dirname = path.dirname(__filename);
+var __dirname = path2.dirname(__filename);
 var PosthogAnalytics = class {
   sessionId;
   client;
@@ -35,7 +34,7 @@ var PosthogAnalytics = class {
     host = "https://app.posthog.com"
   }) {
     this.version = version;
-    const cliConfigPath = path.join(__dirname, "mastra-cli.json");
+    const cliConfigPath = path2.join(__dirname, "mastra-cli.json");
     if (existsSync(cliConfigPath)) {
       try {
         const { distinctId, sessionId } = JSON.parse(readFileSync(cliConfigPath, "utf-8"));
@@ -63,7 +62,7 @@ var PosthogAnalytics = class {
   }
   writeCliConfig({ distinctId, sessionId }) {
     try {
-      writeFileSync(path.join(__dirname, "mastra-cli.json"), JSON.stringify({ distinctId, sessionId }));
+      writeFileSync(path2.join(__dirname, "mastra-cli.json"), JSON.stringify({ distinctId, sessionId }));
     } catch {
     }
   }
@@ -416,6 +415,283 @@ ${color2.gray($)}  ${s}
 `);let m=0,w=0;p(),i=setInterval(()=>{const L=color2.magenta(s[m]),O=".".repeat(Math.floor(w)).slice(0,3);process.stdout.write(srcExports.cursor.move(-999,0)),process.stdout.write(srcExports.erase.down(1)),process.stdout.write(`${L}  ${o}${O}`),m=m+1<s.length?m+1:0,w=w<s.length?w+.125:0;},n);},x=(g="",m=0)=>{o=g??o,r=false,clearInterval(i);const w=m===0?color2.green(M):m===1?color2.red(P):color2.red(V);process.stdout.write(srcExports.cursor.move(-999,0)),process.stdout.write(srcExports.erase.down(1)),process.stdout.write(`${w}  ${o}
 `),S(),t();};return {start:f,stop:x,message:(g="")=>{o=g??o;}}};function ye(){const s=["[\\u001B\\u009B][[\\]()#;?]*(?:(?:(?:(?:;[-a-zA-Z\\d\\/#&.:=?%@~_]+)*|[a-zA-Z\\d]+(?:;[-a-zA-Z\\d\\/#&.:=?%@~_]*)*)?\\u0007)","(?:(?:\\d{1,4}(?:;\\d{0,4})*)?[\\dA-PR-TZcf-nq-uy=><~]))"].join("|");return new RegExp(s,"g")}const ve=async(s,n)=>{const t={},i=Object.keys(s);for(const r of i){const o=s[r],c=await o({results:t})?.catch(l=>{throw l});if(typeof n?.onCancel=="function"&&lD(c)){t[r]="canceled",n.onCancel({results:t});continue}t[r]=c;}return t};
 
+var shellQuote$1 = {};
+
+var quote;
+var hasRequiredQuote;
+
+function requireQuote () {
+	if (hasRequiredQuote) return quote;
+	hasRequiredQuote = 1;
+
+	quote = function quote(xs) {
+		return xs.map(function (s) {
+			if (s === '') {
+				return '\'\'';
+			}
+			if (s && typeof s === 'object') {
+				return s.op.replace(/(.)/g, '\\$1');
+			}
+			if ((/["\s]/).test(s) && !(/'/).test(s)) {
+				return "'" + s.replace(/(['\\])/g, '\\$1') + "'";
+			}
+			if ((/["'\s]/).test(s)) {
+				return '"' + s.replace(/(["\\$`!])/g, '\\$1') + '"';
+			}
+			return String(s).replace(/([A-Za-z]:)?([#!"$&'()*,:;<=>?@[\\\]^`{|}])/g, '$1\\$2');
+		}).join(' ');
+	};
+	return quote;
+}
+
+var parse;
+var hasRequiredParse;
+
+function requireParse () {
+	if (hasRequiredParse) return parse;
+	hasRequiredParse = 1;
+
+	// '<(' is process substitution operator and
+	// can be parsed the same as control operator
+	var CONTROL = '(?:' + [
+		'\\|\\|',
+		'\\&\\&',
+		';;',
+		'\\|\\&',
+		'\\<\\(',
+		'\\<\\<\\<',
+		'>>',
+		'>\\&',
+		'<\\&',
+		'[&;()|<>]'
+	].join('|') + ')';
+	var controlRE = new RegExp('^' + CONTROL + '$');
+	var META = '|&;()<> \\t';
+	var SINGLE_QUOTE = '"((\\\\"|[^"])*?)"';
+	var DOUBLE_QUOTE = '\'((\\\\\'|[^\'])*?)\'';
+	var hash = /^#$/;
+
+	var SQ = "'";
+	var DQ = '"';
+	var DS = '$';
+
+	var TOKEN = '';
+	var mult = 0x100000000; // Math.pow(16, 8);
+	for (var i = 0; i < 4; i++) {
+		TOKEN += (mult * Math.random()).toString(16);
+	}
+	var startsWithToken = new RegExp('^' + TOKEN);
+
+	function matchAll(s, r) {
+		var origIndex = r.lastIndex;
+
+		var matches = [];
+		var matchObj;
+
+		while ((matchObj = r.exec(s))) {
+			matches.push(matchObj);
+			if (r.lastIndex === matchObj.index) {
+				r.lastIndex += 1;
+			}
+		}
+
+		r.lastIndex = origIndex;
+
+		return matches;
+	}
+
+	function getVar(env, pre, key) {
+		var r = typeof env === 'function' ? env(key) : env[key];
+		if (typeof r === 'undefined' && key != '') {
+			r = '';
+		} else if (typeof r === 'undefined') {
+			r = '$';
+		}
+
+		if (typeof r === 'object') {
+			return pre + TOKEN + JSON.stringify(r) + TOKEN;
+		}
+		return pre + r;
+	}
+
+	function parseInternal(string, env, opts) {
+		if (!opts) {
+			opts = {};
+		}
+		var BS = opts.escape || '\\';
+		var BAREWORD = '(\\' + BS + '[\'"' + META + ']|[^\\s\'"' + META + '])+';
+
+		var chunker = new RegExp([
+			'(' + CONTROL + ')', // control chars
+			'(' + BAREWORD + '|' + SINGLE_QUOTE + '|' + DOUBLE_QUOTE + ')+'
+		].join('|'), 'g');
+
+		var matches = matchAll(string, chunker);
+
+		if (matches.length === 0) {
+			return [];
+		}
+		if (!env) {
+			env = {};
+		}
+
+		var commented = false;
+
+		return matches.map(function (match) {
+			var s = match[0];
+			if (!s || commented) {
+				return void undefined;
+			}
+			if (controlRE.test(s)) {
+				return { op: s };
+			}
+
+			// Hand-written scanner/parser for Bash quoting rules:
+			//
+			// 1. inside single quotes, all characters are printed literally.
+			// 2. inside double quotes, all characters are printed literally
+			//    except variables prefixed by '$' and backslashes followed by
+			//    either a double quote or another backslash.
+			// 3. outside of any quotes, backslashes are treated as escape
+			//    characters and not printed (unless they are themselves escaped)
+			// 4. quote context can switch mid-token if there is no whitespace
+			//     between the two quote contexts (e.g. all'one'"token" parses as
+			//     "allonetoken")
+			var quote = false;
+			var esc = false;
+			var out = '';
+			var isGlob = false;
+			var i;
+
+			function parseEnvVar() {
+				i += 1;
+				var varend;
+				var varname;
+				var char = s.charAt(i);
+
+				if (char === '{') {
+					i += 1;
+					if (s.charAt(i) === '}') {
+						throw new Error('Bad substitution: ' + s.slice(i - 2, i + 1));
+					}
+					varend = s.indexOf('}', i);
+					if (varend < 0) {
+						throw new Error('Bad substitution: ' + s.slice(i));
+					}
+					varname = s.slice(i, varend);
+					i = varend;
+				} else if ((/[*@#?$!_-]/).test(char)) {
+					varname = char;
+					i += 1;
+				} else {
+					var slicedFromI = s.slice(i);
+					varend = slicedFromI.match(/[^\w\d_]/);
+					if (!varend) {
+						varname = slicedFromI;
+						i = s.length;
+					} else {
+						varname = slicedFromI.slice(0, varend.index);
+						i += varend.index - 1;
+					}
+				}
+				return getVar(env, '', varname);
+			}
+
+			for (i = 0; i < s.length; i++) {
+				var c = s.charAt(i);
+				isGlob = isGlob || (!quote && (c === '*' || c === '?'));
+				if (esc) {
+					out += c;
+					esc = false;
+				} else if (quote) {
+					if (c === quote) {
+						quote = false;
+					} else if (quote == SQ) {
+						out += c;
+					} else { // Double quote
+						if (c === BS) {
+							i += 1;
+							c = s.charAt(i);
+							if (c === DQ || c === BS || c === DS) {
+								out += c;
+							} else {
+								out += BS + c;
+							}
+						} else if (c === DS) {
+							out += parseEnvVar();
+						} else {
+							out += c;
+						}
+					}
+				} else if (c === DQ || c === SQ) {
+					quote = c;
+				} else if (controlRE.test(c)) {
+					return { op: s };
+				} else if (hash.test(c)) {
+					commented = true;
+					var commentObj = { comment: string.slice(match.index + i + 1) };
+					if (out.length) {
+						return [out, commentObj];
+					}
+					return [commentObj];
+				} else if (c === BS) {
+					esc = true;
+				} else if (c === DS) {
+					out += parseEnvVar();
+				} else {
+					out += c;
+				}
+			}
+
+			if (isGlob) {
+				return { op: 'glob', pattern: out };
+			}
+
+			return out;
+		}).reduce(function (prev, arg) { // finalize parsed arguments
+			// TODO: replace this whole reduce with a concat
+			return typeof arg === 'undefined' ? prev : prev.concat(arg);
+		}, []);
+	}
+
+	parse = function parse(s, env, opts) {
+		var mapped = parseInternal(s, env, opts);
+		if (typeof env !== 'function') {
+			return mapped;
+		}
+		return mapped.reduce(function (acc, s) {
+			if (typeof s === 'object') {
+				return acc.concat(s);
+			}
+			var xs = s.split(RegExp('(' + TOKEN + '.*?' + TOKEN + ')', 'g'));
+			if (xs.length === 1) {
+				return acc.concat(xs[0]);
+			}
+			return acc.concat(xs.filter(Boolean).map(function (x) {
+				if (startsWithToken.test(x)) {
+					return JSON.parse(x.split(TOKEN)[1]);
+				}
+				return x;
+			}));
+		}, []);
+	};
+	return parse;
+}
+
+var hasRequiredShellQuote;
+
+function requireShellQuote () {
+	if (hasRequiredShellQuote) return shellQuote$1;
+	hasRequiredShellQuote = 1;
+
+	shellQuote$1.quote = requireQuote();
+	shellQuote$1.parse = requireParse();
+	return shellQuote$1;
+}
+
+var shellQuoteExports = requireShellQuote();
+var shellQuote = /*@__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)
 // Lots of optionals here to support Deno.
@@ -789,46 +1065,88 @@ function yoctoSpinner(options) {
 }
 
 var LogLevel = {
-  INFO: "info"};
-var Logger = class {
-  logger;
+  INFO: "info",
+  ERROR: "error"};
+var MastraLogger = class {
+  name;
+  level;
   transports;
   constructor(options = {}) {
-    this.transports = options.transports || {};
-    const transportsAry = Object.entries(this.transports);
+    this.name = options.name || "Mastra";
+    this.level = options.level || LogLevel.ERROR;
+    this.transports = new Map(Object.entries(options.transports || {}));
+  }
+  getTransports() {
+    return this.transports;
+  }
+  trackException(_error) {
+  }
+  async getLogs(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) ?? {
+      logs: [],
+      total: 0,
+      page: params?.page ?? 1,
+      perPage: params?.perPage ?? 100,
+      hasMore: false
+    };
+  }
+  async getLogsByRunId({
+    transportId,
+    runId,
+    fromDate,
+    toDate,
+    logLevel,
+    filters,
+    page,
+    perPage
+  }) {
+    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 }) ?? {
+      logs: [],
+      total: 0,
+      page: page ?? 1,
+      perPage: perPage ?? 100,
+      hasMore: false
+    };
+  }
+};
+
+var PinoLogger = class extends MastraLogger {
+  logger;
+  constructor(options = {}) {
+    super(options);
+    let prettyStream = void 0;
+    if (!options.overrideDefaultTransports) {
+      prettyStream = pretty({
+        colorize: true,
+        levelFirst: true,
+        ignore: "pid,hostname",
+        colorizeObjects: true,
+        translateTime: "SYS:standard",
+        singleLine: false
+      });
+    }
+    const transportsAry = [...this.getTransports().entries()];
     this.logger = pino(
       {
         name: options.name || "app",
         level: options.level || LogLevel.INFO,
         formatters: {
-          level: (label) => {
-            return {
-              level: label
-            };
-          }
+          level: (label) => ({ level: label })
         }
       },
-      options.overrideDefaultTransports ? options?.transports?.default : transportsAry.length === 0 ? pretty({
-        colorize: true,
-        levelFirst: true,
-        ignore: "pid,hostname",
-        colorizeObjects: true,
-        translateTime: "SYS:standard",
-        singleLine: false
-      }) : pino.multistream([
+      options.overrideDefaultTransports ? options?.transports?.default : transportsAry.length === 0 ? prettyStream : pino.multistream([
         ...transportsAry.map(([, transport]) => ({
           stream: transport,
           level: options.level || LogLevel.INFO
         })),
         {
-          stream: pretty({
-            colorize: true,
-            levelFirst: true,
-            ignore: "pid,hostname",
-            colorizeObjects: true,
-            translateTime: "SYS:standard",
-            singleLine: false
-          }),
+          stream: prettyStream,
           level: options.level || LogLevel.INFO
         }
       ])
@@ -846,31 +1164,7 @@ var Logger = class {
   error(message, args = {}) {
     this.logger.error(args, message);
   }
-  // Stream creation for process output handling
-  createStream() {
-    return new Transform({
-      transform: (chunk, _encoding, callback) => {
-        const line = chunk.toString().trim();
-        if (line) {
-          this.info(line);
-        }
-        callback(null, chunk);
-      }
-    });
-  }
-  async getLogs(transportId) {
-    if (!transportId || !this.transports[transportId]) {
-      return [];
-    }
-    return this.transports[transportId].getLogs();
-  }
-  async getLogsByRunId({ runId, transportId }) {
-    return this.transports[transportId]?.getLogsByRunId({ runId });
-  }
 };
-function createLogger(options) {
-  return new Logger(options);
-}
 
 var DepsService = class {
   packageManager;
@@ -880,11 +1174,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(path2.join(dir, file))) {
         return file;
       }
     }
-    const parentDir = path.resolve(dir, "..");
+    const parentDir = path2.resolve(dir, "..");
     if (parentDir !== dir) {
       return this.findLockFile(parentDir);
     }
@@ -921,7 +1215,7 @@ var DepsService = class {
   }
   async checkDependencies(dependencies) {
     try {
-      const packageJsonPath = path.join(process.cwd(), "package.json");
+      const packageJsonPath = path2.join(process.cwd(), "package.json");
       try {
         await fs4.access(packageJsonPath);
       } catch {
@@ -941,7 +1235,7 @@ var DepsService = class {
   }
   async getProjectName() {
     try {
-      const packageJsonPath = path.join(process.cwd(), "package.json");
+      const packageJsonPath = path2.join(process.cwd(), "package.json");
       const packageJson = await fs4.readFile(packageJsonPath, "utf-8");
       const pkg = JSON.parse(packageJson);
       return pkg.name;
@@ -952,7 +1246,7 @@ var DepsService = class {
   async getPackageVersion() {
     const __filename = fileURLToPath(import.meta.url);
     const __dirname = dirname(__filename);
-    const pkgJsonPath = path.join(__dirname, "..", "package.json");
+    const pkgJsonPath = path2.join(__dirname, "..", "package.json");
     const content = await fsExtra3.readJSON(pkgJsonPath);
     return content.version;
   }
@@ -1000,57 +1294,85 @@ function getPackageManagerInstallCommand(pm) {
       return "install";
   }
 }
-var args = ["-y", "@mastra/mcp-docs-server@latest"];
-var mcpConfig = {
-  mcpServers: {
-    mastra: process.platform === `win32` ? {
-      command: "cmd",
-      args: ["/c", "npx", ...args]
-    } : {
-      command: "npx",
-      args
-    }
+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) {
+function makeConfig(original, editor) {
+  if (editor === "vscode") {
+    return {
+      ...original,
+      servers: {
+        ...original?.servers || {},
+        ...createMcpConfig(editor).servers
+      }
+    };
+  }
   return {
     ...original,
     mcpServers: {
       ...original?.mcpServers || {},
-      ...mcpConfig.mcpServers
+      ...createMcpConfig(editor).mcpServers
     }
   };
 }
-async function writeMergedConfig(configPath) {
+async function writeMergedConfig(configPath, editor) {
   const configExists = existsSync(configPath);
-  const config = makeConfig(configExists ? await readJSON(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");
-async function installMastraDocsMCPServer({
-  editor,
-  directory
-}) {
+var windsurfGlobalMCPConfigPath = path2.join(os.homedir(), ".codeium", "windsurf", "mcp_config.json");
+var cursorGlobalMCPConfigPath = path2.join(os.homedir(), ".cursor", "mcp.json");
+path2.join(process.cwd(), ".vscode", "mcp.json");
+var vscodeGlobalMCPConfigPath = path2.join(
+  os.homedir(),
+  process.platform === "win32" ? path2.join("AppData", "Roaming", "Code", "User", "settings.json") : process.platform === "darwin" ? path2.join("Library", "Application Support", "Code", "User", "settings.json") : path2.join(".config", "Code", "User", "settings.json")
+);
+async function installMastraDocsMCPServer({ editor, directory }) {
   if (editor === `cursor`) {
-    await writeMergedConfig(path.join(directory, ".cursor", "mcp.json"));
+    await writeMergedConfig(path2.join(directory, ".cursor", "mcp.json"), "cursor");
+  }
+  if (editor === `vscode`) {
+    await writeMergedConfig(path2.join(directory, ".vscode", "mcp.json"), "vscode");
   }
   if (editor === `cursor-global`) {
     const alreadyInstalled = await globalMCPIsAlreadyInstalled(editor);
     if (alreadyInstalled) {
       return;
     }
-    await writeMergedConfig(cursorGlobalMCPConfigPath);
+    await writeMergedConfig(cursorGlobalMCPConfigPath, "cursor-global");
   }
   if (editor === `windsurf`) {
     const alreadyInstalled = await globalMCPIsAlreadyInstalled(editor);
     if (alreadyInstalled) {
       return;
     }
-    await writeMergedConfig(windsurfGlobalMCPConfigPath);
+    await writeMergedConfig(windsurfGlobalMCPConfigPath, editor);
   }
 }
 async function globalMCPIsAlreadyInstalled(editor) {
@@ -1059,12 +1381,21 @@ async function globalMCPIsAlreadyInstalled(editor) {
     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 (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`))
@@ -1146,8 +1477,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 = path2.dirname(__filename);
+    const filePath = path2.resolve(__dirname, "starter-files", inputFile);
     const fileString = fs3__default__default.readFileSync(filePath, "utf8");
     if (fs3__default__default.existsSync(outputFilePath) && !replaceIfExists) {
       console.log(`${outputFilePath} already exists`);
@@ -1157,7 +1488,7 @@ var FileService = class {
     return true;
   }
   async setupEnvFile({ dbUrl }) {
-    const envPath = path.join(process.cwd(), ".env.development");
+    const envPath = path2.join(process.cwd(), ".env.development");
     await fsExtra3.ensureFile(envPath);
     const fileEnvService = new FileEnvService(envPath);
     await fileEnvService.setEnvValue("DB_URL", dbUrl);
@@ -1181,7 +1512,7 @@ var FileService = class {
     fs3__default__default.writeFileSync(filePath, fileContent);
   }
 };
-createLogger({
+new PinoLogger({
   name: "Mastra CLI",
   level: "debug"
 });
@@ -1207,7 +1538,7 @@ var getProviderImportAndModelItem = (llmProvider) => {
   let modelItem = "";
   if (llmProvider === "openai") {
     providerImport = `import { openai } from '${getAISDKPackage(llmProvider)}';`;
-    modelItem = `openai('gpt-4o')`;
+    modelItem = `openai('gpt-4o-mini')`;
   } else if (llmProvider === "anthropic") {
     providerImport = `import { anthropic } from '${getAISDKPackage(llmProvider)}';`;
     modelItem = `anthropic('claude-3-5-sonnet-20241022')`;
@@ -1241,7 +1572,8 @@ async function writeAgentSample(llmProvider, destPath, addExampleTool) {
 ${providerImport}
 import { Agent } from '@mastra/core/agent';
 import { Memory } from '@mastra/memory';
-${addExampleTool ? `import { weatherTool } from '../tools';` : ""}
+import { LibSQLStore } from '@mastra/libsql';
+${addExampleTool ? `import { weatherTool } from '../tools/weather-tool';` : ""}
 
 export const weatherAgent = new Agent({
   name: 'Weather Agent',
@@ -1249,13 +1581,9 @@ export const weatherAgent = new Agent({
   model: ${modelItem},
   ${addExampleTool ? "tools: { weatherTool }," : ""}
   memory: new Memory({
-    options: {
-      lastMessages: 10,
-      semanticRecall: false,
-      threads: {
-        generateTitle: false
-      } 
-    }
+    storage: new LibSQLStore({
+      url: "file:../mastra.db", // path is relative to the .mastra/output directory
+    })
   })
 });
     `;
@@ -1270,7 +1598,7 @@ async function writeWorkflowSample(destPath, llmProvider) {
   const { providerImport, modelItem } = getProviderImportAndModelItem(llmProvider);
   const content = `${providerImport}
 import { Agent } from '@mastra/core/agent';
-import { Step, Workflow } from '@mastra/core/workflows';
+import { createStep, createWorkflow } from '@mastra/core/workflows';
 import { z } from 'zod';
 
 const llm = ${modelItem};
@@ -1323,80 +1651,107 @@ const agent = new Agent({
       \`,
 });
 
-const forecastSchema = z.array(
-  z.object({
-    date: z.string(),
-    maxTemp: z.number(),
-    minTemp: z.number(),
-    precipitationChance: z.number(),
-    condition: z.string(),
-    location: z.string(),
-  }),
-);
+const forecastSchema = z.object({
+  date: z.string(),
+  maxTemp: z.number(),
+  minTemp: z.number(),
+  precipitationChance: z.number(),
+  condition: z.string(),
+  location: z.string(),
+})
 
-const fetchWeather = new Step({
+function getWeatherCondition(code: number): string {
+  const conditions: Record<number, string> = {
+    0: 'Clear sky',
+    1: 'Mainly clear',
+    2: 'Partly cloudy',
+    3: 'Overcast',
+    45: 'Foggy',
+    48: 'Depositing rime fog',
+    51: 'Light drizzle',
+    53: 'Moderate drizzle',
+    55: 'Dense drizzle',
+    61: 'Slight rain',
+    63: 'Moderate rain',
+    65: 'Heavy rain',
+    71: 'Slight snow fall',
+    73: 'Moderate snow fall',
+    75: 'Heavy snow fall',
+    95: 'Thunderstorm',
+  }
+  return conditions[code] || 'Unknown'
+}
+
+const fetchWeather = createStep({
   id: 'fetch-weather',
   description: 'Fetches weather forecast for a given city',
   inputSchema: z.object({
     city: z.string().describe('The city to get the weather for'),
   }),
   outputSchema: forecastSchema,
-  execute: async ({ context }) => {
-    const triggerData = context?.getStepResult<{ city: string }>('trigger');
-
-    if (!triggerData) {
-      throw new Error('Trigger data not found');
+  execute: async ({ inputData }) => {
+    if (!inputData) {
+      throw new Error('Input data not found');
     }
 
-    const geocodingUrl = \`https://geocoding-api.open-meteo.com/v1/search?name=\${encodeURIComponent(triggerData.city)}&count=1\`;
+    const geocodingUrl = \`https://geocoding-api.open-meteo.com/v1/search?name=\${encodeURIComponent(inputData.city)}&count=1\`;
     const geocodingResponse = await fetch(geocodingUrl);
     const geocodingData = (await geocodingResponse.json()) as {
       results: { latitude: number; longitude: number; name: string }[];
     };
 
     if (!geocodingData.results?.[0]) {
-      throw new Error(\`Location '\${triggerData.city}' not found\`);
+      throw new Error(\`Location '\${inputData.city}' not found\`);
     }
 
     const { latitude, longitude, name } = geocodingData.results[0];
 
-    const weatherUrl = \`https://api.open-meteo.com/v1/forecast?latitude=\${latitude}&longitude=\${longitude}&daily=temperature_2m_max,temperature_2m_min,precipitation_probability_mean,weathercode&timezone=auto\`;
+    const weatherUrl = \`https://api.open-meteo.com/v1/forecast?latitude=\${latitude}&longitude=\${longitude}&current=precipitation,weathercode&timezone=auto,&hourly=precipitation_probability,temperature_2m\`;
     const response = await fetch(weatherUrl);
     const data = (await response.json()) as {
-      daily: {
-        time: string[];
-        temperature_2m_max: number[];
-        temperature_2m_min: number[];
-        precipitation_probability_mean: number[];
-        weathercode: number[];
-      };
-    };
+      current: {
+        time: string
+        precipitation: number
+        weathercode: number
+      }
+      hourly: {
+        precipitation_probability: number[]
+        temperature_2m: number[]
+      }
+    }
 
-    const forecast = data.daily.time.map((date: string, index: number) => ({
-      date,
-      maxTemp: data.daily.temperature_2m_max[index],
-      minTemp: data.daily.temperature_2m_min[index],
-      precipitationChance: data.daily.precipitation_probability_mean[index],
-      condition: getWeatherCondition(data.daily.weathercode[index]!),
-      location: name,
-    }));
+    const forecast = {
+      date: new Date().toISOString(),
+      maxTemp: Math.max(...data.hourly.temperature_2m),
+      minTemp: Math.min(...data.hourly.temperature_2m),
+      condition: getWeatherCondition(data.current.weathercode),
+      precipitationChance: data.hourly.precipitation_probability.reduce(
+        (acc, curr) => Math.max(acc, curr),
+        0
+      ),
+      location: name
+    }
 
     return forecast;
   },
 });
 
 
-const planActivities = new Step({
+const planActivities = createStep({
   id: 'plan-activities',
   description: 'Suggests activities based on weather conditions',
-  execute: async ({ context, mastra }) => {
-    const forecast = context?.getStepResult(fetchWeather);
+  inputSchema: forecastSchema,
+  outputSchema: z.object({
+    activities: z.string(),
+  }),
+  execute: async ({ inputData }) => {
+    const forecast = inputData
 
-    if (!forecast || forecast.length === 0) {
-      throw new Error('Forecast data not found');
+    if (!forecast) {
+      throw new Error('Forecast data not found')
     }
 
-    const prompt = \`Based on the following weather forecast for \${forecast[0]?.location}, suggest appropriate activities:
+    const prompt = \`Based on the following weather forecast for \${forecast.location}, suggest appropriate activities:
       \${JSON.stringify(forecast, null, 2)}
       \`;
 
@@ -1408,7 +1763,7 @@ const planActivities = new Step({
     ]);
 
     let activitiesText = '';
-    
+
     for await (const chunk of response.textStream) {
       process.stdout.write(chunk);
       activitiesText += chunk;
@@ -1420,35 +1775,16 @@ const planActivities = new Step({
   },
 });
 
-function getWeatherCondition(code: number): string {
-  const conditions: Record<number, string> = {
-    0: 'Clear sky',
-    1: 'Mainly clear',
-    2: 'Partly cloudy',
-    3: 'Overcast',
-    45: 'Foggy',
-    48: 'Depositing rime fog',
-    51: 'Light drizzle',
-    53: 'Moderate drizzle',
-    55: 'Dense drizzle',
-    61: 'Slight rain',
-    63: 'Moderate rain',
-    65: 'Heavy rain',
-    71: 'Slight snow fall',
-    73: 'Moderate snow fall',
-    75: 'Heavy snow fall',
-    95: 'Thunderstorm',
-  };
-  return conditions[code] || 'Unknown';
-}
-
-const weatherWorkflow = new Workflow({
-  name: 'weather-workflow',
-  triggerSchema: z.object({
+const weatherWorkflow = createWorkflow({
+  id: 'weather-workflow',
+  inputSchema: z.object({
     city: z.string().describe('The city to get the weather for'),
   }),
+  outputSchema: z.object({
+    activities: z.string(),
+  })
 })
-  .step(fetchWeather)
+  .then(fetchWeather)
   .then(planActivities);
 
 weatherWorkflow.commit();
@@ -1488,7 +1824,7 @@ var writeIndexFile = async ({
   addWorkflow
 }) => {
   const indexPath = dirPath + "/index.ts";
-  const destPath = path.join(indexPath);
+  const destPath = path2.join(indexPath);
   try {
     await fs4.writeFile(destPath, "");
     const filteredExports = [
@@ -1510,10 +1846,10 @@ export const mastra = new Mastra()
       destPath,
       `
 import { Mastra } from '@mastra/core/mastra';
-import { createLogger } from '@mastra/core/logger';
+import { PinoLogger } from '@mastra/loggers';
 import { LibSQLStore } from '@mastra/libsql';
-${addWorkflow ? `import { weatherWorkflow } from './workflows';` : ""}
-${addAgent ? `import { weatherAgent } from './agents';` : ""}
+${addWorkflow ? `import { weatherWorkflow } from './workflows/weather-workflow';` : ""}
+${addAgent ? `import { weatherAgent } from './agents/weather-agent';` : ""}
 
 export const mastra = new Mastra({
   ${filteredExports.join("\n  ")}
@@ -1521,7 +1857,7 @@ export const mastra = new Mastra({
     // stores telemetry, evals, ... into memory storage, if it needs to persist, change to file:../mastra.db
     url: ":memory:",
   }),
-  logger: createLogger({
+  logger: new PinoLogger({
     name: 'Mastra',
     level: 'info',
   }),
@@ -1557,11 +1893,13 @@ var writeAPIKey = async ({
   apiKey = "your-api-key"
 }) => {
   const key = await getAPIKey(provider);
-  await exec(`echo ${key}=${apiKey} >> .env.development`);
+  const escapedKey = shellQuote.quote([key]);
+  const escapedApiKey = shellQuote.quote([apiKey]);
+  await exec(`echo ${escapedKey}=${escapedApiKey} >> .env`);
 };
 var createMastraDir = async (directory) => {
   let dir = directory.trim().split("/").filter((item) => item !== "");
-  const dirPath = path.join(process.cwd(), ...dir, "mastra");
+  const dirPath = path2.join(process.cwd(), ...dir, "mastra");
   try {
     await fs4.access(dirPath);
     return { ok: false };
@@ -1571,7 +1909,7 @@ var createMastraDir = async (directory) => {
   }
 };
 var writeCodeSample = async (dirPath, component, llmProvider, importComponents) => {
-  const destPath = dirPath + `/${component}/index.ts`;
+  const destPath = dirPath + `/${component}/weather-${component.slice(0, -1)}.ts`;
   try {
     await writeCodeSampleForComponents(llmProvider, component, destPath, importComponents);
   } catch (err) {
@@ -1635,6 +1973,7 @@ var interactivePrompt = async () => {
       configureEditorWithDocsMCP: async () => {
         const windsurfIsAlreadyInstalled = await globalMCPIsAlreadyInstalled(`windsurf`);
         const cursorIsAlreadyInstalled = await globalMCPIsAlreadyInstalled(`cursor`);
+        const vscodeIsAlreadyInstalled = await globalMCPIsAlreadyInstalled(`vscode`);
         const editor = await le({
           message: `Make your AI IDE into a Mastra expert? (installs Mastra docs MCP server)`,
           options: [
@@ -1653,6 +1992,11 @@ var interactivePrompt = async () => {
               value: "windsurf",
               label: "Windsurf",
               hint: windsurfIsAlreadyInstalled ? `Already installed` : void 0
+            },
+            {
+              value: "vscode",
+              label: "VSCode",
+              hint: vscodeIsAlreadyInstalled ? `Already installed` : void 0
             }
           ]
         });
@@ -1662,6 +2006,11 @@ var interactivePrompt = async () => {
 Windsurf is already installed, skipping.`);
           return void 0;
         }
+        if (editor === `vscode` && vscodeIsAlreadyInstalled) {
+          v.message(`
+VSCode is already installed, skipping.`);
+          return void 0;
+        }
         if (editor === `cursor`) {
           v.message(
             `
@@ -1751,6 +2100,10 @@ var init = async ({
       if (needsMemory) {
         await depService.installPackages(["@mastra/memory"]);
       }
+      const needsLoggers = await depService.checkDependencies(["@mastra/loggers"]) !== `ok`;
+      if (needsLoggers) {
+        await depService.installPackages(["@mastra/loggers"]);
+      }
     }
     const key = await getAPIKey(llmProvider || "openai");
     const aiSdkPackage = getAISDKPackage(llmProvider);
@@ -1770,7 +2123,7 @@ var init = async ({
       ${color2.green("Mastra initialized successfully!")}
 
       Add your ${color2.cyan(key)} as an environment variable
-      in your ${color2.cyan(".env.development")} file
+      in your ${color2.cyan(".env")} file
       `);
     } else {
       me(`
@@ -1831,7 +2184,7 @@ var createMastraProject = async ({
   createVersionTag,
   timeout
 }) => {
-  pe(color2.inverse("Mastra Create"));
+  pe(color2.inverse(" Mastra Create "));
   const projectName = name ?? await ae({
     message: "What do you want to name your project?",
     placeholder: "my-mastra-app",
@@ -1860,10 +2213,12 @@ var createMastraProject = async ({
   s2.message("Creating project");
   await exec3(`npm init -y`);
   await exec3(`npm pkg set type="module"`);
+  await exec3(`npm pkg set engines.node=">=20.9.0"`);
   const depsService = new DepsService();
   await depsService.addScriptsToPackageJson({
     dev: "mastra dev",
-    build: "mastra build"
+    build: "mastra build",
+    start: "mastra start"
   });
   s2.stop("Project created");
   s2.start(`Installing ${pm} dependencies`);
@@ -1887,7 +2242,7 @@ var createMastraProject = async ({
 }' > tsconfig.json`);
   s2.stop(`${pm} dependencies installed`);
   s2.start("Installing mastra");
-  const versionTag = createVersionTag ? `@${createVersionTag}` : "@latest";
+  const versionTag = createVersionTag ? `@latest` : "@latest";
   await installMastraDependency(pm, "mastra", versionTag, true, timeout);
   s2.stop("mastra installed");
   s2.start("Installing dependencies");
@@ -1916,13 +2271,16 @@ var create = async (args2) => {
     timeout: args2?.timeout
   });
   const directory = args2.directory || "src/";
+  console.log("args", args2);
   if (args2.components === void 0 || args2.llmProvider === void 0 || args2.addExample === void 0) {
+    console.log("got to interactive prompt");
     const result = await interactivePrompt();
     await init({
       ...result,
       llmApiKey: result?.llmApiKey
     });
     postCreate({ projectName });
+    console.log("done with interactive prompt");
     return;
   }
   const { components = [], llmProvider = "openai", addExample = false, llmApiKey } = args2;
@@ -1931,23 +2289,25 @@ var create = async (args2) => {
     components,
     llmProvider,
     addExample,
-    llmApiKey
+    llmApiKey,
+    configureEditorWithDocsMCP: args2.mcpServer
   });
   postCreate({ projectName });
 };
 var postCreate = ({ projectName }) => {
+  const packageManager = getPackageManager();
   ge(`
    ${color2.green("To start your project:")}
 
     ${color2.cyan("cd")} ${projectName}
-    ${color2.cyan("npm run dev")}
+    ${color2.cyan(`${packageManager} run dev`)}
   `);
 };
 
 async function getPackageVersion() {
   const __filename = fileURLToPath(import.meta.url);
   const __dirname = dirname(__filename);
-  const pkgJsonPath = path.join(__dirname, "..", "package.json");
+  const pkgJsonPath = path2.join(__dirname, "..", "package.json");
   const content = await fsExtra.readJSON(pkgJsonPath);
   return content.version;
 }
@@ -1956,7 +2316,7 @@ async function getCreateVersionTag() {
     const pkgPath = fileURLToPath(import.meta.resolve("create-mastra/package.json"));
     const json = await fsExtra.readJSON(pkgPath);
     const { stdout } = await execa("npm", ["dist-tag", "create-mastra"]);
-    const tagLine = stdout.split("\n").find((distLine) => distLine.includes(`: ${json.version}`));
+    const tagLine = stdout.split("\n").find((distLine) => distLine.endsWith(`: ${json.version}`));
     const tag = tagLine ? tagLine.split(":")[0].trim() : "latest";
     return tag;
   } catch {
@@ -1985,16 +2345,18 @@ program.version(`${version}`, "-v, --version").description(`create-mastra ${vers
 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, no 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/)").action(async (projectNameArg, args) => {
+).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)").action(async (projectNameArg, args) => {
   const projectName = projectNameArg || args.projectName;
   const timeout = args?.timeout ? args?.timeout === true ? 6e4 : parseInt(args?.timeout, 10) : void 0;
   if (args.default) {
     await create({
       components: ["agents", "tools", "workflows"],
       llmProvider: "openai",
-      addExample: false,
+      addExample: true,
       createVersionTag,
-      timeout
+      timeout,
+      mcpServer: args.mcp,
+      directory: "src/"
     });
     return;
   }
@@ -2006,7 +2368,8 @@ program.name("create-mastra").description("Create a new Mastra project").argumen
     createVersionTag,
     timeout,
     projectName,
-    directory: args.dir
+    directory: args.dir,
+    mcpServer: args.mcp
   });
 });
 program.parse(process.argv);