mastra 0.2.0-alpha.158 → 0.2.0-alpha.159

package/dist/index.js

@@ -1,381 +0,0 @@
-#! /usr/bin/env node
-import { PosthogAnalytics } from './chunk-K5HPNH5H.js';
-export { PosthogAnalytics } from './chunk-K5HPNH5H.js';
-import { DepsService, create, checkPkgJson, checkAndInstallCoreDeps, interactivePrompt, init, FileService, logger } from './chunk-UU6XEV7T.js';
-export { create } from './chunk-UU6XEV7T.js';
-import { Command } from 'commander';
-import 'picocolors';
-import { join, dirname } from 'node:path';
-import { FileService as FileService$1, getWatcherInputOptions, createWatcher } from '@mastra/deployer/build';
-import { Bundler } from '@mastra/deployer/bundler';
-import * as fsExtra2 from 'fs-extra';
-import { readFileSync } from 'node:fs';
-import { fileURLToPath } from 'node:url';
-import { getDeployer, FileService as FileService$2 } from '@mastra/deployer';
-import { join as join$1 } from 'path';
-import { execa } from 'execa';
-import { MastraBundler } from '@mastra/core/bundler';
-import 'dotenv';
-
-var BuildBundler = class extends Bundler {
-  constructor() {
-    super("Build");
-  }
-  getEnvFiles() {
-    const possibleFiles = [".env.production", ".env"];
-    try {
-      const fileService = new FileService$1();
-      const envFile = fileService.getFirstExistingFile(possibleFiles);
-      return Promise.resolve([envFile]);
-    } catch (err) {
-    }
-    return Promise.resolve([]);
-  }
-  async prepare(outputDirectory) {
-    await super.prepare(outputDirectory);
-    const __filename = fileURLToPath(import.meta.url);
-    const __dirname = dirname(__filename);
-    const playgroundServePath = join(outputDirectory, this.outputDir, "playground");
-    await fsExtra2.copy(join(dirname(__dirname), "src/playground/dist"), playgroundServePath, {
-      overwrite: true
-    });
-  }
-  bundle(entryFile, outputDirectory) {
-    return this._bundle(this.getEntry(), entryFile, outputDirectory);
-  }
-  getEntry() {
-    const __filename = fileURLToPath(import.meta.url);
-    const __dirname = dirname(__filename);
-    return readFileSync(join(__dirname, "templates", "dev.entry.js"), "utf8");
-  }
-};
-
-// src/commands/build/build.ts
-async function build({ dir }) {
-  const mastraDir = dir ?? process.cwd();
-  const outputDirectory = join(mastraDir, ".mastra");
-  const deployer = new BuildBundler();
-  const fs = new FileService();
-  const mastraEntryFile = fs.getFirstExistingFile([
-    join(mastraDir, "src", "mastra", "index.ts"),
-    join(mastraDir, "src", "mastra", "index.js")
-  ]);
-  console.log(join(mastraDir, "index.ts"), join(mastraDir, "index.js"));
-  await deployer.prepare(outputDirectory);
-  await deployer.bundle(mastraEntryFile, outputDirectory);
-}
-async function deploy({ dir }) {
-  let mastraDir = dir || join$1(process.cwd(), "src/mastra");
-  try {
-    const outputDirectory = join$1(process.cwd(), ".mastra");
-    const fs = new FileService();
-    const mastraEntryFile = fs.getFirstExistingFile([join$1(mastraDir, "index.ts"), join$1(mastraDir, "index.js")]);
-    const deployer = await getDeployer(mastraEntryFile, outputDirectory);
-    if (!deployer) {
-      logger.warn("No deployer found.");
-      return;
-    }
-    try {
-      await deployer.prepare(outputDirectory);
-      await deployer.bundle(mastraEntryFile, outputDirectory);
-      try {
-        await deployer.deploy(outputDirectory);
-      } catch (error) {
-        console.error("[Mastra Deploy] - Error deploying:", error);
-      }
-    } catch (err) {
-      if (err instanceof Error) {
-        logger.debug(`error: ${err.message}`, { error: err });
-      }
-    }
-  } catch (error) {
-    if (error instanceof Error) {
-      logger.debug(`error: ${error.message}`, { error });
-    }
-    logger.warn("No deployer found.");
-  }
-}
-var DevBundler = class extends MastraBundler {
-  mastraDir;
-  constructor(mastraDir) {
-    super({
-      name: "Dev",
-      component: "BUNDLER"
-    });
-    this.mastraDir = mastraDir;
-  }
-  getEnvFiles() {
-    const possibleFiles = [".env.development", ".env"];
-    try {
-      const fileService = new FileService$2();
-      const envFile = fileService.getFirstExistingFile(possibleFiles);
-      return Promise.resolve([envFile]);
-    } catch (err) {
-    }
-    return Promise.resolve([]);
-  }
-  async writePackageJson() {
-  }
-  async prepare(outputDirectory) {
-    await fsExtra2.ensureDir(outputDirectory);
-    await fsExtra2.emptyDir(outputDirectory);
-    const __filename = fileURLToPath(import.meta.url);
-    const __dirname = dirname(__filename);
-    const playgroundServePath = join(outputDirectory, "playground");
-    await fsExtra2.copy(join(dirname(__dirname), "src/playground/dist"), playgroundServePath, {
-      overwrite: true
-    });
-  }
-  async watch(outputDirectory) {
-    const __filename = fileURLToPath(import.meta.url);
-    const __dirname = dirname(__filename);
-    const fileService = new FileService$2();
-    const entryFile = fileService.getFirstExistingFile([
-      join(this.mastraDir, "index.ts"),
-      join(this.mastraDir, "index.js")
-    ]);
-    const envFiles = await this.getEnvFiles();
-    const inputOptions = await getWatcherInputOptions(entryFile, "node");
-    const watcher = await createWatcher(
-      {
-        ...inputOptions,
-        plugins: [
-          // @ts-ignore - types are good
-          ...inputOptions.plugins,
-          {
-            name: "env-watcher",
-            buildStart() {
-              for (const envFile of envFiles) {
-                this.addWatchFile(envFile);
-              }
-            }
-          }
-        ],
-        input: {
-          index: join(__dirname, "templates", "dev.entry.js")
-        }
-      },
-      {
-        dir: outputDirectory
-      }
-    );
-    this.logger.info("Starting watcher...");
-    return new Promise((resolve, reject) => {
-      const cb = (event) => {
-        if (event.code === "BUNDLE_END") {
-          this.logger.info("Bundling finished, starting server...");
-          watcher.off("event", cb);
-          resolve(watcher);
-        }
-        if (event.code === "ERROR") {
-          console.log(event);
-          this.logger.error("Bundling failed, stopping watcher...");
-          watcher.off("event", cb);
-          reject(event);
-        }
-      };
-      watcher.on("event", cb);
-    });
-  }
-  async bundle() {
-  }
-};
-
-// src/commands/dev/dev.ts
-var currentServerProcess;
-var isRestarting = false;
-var startServer = async (dotMastraPath, port, env) => {
-  try {
-    logger.info("[Mastra Dev] - Starting server...");
-    currentServerProcess = execa("node", ["index.mjs"], {
-      cwd: dotMastraPath,
-      env: {
-        PORT: port.toString() || "4111",
-        ...Object.fromEntries(env)
-      },
-      stdio: "inherit",
-      reject: false
-    });
-    if (currentServerProcess?.exitCode && currentServerProcess?.exitCode !== 0) {
-      if (!currentServerProcess) {
-        throw new Error(`Server failed to start`);
-      }
-      throw new Error(`Server failed to start with error: ${currentServerProcess.stderr}`);
-    }
-    await new Promise((resolve) => setTimeout(resolve, 1e3));
-    try {
-      await fetch(`http://localhost:${port}/__refresh`, {
-        method: "POST",
-        headers: {
-          "Content-Type": "application/json"
-        }
-      });
-    } catch (err) {
-      await new Promise((resolve) => setTimeout(resolve, 1500));
-      try {
-        await fetch(`http://localhost:${port}/__refresh`, {
-          method: "POST",
-          headers: {
-            "Content-Type": "application/json"
-          }
-        });
-      } catch (retryErr) {
-      }
-    }
-    if (currentServerProcess.exitCode !== null) {
-      logger.error("Server failed to start with error:", { message: currentServerProcess.stderr });
-      return;
-    }
-  } catch (err) {
-    const execaError = err;
-    if (execaError.stderr) logger.error("Server error output:", { stderr: execaError.stderr });
-    if (execaError.stdout) logger.debug("Server output:", { stdout: execaError.stdout });
-  }
-};
-async function rebundleAndRestart(dotMastraPath, port, bundler) {
-  if (isRestarting) {
-    return;
-  }
-  isRestarting = true;
-  try {
-    if (currentServerProcess) {
-      logger.debug("Stopping current server...");
-      currentServerProcess.kill();
-      await new Promise((resolve) => setTimeout(resolve, 1e3));
-    }
-    const env = await bundler.loadEnvVars();
-    await startServer(dotMastraPath, port, env);
-  } finally {
-    isRestarting = false;
-  }
-}
-async function dev({ port, dir, root }) {
-  const rootDir = root || process.cwd();
-  const mastraDir = join$1(rootDir, dir || "src/mastra");
-  const dotMastraPath = join$1(rootDir, ".mastra");
-  const bundler = new DevBundler(mastraDir);
-  const env = await bundler.loadEnvVars();
-  await bundler.prepare(dotMastraPath);
-  const watcher = await bundler.watch(dotMastraPath);
-  await startServer(dotMastraPath, port, env);
-  watcher.on("event", (event) => {
-    if (event.code === "BUNDLE_END") {
-      logger.info("[Mastra Dev] - Bundling finished, restarting server...");
-      rebundleAndRestart(dotMastraPath, port, bundler);
-    }
-  });
-  process.on("SIGINT", () => {
-    logger.info("[Mastra Dev] - Stopping server...");
-    if (currentServerProcess) {
-      currentServerProcess.kill();
-    }
-    watcher.close();
-    process.exit(0);
-  });
-}
-
-// src/index.ts
-var depsService = new DepsService();
-var version = await depsService.getPackageVersion();
-var analytics = new PosthogAnalytics({
-  apiKey: "phc_SBLpZVAB6jmHOct9CABq3PF0Yn5FU3G2FgT4xUr2XrT",
-  host: "https://us.posthog.com",
-  version
-});
-var program = new Command();
-program.version(`${version}`, "-v, --version").description(`Mastra CLI ${version}`).action(() => {
-  try {
-    analytics.trackCommand({
-      command: "version"
-    });
-    console.log(`Mastra CLI: ${version}`);
-  } catch (e) {
-  }
-});
-program.command("create").description("Create a new Mastra project").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, or groq))").option("-k, --llm-api-key <api-key>", "API key for the model provider").option("-e, --example", "Include example code").action(async (args) => {
-  await analytics.trackCommandExecution({
-    command: "create",
-    args,
-    execution: async () => {
-      if (args.default) {
-        await create({
-          components: ["agents", "tools", "workflows"],
-          llmProvider: "openai",
-          addExample: false
-        });
-        return;
-      }
-      await create({
-        components: args.components ? args.components.split(",") : [],
-        llmProvider: args.llm,
-        addExample: args.example,
-        llmApiKey: args["llm-api-key"]
-      });
-    }
-  });
-});
-program.command("init").description("Initialize Mastra in your project").option("--default", "Quick start with defaults(src, OpenAI, no examples)").option("-d, --dir <directory>", "Directory for Mastra files to (defaults to src/)").option("-c, --components <components>", "Comma-separated list of components (agents, tools, workflows)").option("-l, --llm <model-provider>", "Default model provider (openai, anthropic, or groq))").option("-k, --llm-api-key <api-key>", "API key for the model provider").option("-e, --example", "Include example code").action(async (args) => {
-  await analytics.trackCommandExecution({
-    command: "init",
-    args,
-    execution: async () => {
-      await checkPkgJson();
-      await checkAndInstallCoreDeps();
-      if (!Object.keys(args).length) {
-        const result = await interactivePrompt();
-        await init({
-          ...result,
-          llmApiKey: result?.llmApiKey
-        });
-        return;
-      }
-      if (args?.default) {
-        init({
-          directory: "src/",
-          components: ["agents", "tools", "workflows"],
-          llmProvider: "openai",
-          addExample: false
-        });
-        return;
-      }
-      const componentsArr = args.components ? args.components.split(",") : [];
-      init({
-        directory: args.dir,
-        components: componentsArr,
-        llmProvider: args.llm,
-        addExample: args.example,
-        llmApiKey: args["llm-api-key"]
-      });
-      return;
-    }
-  });
-});
-program.command("dev").description("Start mastra server").option("-d, --dir <dir>", "Path to your mastra folder").option("-r, --root <root>", "Path to your root folder").option("-e, --env <env>", "Environment File to use (defaults to .env.development)").option("-t, --tools <toolsDirs>", "Comma-separated list of paths to tool files to include").option("-p, --port <port>", "Port number for the development server (defaults to 4111)").action((args) => {
-  analytics.trackCommand({
-    command: "dev"
-  });
-  dev({
-    port: args?.port ? parseInt(args.port) : 4111,
-    dir: args?.dir,
-    root: args?.root
-  });
-});
-program.command("build").description("Build your Mastra project").option("-d, --dir <path>", "Path to directory").action(async (args) => {
-  await analytics.trackCommandExecution({
-    command: "mastra build",
-    args,
-    execution: async () => {
-      await build({ dir: args.dir });
-    }
-  });
-});
-program.command("deploy").description("Deploy your Mastra project").option("-d, --dir <path>", "Path to directory").action(async (args) => {
-  await analytics.trackCommandExecution({
-    command: "mastra deploy",
-    args,
-    execution: async () => {
-      await deploy({ dir: args.dir });
-    }
-  });
-});
-program.parse(process.argv);

