mastra 0.2.0-alpha.159 → 0.2.0-alpha.160

package/dist/chunk-UU6XEV7T.js

@@ -0,0 +1,672 @@
+import * as p from '@clack/prompts';
+import color2 from 'picocolors';
+import child_process from 'node:child_process';
+import util from 'node:util';
+import path, { dirname } from 'path';
+import prettier from 'prettier';
+import yoctoSpinner from 'yocto-spinner';
+import fsExtra3 from 'fs-extra/esm';
+import fs4 from 'fs/promises';
+import { execa } from 'execa';
+import * as fs3 from 'fs';
+import fs3__default from 'fs';
+import { fileURLToPath } from 'url';
+import { createLogger } from '@mastra/core/logger';
+
+// src/commands/create/create.ts
+var DepsService = class {
+  packageManager;
+  constructor() {
+    this.packageManager = this.getPackageManager();
+  }
+  findLockFile(dir) {
+    const lockFiles = ["pnpm-lock.yaml", "package-lock.json", "yarn.lock", "bun.lock"];
+    for (const file of lockFiles) {
+      if (fs3__default.existsSync(path.join(dir, file))) {
+        return file;
+      }
+    }
+    const parentDir = path.resolve(dir, "..");
+    if (parentDir !== dir) {
+      return this.findLockFile(parentDir);
+    }
+    return null;
+  }
+  getPackageManager() {
+    const lockFile = this.findLockFile(process.cwd());
+    switch (lockFile) {
+      case "pnpm-lock.yaml":
+        return "pnpm";
+      case "package-lock.json":
+        return "npm";
+      case "yarn.lock":
+        return "yarn";
+      case "bun.lock":
+        return "bun";
+      default:
+        return "npm";
+    }
+  }
+  async installPackages(packages) {
+    let runCommand = this.packageManager;
+    if (this.packageManager === "npm") {
+      runCommand = `${this.packageManager} i`;
+    } else {
+      runCommand = `${this.packageManager} add`;
+    }
+    const packageList = packages.join(" ");
+    return execa(`${runCommand} ${packageList}`, {
+      all: true,
+      shell: true,
+      stdio: "inherit"
+    });
+  }
+  async checkDependencies(dependencies) {
+    try {
+      const packageJsonPath = path.join(process.cwd(), "package.json");
+      try {
+        await fs4.access(packageJsonPath);
+      } catch {
+        return "No package.json file found in the current directory";
+      }
+      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})`;
+        }
+      }
+      return "ok";
+    } catch (err) {
+      console.error(err);
+      return "Could not check dependencies";
+    }
+  }
+  async getProjectName() {
+    try {
+      const packageJsonPath = path.join(process.cwd(), "package.json");
+      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 = path.join(__dirname, "..", "package.json");
+    const content = await fsExtra3.readJSON(pkgJsonPath);
+    return content.version;
+  }
+  async addScriptsToPackageJson(scripts) {
+    const packageJson = JSON.parse(await fs4.readFile("package.json", "utf-8"));
+    packageJson.scripts = {
+      ...packageJson.scripts,
+      ...scripts
+    };
+    await fs4.writeFile("package.json", JSON.stringify(packageJson, null, 2));
+  }
+};
+
+// src/services/service.env.ts
+var EnvService = class {
+};
+
+// src/services/service.fileEnv.ts
+var FileEnvService = class extends EnvService {
+  filePath;
+  constructor(filePath) {
+    super();
+    this.filePath = filePath;
+  }
+  readFile(filePath) {
+    return new Promise((resolve, reject) => {
+      fs3.readFile(filePath, "utf8", (err, data) => {
+        if (err) reject(err);
+        else resolve(data);
+      });
+    });
+  }
+  writeFile({ filePath, data }) {
+    return new Promise((resolve, reject) => {
+      fs3.writeFile(filePath, data, "utf8", (err) => {
+        if (err) reject(err);
+        else resolve();
+      });
+    });
+  }
+  async updateEnvData({
+    key,
+    value,
+    filePath = this.filePath,
+    data
+  }) {
+    const regex = new RegExp(`^${key}=.*$`, "m");
+    if (data.match(regex)) {
+      data = data.replace(regex, `${key}=${value}`);
+    } else {
+      data += `
+${key}=${value}`;
+    }
+    await this.writeFile({ filePath, data });
+    console.log(`${key} set to ${value} in ENV file.`);
+    return data;
+  }
+  async getEnvValue(key) {
+    try {
+      const data = await this.readFile(this.filePath);
+      const regex = new RegExp(`^${key}=(.*)$`, "m");
+      const match = data.match(regex);
+      return match?.[1] || null;
+    } catch (err) {
+      console.error(`Error reading ENV value: ${err}`);
+      return null;
+    }
+  }
+  async setEnvValue(key, value) {
+    try {
+      const data = await this.readFile(this.filePath);
+      await this.updateEnvData({ key, value, data });
+    } catch (err) {
+      console.error(`Error writing ENV value: ${err}`);
+    }
+  }
+};
+
+// src/services/service.file.ts
+var FileService = class {
+  /**
+   *
+   * @param inputFile the file in the starter files directory to copy
+   * @param outputFilePath the destination path
+   * @param replaceIfExists flag to replace if it exists
+   * @returns
+   */
+  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 fileString = fs3__default.readFileSync(filePath, "utf8");
+    if (fs3__default.existsSync(outputFilePath) && !replaceIfExists) {
+      console.log(`${outputFilePath} already exists`);
+      return false;
+    }
+    await fsExtra3.outputFile(outputFilePath, fileString);
+    return true;
+  }
+  async setupEnvFile({ dbUrl }) {
+    const envPath = path.join(process.cwd(), ".env.development");
+    await fsExtra3.ensureFile(envPath);
+    const fileEnvService = new FileEnvService(envPath);
+    await fileEnvService.setEnvValue("DB_URL", dbUrl);
+  }
+  getFirstExistingFile(files) {
+    for (const f of files) {
+      if (fs3__default.existsSync(f)) {
+        return f;
+      }
+    }
+    throw new Error("Missing required file, checked the following paths: " + files.join(", "));
+  }
+  replaceValuesInFile({
+    filePath,
+    replacements
+  }) {
+    let fileContent = fs3__default.readFileSync(filePath, "utf8");
+    replacements.forEach(({ search, replace }) => {
+      fileContent = fileContent.replaceAll(search, replace);
+    });
+    fs3__default.writeFileSync(filePath, fileContent);
+  }
+};
+var logger = createLogger({
+  name: "Mastra CLI",
+  level: "debug"
+});
+
+// src/commands/init/utils.ts
+var exec = util.promisify(child_process.exec);
+var getAISDKPackage = (llmProvider) => {
+  switch (llmProvider) {
+    case "openai":
+      return "@ai-sdk/openai";
+    case "anthropic":
+      return "@ai-sdk/anthropic";
+    case "groq":
+      return "@ai-sdk/groq";
+    default:
+      return "@ai-sdk/openai";
+  }
+};
+async function writeAgentSample(llmProvider, destPath, addExampleTool) {
+  let providerImport = "";
+  let modelItem = "";
+  if (llmProvider === "openai") {
+    providerImport = `import { openai } from '${getAISDKPackage(llmProvider)}';`;
+    modelItem = `openai('gpt-4o')`;
+  } else if (llmProvider === "anthropic") {
+    providerImport = `import { anthropic } from '${getAISDKPackage(llmProvider)}';`;
+    modelItem = `anthropic('claude-3-5-sonnet-20241022')`;
+  } else if (llmProvider === "groq") {
+    providerImport = `import { groq } from '${getAISDKPackage(llmProvider)}';`;
+    modelItem = `groq('llama3-groq-70b-8192-tool-use-preview')`;
+  }
+  const instructions = `
+      You are a helpful weather assistant that provides accurate weather information.
+
+      Your primary function is to help users get weather details for specific locations. When responding:
+      - Always ask for a location if none is provided
+      - If giving a location with multiple parts (e.g. "New York, NY"), use the most relevant part (e.g. "New York")
+      - Include relevant details like humidity, wind conditions, and precipitation
+      - Keep responses concise but informative
+
+      ${addExampleTool ? "Use the weatherTool to fetch current weather data." : ""}
+`;
+  const content = `
+${providerImport}  
+import { Agent } from '@mastra/core/agent';
+${addExampleTool ? `import { weatherTool } from '../tools';` : ""}
+
+export const weatherAgent = new Agent({
+  name: 'Weather Agent',
+  instructions: \`${instructions}\`,
+  model: ${modelItem},
+  ${addExampleTool ? "tools: { weatherTool }," : ""}
+});
+    `;
+  const formattedContent = await prettier.format(content, {
+    parser: "typescript",
+    singleQuote: true
+  });
+  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 writeToolSample(destPath) {
+  const fileService = new FileService();
+  await fileService.copyStarterFile("tools.ts", destPath);
+}
+async function writeCodeSampleForComponents(llmprovider, component, destPath, importComponents) {
+  switch (component) {
+    case "agents":
+      return writeAgentSample(llmprovider, destPath, importComponents.includes("tools"));
+    case "tools":
+      return writeToolSample(destPath);
+    case "workflows":
+      return writeWorkflowSample(destPath);
+    default:
+      return "";
+  }
+}
+var createComponentsDir = async (dirPath, component) => {
+  const componentPath = dirPath + `/${component}`;
+  await fsExtra3.ensureDir(componentPath);
+};
+var writeIndexFile = async ({
+  dirPath,
+  addAgent,
+  addExample,
+  addWorkflow
+}) => {
+  const indexPath = dirPath + "/index.ts";
+  const destPath = path.join(indexPath);
+  try {
+    await fs4.writeFile(destPath, "");
+    const filteredExports = [
+      addWorkflow ? `workflows: { weatherWorkflow },` : "",
+      addAgent ? `agents: { weatherAgent },` : ""
+    ].filter(Boolean);
+    if (!addExample) {
+      await fs4.writeFile(
+        destPath,
+        `
+import { Mastra } from '@mastra/core';
+
+export const mastra = new Mastra()
+        `
+      );
+      return;
+    }
+    await fs4.writeFile(
+      destPath,
+      `
+import { Mastra } from '@mastra/core/mastra';
+import { createLogger } from '@mastra/core/logger';
+${addWorkflow ? `import { weatherWorkflow } from './workflows';` : ""}
+${addAgent ? `import { weatherAgent } from './agents';` : ""}
+
+export const mastra = new Mastra({
+  ${filteredExports.join("\n  ")}
+  logger: createLogger({
+    name: 'Mastra',
+    level: 'info',
+  }),
+});
+`
+    );
+  } catch (err) {
+    throw err;
+  }
+};
+var checkAndInstallCoreDeps = async () => {
+  const depsService = new DepsService();
+  const depCheck = await depsService.checkDependencies(["@mastra/core"]);
+  if (depCheck !== "ok") {
+    await installCoreDeps();
+  }
+};
+var spinner = yoctoSpinner({ text: "Installing Mastra core dependencies\n" });
+async function installCoreDeps() {
+  try {
+    const confirm2 = await p.confirm({
+      message: "You do not have the @mastra/core package installed. Would you like to install it?",
+      initialValue: false
+    });
+    if (p.isCancel(confirm2)) {
+      p.cancel("Installation Cancelled");
+      process.exit(0);
+    }
+    if (!confirm2) {
+      p.cancel("Installation Cancelled");
+      process.exit(0);
+    }
+    spinner.start();
+    const depsService = new DepsService();
+    await depsService.installPackages(["@mastra/core@alpha"]);
+    spinner.success("@mastra/core installed successfully");
+  } catch (err) {
+    console.error(err);
+  }
+}
+var getAPIKey = async (provider) => {
+  let key = "OPENAI_API_KEY";
+  switch (provider) {
+    case "anthropic":
+      key = "ANTHROPIC_API_KEY";
+      return key;
+    case "groq":
+      key = "GROQ_API_KEY";
+      return key;
+    default:
+      return key;
+  }
+};
+var writeAPIKey = async ({
+  provider,
+  apiKey = "your-api-key"
+}) => {
+  const key = await getAPIKey(provider);
+  await exec(`echo ${key}=${apiKey} >> .env.development`);
+};
+var createMastraDir = async (directory) => {
+  let dir = directory.trim().split("/").filter((item) => item !== "");
+  const dirPath = path.join(process.cwd(), ...dir, "mastra");
+  try {
+    await fs4.access(dirPath);
+    return { ok: false };
+  } catch {
+    await fsExtra3.ensureDir(dirPath);
+    return { ok: true, dirPath };
+  }
+};
+var writeCodeSample = async (dirPath, component, llmProvider, importComponents) => {
+  const destPath = dirPath + `/${component}/index.ts`;
+  try {
+    await writeCodeSampleForComponents(llmProvider, component, destPath, importComponents);
+  } catch (err) {
+    throw err;
+  }
+};
+var interactivePrompt = async () => {
+  p.intro(color2.inverse("Mastra Init"));
+  const mastraProject = await p.group(
+    {
+      directory: () => p.text({
+        message: "Where should we create the Mastra files? (default: src/)",
+        placeholder: "src/",
+        defaultValue: "src/"
+      }),
+      components: () => p.multiselect({
+        message: "Choose components to install:",
+        options: [
+          { value: "agents", label: "Agents", hint: "recommended" },
+          {
+            value: "workflows",
+            label: "Workflows"
+          }
+        ]
+      }),
+      shouldAddTools: () => p.confirm({
+        message: "Add tools?",
+        initialValue: false
+      }),
+      llmProvider: () => p.select({
+        message: "Select default provider:",
+        options: [
+          { value: "openai", label: "OpenAI", hint: "recommended" },
+          { value: "anthropic", label: "Anthropic" },
+          { value: "groq", label: "Groq" }
+        ]
+      }),
+      llmApiKey: async ({ results: { llmProvider } }) => {
+        const keyChoice = await p.select({
+          message: `Enter your ${llmProvider} API key?`,
+          options: [
+            { value: "skip", label: "Skip for now", hint: "default" },
+            { value: "enter", label: "Enter API key" }
+          ],
+          initialValue: "skip"
+        });
+        if (keyChoice === "enter") {
+          return p.text({
+            message: "Enter your API key:",
+            placeholder: "sk-..."
+          });
+        }
+        return undefined;
+      },
+      addExample: () => p.confirm({
+        message: "Add example",
+        initialValue: false
+      })
+    },
+    {
+      onCancel: () => {
+        p.cancel("Operation cancelled.");
+        process.exit(0);
+      }
+    }
+  );
+  const { shouldAddTools, components, ...rest } = mastraProject;
+  const mastraComponents = shouldAddTools ? [...components, "tools"] : components;
+  return { ...rest, components: mastraComponents };
+};
+var checkPkgJson = async () => {
+  const cwd = process.cwd();
+  const pkgJsonPath = path.join(cwd, "package.json");
+  let isPkgJsonPresent = false;
+  try {
+    await fsExtra3.readJSON(pkgJsonPath);
+    isPkgJsonPresent = true;
+  } catch (err) {
+    isPkgJsonPresent = false;
+  }
+  if (isPkgJsonPresent) {
+    return;
+  }
+  logger.debug('no package.json found, create one or run "mastra create" to create a new project');
+  process.exit(0);
+};
+
+// src/commands/init/init.ts
+var s = p.spinner();
+var exec2 = util.promisify(child_process.exec);
+var init = async ({
+  directory,
+  addExample = false,
+  components,
+  llmProvider = "openai",
+  llmApiKey
+}) => {
+  s.start("Initializing Mastra");
+  try {
+    const result = await createMastraDir(directory);
+    if (!result.ok) {
+      s.stop(color2.inverse(" Mastra already initialized "));
+      return { success: false };
+    }
+    const dirPath = result.dirPath;
+    await Promise.all([
+      writeIndexFile({
+        dirPath,
+        addExample,
+        addWorkflow: components.includes("workflows"),
+        addAgent: components.includes("agents")
+      }),
+      ...components.map((component) => createComponentsDir(dirPath, component)),
+      writeAPIKey({ provider: llmProvider, apiKey: llmApiKey })
+    ]);
+    if (addExample) {
+      await Promise.all([
+        ...components.map(
+          (component) => writeCodeSample(dirPath, component, llmProvider, components)
+        )
+      ]);
+    }
+    const key = await getAPIKey(llmProvider || "openai");
+    const aiSdkPackage = getAISDKPackage(llmProvider);
+    await exec2(`npm i ${aiSdkPackage}`);
+    s.stop();
+    if (!llmApiKey) {
+      p.note(`
+      ${color2.green("Mastra initialized successfully!")}
+
+      Add your ${color2.cyan(key)} as an environment variable
+      in your ${color2.cyan(".env.development")} file
+      `);
+    } else {
+      p.note(`
+      ${color2.green("Mastra initialized successfully!")}
+      `);
+    }
+    return { success: true };
+  } catch (err) {
+    s.stop(color2.inverse("An error occurred while initializing Mastra"));
+    console.error(err);
+    return { success: false };
+  }
+};
+var exec3 = util.promisify(child_process.exec);
+var createMastraProject = async () => {
+  p.intro(color2.inverse("Mastra Create"));
+  const projectName = await p.text({
+    message: "What do you want to name your project?",
+    placeholder: "my-mastra-app",
+    defaultValue: "my-mastra-app"
+  });
+  if (p.isCancel(projectName)) {
+    p.cancel("Operation cancelled");
+    process.exit(0);
+  }
+  const s2 = p.spinner();
+  s2.start("Creating project");
+  try {
+    await fs4.mkdir(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 or delete the existing directory.`
+      );
+      process.exit(1);
+    }
+    throw error;
+  }
+  process.chdir(projectName);
+  s2.message("Creating project");
+  await exec3(`npm init -y`);
+  await exec3(`npm pkg set type="module"`);
+  const depsService = new DepsService();
+  await depsService.addScriptsToPackageJson({
+    dev: "mastra dev"
+  });
+  s2.stop("Project created");
+  s2.start("Installing npm dependencies");
+  await exec3(`npm i zod`);
+  await exec3(`npm i typescript tsx @types/node --save-dev`);
+  await exec3(`echo '{
+  "compilerOptions": {
+    "target": "ES2022",
+    "module": "ES2022",
+    "moduleResolution": "bundler",
+    "esModuleInterop": true,
+    "forceConsistentCasingInFileNames": true,
+    "strict": true,
+    "skipLibCheck": true,
+    "outDir": "dist"
+  },
+  "include": [
+    "src/**/*"
+  ],
+  "exclude": [
+    "node_modules",
+    "dist",
+    ".mastra"
+  ]
+}' > tsconfig.json`);
+  s2.stop("NPM dependencies installed");
+  s2.start("Installing mastra");
+  await exec3(`npm i -D mastra`);
+  s2.stop("mastra installed");
+  s2.start("Installing @mastra/core");
+  await exec3(`npm i @mastra/core@alpha`);
+  s2.stop("@mastra/core installed");
+  s2.start("Adding .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`);
+  s2.stop(".gitignore added");
+  p.outro("Project created successfully");
+  console.log("");
+  return { projectName };
+};
+
+// src/commands/create/create.ts
+var create = async (args) => {
+  const { projectName } = await createMastraProject();
+  const directory = "/src";
+  if (!args.components || !args.llmProvider || !args.addExample) {
+    const result = await interactivePrompt();
+    await init({
+      ...result,
+      llmApiKey: result?.llmApiKey
+    });
+    postCreate({ projectName });
+    return;
+  }
+  const { components = [], llmProvider = "openai", addExample = false, llmApiKey } = args;
+  await init({
+    directory,
+    components,
+    llmProvider,
+    addExample,
+    llmApiKey
+  });
+  postCreate({ projectName });
+};
+var postCreate = ({ projectName }) => {
+  p.outro(`
+   ${color2.green("To start your project:")}
+
+    ${color2.cyan("cd")} ${projectName}
+    ${color2.cyan("npm run dev")}
+  `);
+};
+
+export { DepsService, FileService, checkAndInstallCoreDeps, checkPkgJson, create, init, interactivePrompt, logger };

package/dist/commands/create/create.d.ts

@@ -0,0 +1,10 @@
+type LLMProvider = 'openai' | 'anthropic' | 'groq';
+
+declare const create: (args: {
+    components?: string[];
+    llmProvider?: LLMProvider;
+    addExample?: boolean;
+    llmApiKey?: string;
+}) => Promise<void>;
+
+export { create };

package/dist/commands/create/create.js

@@ -0,0 +1 @@
+export { create } from '../../chunk-UU6XEV7T.js';

package/dist/index.d.ts

@@ -0,0 +1,3 @@
+#! /usr/bin/env node
+export { create } from './commands/create/create.js';
+export { PosthogAnalytics } from './analytics/index.js';