mastra 0.2.2-alpha.0 → 0.2.3-alpha.0

package/dist/{chunk-NOF26LQY.js → chunk-F6RK2UOG.js}

@@ -14,6 +14,31 @@ import { fileURLToPath } from 'url';
 import { createLogger } from '@mastra/core/logger';
 
 // src/commands/create/create.ts
+
+// src/commands/utils.ts
+function getPackageManager() {
+  const userAgent = process.env.npm_config_user_agent || "";
+  const execPath = process.env.npm_execpath || "";
+  if (userAgent.includes("yarn")) {
+    return "yarn";
+  }
+  if (userAgent.includes("pnpm")) {
+    return "pnpm";
+  }
+  if (userAgent.includes("npm")) {
+    return "npm";
+  }
+  if (execPath.includes("yarn")) {
+    return "yarn";
+  }
+  if (execPath.includes("pnpm")) {
+    return "pnpm";
+  }
+  if (execPath.includes("npm")) {
+    return "npm";
+  }
+  return "npm";
+}
 var DepsService = class {
   packageManager;
   constructor() {
@@ -238,7 +263,7 @@ var getAISDKPackage = (llmProvider) => {
       return "@ai-sdk/openai";
   }
 };
-async function writeAgentSample(llmProvider, destPath, addExampleTool) {
+var getProviderImportAndModelItem = (llmProvider) => {
   let providerImport = "";
   let modelItem = "";
   if (llmProvider === "openai") {
@@ -251,6 +276,10 @@ async function writeAgentSample(llmProvider, destPath, addExampleTool) {
     providerImport = `import { groq } from '${getAISDKPackage(llmProvider)}';`;
     modelItem = `groq('llama3-groq-70b-8192-tool-use-preview')`;
   }
+  return { providerImport, modelItem };
+};
+async function writeAgentSample(llmProvider, destPath, addExampleTool) {
+  const { providerImport, modelItem } = getProviderImportAndModelItem(llmProvider);
   const instructions = `
       You are a helpful weather assistant that provides accurate weather information.
 
@@ -281,9 +310,196 @@ export const weatherAgent = new Agent({
   await fs4.writeFile(destPath, "");
   await fs4.writeFile(destPath, formattedContent);
 }
-async function writeWorkflowSample(destPath) {
-  const fileService = new FileService();
-  await fileService.copyStarterFile("workflow.ts", destPath);
+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 { z } from 'zod';
+
+const llm = ${modelItem};
+
+const agent = new Agent({
+  name: 'Weather Agent',
+  model: llm,
+  instructions: \`
+        You are a local activities and travel expert who excels at weather-based planning. Analyze the weather data and provide practical activity recommendations.
+
+        For each day in the forecast, structure your response exactly as follows:
+
+        \u{1F4C5} [Day, Month Date, Year]
+        \u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550
+
+        \u{1F321}\uFE0F WEATHER SUMMARY
+        \u2022 Conditions: [brief description]
+        \u2022 Temperature: [X\xB0C/Y\xB0F to A\xB0C/B\xB0F]
+        \u2022 Precipitation: [X% chance]
+
+        \u{1F305} MORNING ACTIVITIES
+        Outdoor:
+        \u2022 [Activity Name] - [Brief description including specific location/route]
+          Best timing: [specific time range]
+          Note: [relevant weather consideration]
+
+        \u{1F31E} AFTERNOON ACTIVITIES
+        Outdoor:
+        \u2022 [Activity Name] - [Brief description including specific location/route]
+          Best timing: [specific time range]
+          Note: [relevant weather consideration]
+
+        \u{1F3E0} INDOOR ALTERNATIVES
+        \u2022 [Activity Name] - [Brief description including specific venue]
+          Ideal for: [weather condition that would trigger this alternative]
+
+        \u26A0\uFE0F SPECIAL CONSIDERATIONS
+        \u2022 [Any relevant weather warnings, UV index, wind conditions, etc.]
+
+        Guidelines:
+        - Suggest 2-3 time-specific outdoor activities per day
+        - Include 1-2 indoor backup options
+        - For precipitation >50%, lead with indoor activities
+        - All activities must be specific to the location
+        - Include specific venues, trails, or locations
+        - Consider activity intensity based on temperature
+        - Keep descriptions concise but informative
+
+        Maintain this exact formatting for consistency, using the emoji and section headers as shown.
+      \`,
+});
+
+const fetchWeather = new Step({
+  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'),
+  }),
+  execute: async ({ context }) => {
+    const triggerData = context?.getStepPayload<{ city: string }>('trigger');
+
+    if (!triggerData) {
+      throw new Error('Trigger data not found');
+    }
+
+    const geocodingUrl = \`https://geocoding-api.open-meteo.com/v1/search?name=\${encodeURIComponent(triggerData.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\`);
+    }
+
+    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 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[];
+      };
+    };
+
+    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,
+    }));
+
+    return forecast;
+  },
+});
+
+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 planActivities = new Step({
+  id: 'plan-activities',
+  description: 'Suggests activities based on weather conditions',
+  inputSchema: forecastSchema,
+  execute: async ({ context, mastra }) => {
+    const forecast = context?.getStepPayload<z.infer<typeof forecastSchema>>('fetch-weather');
+
+    if (!forecast || forecast.length === 0) {
+      throw new Error('Forecast data not found');
+    }
+
+    const prompt = \`Based on the following weather forecast for \${forecast[0]?.location}, suggest appropriate activities:
+      \${JSON.stringify(forecast, null, 2)}
+      \`;
+
+    const response = await agent.stream([
+      {
+        role: 'user',
+        content: prompt,
+      },
+    ]);
+
+    for await (const chunk of response.textStream) {
+      process.stdout.write(chunk);
+    }
+
+    return {
+      activities: response.text,
+    };
+  },
+});
+
+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({
+    city: z.string().describe('The city to get the weather for'),
+  }),
+})
+  .step(fetchWeather)
+  .then(planActivities);
+
+weatherWorkflow.commit();
+
+export { weatherWorkflow };`;
+  const formattedContent = await prettier.format(content, {
+    parser: "typescript",
+    semi: true,
+    singleQuote: true
+  });
+  await fs4.writeFile(destPath, formattedContent);
 }
 async function writeToolSample(destPath) {
   const fileService = new FileService();
@@ -296,7 +512,7 @@ async function writeCodeSampleForComponents(llmprovider, component, destPath, im
     case "tools":
       return writeToolSample(destPath);
     case "workflows":
-      return writeWorkflowSample(destPath);
+      return writeWorkflowSample(destPath, llmprovider);
     default:
       return "";
   }
@@ -538,7 +754,7 @@ var init = async ({
     }
     const key = await getAPIKey(llmProvider || "openai");
     const aiSdkPackage = getAISDKPackage(llmProvider);
-    await exec2(`npm i ${aiSdkPackage}`);
+    await exec2(`${getPackageManager()} i ${aiSdkPackage}`);
     s.stop();
     if (!llmApiKey) {
       p.note(`
@@ -583,15 +799,6 @@ var execWithTimeout = async (command, timeoutMs = 18e4) => {
     throw error;
   }
 };
-function getPackageManager() {
-  const userAgent = process.env.npm_config_user_agent || `npm`;
-  if (userAgent.includes(`pnpm/`)) {
-    return `pnpm`;
-  } else if (userAgent.includes(`yarn/`)) {
-    return `yarn`;
-  }
-  return `npm`;
-}
 var createMastraProject = async () => {
   p.intro(color2.inverse("Mastra Create"));
   const projectName = await p.text({

package/dist/commands/create/create.js

@@ -1 +1 @@
-export { create } from '../../chunk-NOF26LQY.js';
+export { create } from '../../chunk-F6RK2UOG.js';

package/dist/index.js

@@ -1,8 +1,8 @@
 #! /usr/bin/env node
 import { PosthogAnalytics } from './chunk-DHTLEROT.js';
 export { PosthogAnalytics } from './chunk-DHTLEROT.js';
-import { DepsService, create, checkPkgJson, checkAndInstallCoreDeps, interactivePrompt, init, logger, FileService as FileService$1 } from './chunk-NOF26LQY.js';
-export { create } from './chunk-NOF26LQY.js';
+import { DepsService, create, checkPkgJson, checkAndInstallCoreDeps, interactivePrompt, init, logger, FileService as FileService$1 } from './chunk-F6RK2UOG.js';
+export { create } from './chunk-F6RK2UOG.js';
 import { Command } from 'commander';
 import 'picocolors';
 import { join as join$1, dirname } from 'node:path';

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "mastra",
-  "version": "0.2.2-alpha.0",
+  "version": "0.2.3-alpha.0",
   "license": "MIT",
   "description": "cli for mastra",
   "type": "module",
@@ -59,7 +59,6 @@
     "@mastra/core": "^0.2.1"
   },
   "devDependencies": {
-    "@ai-sdk/openai": "^1.1.9",
     "@microsoft/api-extractor": "^7.49.2",
     "@types/express": "^5.0.0",
     "@types/fs-extra": "^11.0.4",

package/dist/starter-files/workflow.ts

@@ -1,182 +0,0 @@
-import { openai } from '@ai-sdk/openai';
-import { Agent } from '@mastra/core/agent';
-import { Step, Workflow } from '@mastra/core/workflows';
-import { z } from 'zod';
-
-const llm = openai('gpt-4o');
-
-const agent = new Agent({
-  name: 'Weather Agent',
-  model: llm,
-  instructions: `
-        You are a local activities and travel expert who excels at weather-based planning. Analyze the weather data and provide practical activity recommendations.
-
-        For each day in the forecast, structure your response exactly as follows:
-
-        📅 [Day, Month Date, Year]
-        ═══════════════════════════
-
-        🌡️ WEATHER SUMMARY
-        • Conditions: [brief description]
-        • Temperature: [X°C/Y°F to A°C/B°F]
-        • Precipitation: [X% chance]
-
-        🌅 MORNING ACTIVITIES
-        Outdoor:
-        • [Activity Name] - [Brief description including specific location/route]
-          Best timing: [specific time range]
-          Note: [relevant weather consideration]
-
-        🌞 AFTERNOON ACTIVITIES
-        Outdoor:
-        • [Activity Name] - [Brief description including specific location/route]
-          Best timing: [specific time range]
-          Note: [relevant weather consideration]
-
-        🏠 INDOOR ALTERNATIVES
-        • [Activity Name] - [Brief description including specific venue]
-          Ideal for: [weather condition that would trigger this alternative]
-
-        ⚠️ SPECIAL CONSIDERATIONS
-        • [Any relevant weather warnings, UV index, wind conditions, etc.]
-
-        Guidelines:
-        - Suggest 2-3 time-specific outdoor activities per day
-        - Include 1-2 indoor backup options
-        - For precipitation >50%, lead with indoor activities
-        - All activities must be specific to the location
-        - Include specific venues, trails, or locations
-        - Consider activity intensity based on temperature
-        - Keep descriptions concise but informative
-
-        Maintain this exact formatting for consistency, using the emoji and section headers as shown.
-      `,
-});
-
-const fetchWeather = new Step({
-  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'),
-  }),
-  execute: async ({ context }) => {
-    const triggerData = context?.getStepPayload<{ city: string }>('trigger');
-
-    if (!triggerData) {
-      throw new Error('Trigger data not found');
-    }
-
-    const geocodingUrl = `https://geocoding-api.open-meteo.com/v1/search?name=${encodeURIComponent(triggerData.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`);
-    }
-
-    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 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[];
-      };
-    };
-
-    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,
-    }));
-
-    return forecast;
-  },
-});
-
-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 planActivities = new Step({
-  id: 'plan-activities',
-  description: 'Suggests activities based on weather conditions',
-  inputSchema: forecastSchema,
-  execute: async ({ context, mastra }) => {
-    const forecast = context?.getStepPayload<z.infer<typeof forecastSchema>>('fetch-weather');
-
-    if (!forecast || forecast.length === 0) {
-      throw new Error('Forecast data not found');
-    }
-
-    const prompt = `Based on the following weather forecast for ${forecast[0]?.location}, suggest appropriate activities:
-      ${JSON.stringify(forecast, null, 2)}
-      `;
-
-    const response = await agent.stream([
-      {
-        role: 'user',
-        content: prompt,
-      },
-    ]);
-
-    for await (const chunk of response.textStream) {
-      process.stdout.write(chunk);
-    }
-
-    return {
-      activities: response.text,
-    };
-  },
-});
-
-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({
-    city: z.string().describe('The city to get the weather for'),
-  }),
-})
-  .step(fetchWeather)
-  .then(planActivities);
-
-weatherWorkflow.commit();
-
-export { weatherWorkflow };