package/dist/starter-files/config.ts

@@ -1,28 +0,0 @@
-// @ts-ignore
-import { Config } from '@mastra/core';
-
-export const config: Config = {
-  name: 'PROJECT_NAME',
-  integrations: [],
-  db: {
-    provider: 'postgres',
-    uri: process.env.DB_URL!,
-  },
-  runner: {
-    provider: 'inngest',
-    uri: process.env.INNGEST_URL!,
-    signingKey: process.env.INNGEST_SIGNING_KEY!,
-    eventKey: process.env.INNGEST_EVENT_KEY!,
-  },
-  workflows: {
-    blueprintDirPath: '/mastra/blueprints',
-    systemEvents: {},
-    systemApis: [],
-  },
-  agents: {
-    agentDirPath: '/mastra/agents',
-    vectorProvider: [],
-  },
-  systemHostURL: process.env.APP_URL!,
-  routeRegistrationPath: '/api/mastra',
-};

package/dist/starter-files/mastra-pg.docker-compose.yaml

@@ -1,15 +0,0 @@
-services:
-  db:
-    image: pgvector/pgvector:pg16
-    container_name: 'REPLACE_PROJECT_NAME-db'
-    ports:
-      - 'REPLACE_DB_PORT:5432'
-    environment:
-      POSTGRES_USER: ${POSTGRES_USER:-postgres}
-      POSTGRES_PASSWORD: ${POSTGRES_PASSWORD:-postgres}
-      POSTGRES_DB: ${POSTGRES_DB:-mastra}
-    volumes:
-      - pgdata:/var/lib/postgresql/data
-
-volumes:
-  pgdata:

package/dist/starter-files/tools.ts

@@ -1,95 +0,0 @@
-import { createTool } from '@mastra/core/tools';
-import { z } from 'zod';
-
-interface WeatherResponse {
-  current: {
-    time: string;
-    temperature_2m: number;
-    apparent_temperature: number;
-    relative_humidity_2m: number;
-    wind_speed_10m: number;
-    wind_gusts_10m: number;
-    weather_code: number;
-  };
-}
-
-export const weatherTool = createTool({
-  id: 'get-weather',
-  description: 'Get current weather for a location',
-  inputSchema: z.object({
-    location: z.string().describe('City name'),
-  }),
-  outputSchema: z.object({
-    temperature: z.number(),
-    feelsLike: z.number(),
-    humidity: z.number(),
-    windSpeed: z.number(),
-    windGust: z.number(),
-    conditions: z.string(),
-    location: z.string(),
-  }),
-  execute: async ({ context }) => {
-    return await getWeather(context.location);
-  },
-});
-
-const getWeather = async (location: string) => {
-  const geocodingUrl = `https://geocoding-api.open-meteo.com/v1/search?name=${encodeURIComponent(location)}&count=1`;
-  const geocodingResponse = await fetch(geocodingUrl);
-  const geocodingData = await geocodingResponse.json();
-
-  if (!geocodingData.results?.[0]) {
-    throw new Error(`Location '${location}' not found`);
-  }
-
-  const { latitude, longitude, name } = geocodingData.results[0];
-
-  const weatherUrl = `https://api.open-meteo.com/v1/forecast?latitude=${latitude}&longitude=${longitude}&current=temperature_2m,apparent_temperature,relative_humidity_2m,wind_speed_10m,wind_gusts_10m,weather_code`;
-
-  const response = await fetch(weatherUrl);
-  const data: WeatherResponse = await response.json();
-
-  return {
-    temperature: data.current.temperature_2m,
-    feelsLike: data.current.apparent_temperature,
-    humidity: data.current.relative_humidity_2m,
-    windSpeed: data.current.wind_speed_10m,
-    windGust: data.current.wind_gusts_10m,
-    conditions: getWeatherCondition(data.current.weather_code),
-    location: name,
-  };
-};
-
-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',
-    56: 'Light freezing drizzle',
-    57: 'Dense freezing drizzle',
-    61: 'Slight rain',
-    63: 'Moderate rain',
-    65: 'Heavy rain',
-    66: 'Light freezing rain',
-    67: 'Heavy freezing rain',
-    71: 'Slight snow fall',
-    73: 'Moderate snow fall',
-    75: 'Heavy snow fall',
-    77: 'Snow grains',
-    80: 'Slight rain showers',
-    81: 'Moderate rain showers',
-    82: 'Violent rain showers',
-    85: 'Slight snow showers',
-    86: 'Heavy snow showers',
-    95: 'Thunderstorm',
-    96: 'Thunderstorm with slight hail',
-    99: 'Thunderstorm with heavy hail',
-  };
-  return conditions[code] || 'Unknown';
-}

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) {
-      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 };