mastra 0.1.57-alpha.9 → 0.1.57-unstable.35

package/dist/commands/init/init.js

@@ -0,0 +1,32 @@
+import { logger } from '../../utils/logger.js';
+import { checkDependencies, createComponentsDir, createMastraDir, writeAPIKey, writeCodeSample, writeIndexFile, } from './utils.js';
+export const init = async ({ directory, addExample = false, components, llmProvider = 'openai', showSpinner = false, }) => {
+    const depCheck = await checkDependencies();
+    if (depCheck !== 'ok') {
+        logger.error(depCheck);
+        return { success: false };
+    }
+    try {
+        const result = await createMastraDir(directory);
+        if (!result.ok) {
+            logger.info('Mastra already initialized');
+            return { success: false };
+        }
+        const dirPath = result.dirPath;
+        await Promise.all([
+            writeIndexFile(dirPath, addExample),
+            ...components.map(component => createComponentsDir(dirPath, component)),
+            writeAPIKey(llmProvider),
+        ]);
+        if (addExample) {
+            await Promise.all([components.map(component => writeCodeSample(dirPath, component, llmProvider))]);
+        }
+        showSpinner && logger.success('Mastra initialized successfully');
+        return { success: true };
+    }
+    catch (err) {
+        showSpinner && logger.error('Could not initialize mastra');
+        console.error(err);
+        return { success: false };
+    }
+};

package/dist/commands/init/utils.d.ts

@@ -0,0 +1,25 @@
+import { ModelConfig } from '@mastra/core';
+export type LLMProvider = 'openai' | 'anthropic' | 'groq';
+export type Components = 'agents' | 'workflows' | 'tools';
+export declare const modelToConfigMap: Record<LLMProvider, ModelConfig>;
+export declare function writeAgentSample(llmProvider: LLMProvider, destPath: string): Promise<void>;
+export declare function writeWorkflowSample(destPath: string): Promise<void>;
+export declare function writeToolSample(destPath: string): Promise<void>;
+export declare function writeCodeSampleForComponents(llmprovider: LLMProvider, component: Components, destPath: string): Promise<void | "">;
+export declare const createComponentsDir: (dirPath: string, component: string) => Promise<void>;
+export declare const writeIndexFile: (dirPath: string, addExample: boolean) => Promise<void>;
+export declare const checkInitialization: (dirPath: string) => Promise<boolean>;
+export declare const checkDependencies: () => Promise<"No package.json file found in the current directory" | "Install @mastra/core before running this command (npm install @mastra/core)" | "ok" | "Could not check dependencies">;
+export declare const writeAPIKey: (provider: LLMProvider) => Promise<void>;
+export declare const createMastraDir: (directory: string) => Promise<{
+    ok: true;
+    dirPath: string;
+} | {
+    ok: false;
+}>;
+export declare const writeCodeSample: (dirPath: string, component: Components, llmProvider: LLMProvider) => Promise<void>;
+export declare const interactivePrompt: () => Promise<void>;
+export declare const initializeMinimal: () => Promise<void>;
+export declare const checkPkgJsonAndCreateStarter: () => Promise<{
+    isStarter: boolean;
+} | undefined>;

package/dist/commands/init/utils.js

@@ -0,0 +1,266 @@
+import * as p from '@clack/prompts';
+import child_process from 'node:child_process';
+import util from 'node:util';
+import path from 'path';
+import color from 'picocolors';
+import prettier from 'prettier';
+import fsExtra from 'fs-extra/esm';
+import fs from 'fs/promises';
+import { copyStarterFile } from '../../utils/copy-starter-file.js';
+import { logger } from '../../utils/logger.js';
+import { init } from './init.js';
+const exec = util.promisify(child_process.exec);
+export const modelToConfigMap = {
+    openai: { provider: 'OPEN_AI', name: 'gpt-4o', toolChoice: 'auto' },
+    anthropic: { provider: 'ANTHROPIC', name: 'claude-3-5-sonnet-20241022', toolChoice: 'auto' },
+    groq: { provider: 'GROQ', name: 'llama3-groq-70b-8192-tool-use-preview', toolChoice: 'auto' },
+};
+export async function writeAgentSample(llmProvider, destPath) {
+    const model = modelToConfigMap[llmProvider];
+    const content = `
+import { Agent } from '@mastra/core';
+
+export const catOne = new Agent({
+  name: 'cat-one',
+  instructions: 'You are a feline expert with comprehensive knowledge of all cat species, from domestic breeds to wild big cats. As a lifelong cat specialist, you understand their behavior, biology, social structures, and evolutionary history in great depth.',
+  model: ${JSON.stringify(model, null, 2)},
+});
+    `;
+    const formattedContent = await prettier.format(content, {
+        parser: 'typescript',
+        singleQuote: true,
+    });
+    await fs.writeFile(destPath, '');
+    await fs.writeFile(destPath, formattedContent);
+}
+export async function writeWorkflowSample(destPath) {
+    await copyStarterFile('workflow.ts', destPath);
+}
+export async function writeToolSample(destPath) {
+    await copyStarterFile('tools.ts', destPath);
+}
+export async function writeCodeSampleForComponents(llmprovider, component, destPath) {
+    switch (true) {
+        case component === 'agents':
+            return writeAgentSample(llmprovider, destPath);
+        case component === 'tools':
+            return writeToolSample(destPath);
+        case component === 'workflows':
+            return writeWorkflowSample(destPath);
+        default:
+            return '';
+    }
+}
+export const createComponentsDir = async (dirPath, component) => {
+    const componentPath = dirPath + `/${component}`;
+    await fsExtra.ensureDir(componentPath);
+};
+export const writeIndexFile = async (dirPath, addExample) => {
+    const indexPath = dirPath + '/index.ts';
+    const destPath = path.join(indexPath);
+    try {
+        await fs.writeFile(destPath, '');
+        if (!addExample) {
+            await fs.writeFile(destPath, `
+import { Mastra } from '@mastra/core';
+
+export const mastra = new Mastra({})
+        `);
+            return;
+        }
+        await fs.writeFile(destPath, `
+import { Mastra, createLogger } from '@mastra/core';
+
+import { catOne } from './agents/index';
+
+export const mastra = new Mastra({
+  agents: [catOne],
+  logger: createLogger({
+    type: 'CONSOLE',
+    level: 'INFO',
+  }),
+});
+`);
+    }
+    catch (err) {
+        throw err;
+    }
+};
+export const checkInitialization = async (dirPath) => {
+    try {
+        await fs.access(dirPath);
+        return true;
+    }
+    catch (err) {
+        return false;
+    }
+};
+export const checkDependencies = async () => {
+    try {
+        const packageJsonPath = path.join(process.cwd(), 'package.json');
+        try {
+            await fs.access(packageJsonPath);
+        }
+        catch {
+            return 'No package.json file found in the current directory';
+        }
+        const packageJson = JSON.parse(await fs.readFile(packageJsonPath, 'utf-8'));
+        if (!packageJson.dependencies || !packageJson.dependencies['@mastra/core']) {
+            return 'Install @mastra/core before running this command (npm install @mastra/core)';
+        }
+        return 'ok';
+    }
+    catch (err) {
+        console.error(err);
+        return 'Could not check dependencies';
+    }
+};
+export const writeAPIKey = async (provider) => {
+    let key = 'OPENAI_API_KEY';
+    switch (provider) {
+        case 'anthropic':
+            key = 'ANTHROPIC_API_KEY';
+            return;
+        case 'groq':
+            key = 'GROQ_API_KEY';
+            return;
+        default:
+            key = 'OPENAI_API_KEY';
+    }
+    await exec(`echo ${key}= >> .env.development`);
+};
+export const createMastraDir = async (directory) => {
+    let dir = directory
+        .trim()
+        .split('/')
+        .filter(item => item !== '');
+    const dirPath = path.join(process.cwd(), ...dir, 'mastra');
+    try {
+        await fs.access(dirPath);
+        return { ok: false };
+    }
+    catch {
+        await fsExtra.ensureDir(dirPath);
+        return { ok: true, dirPath };
+    }
+};
+export const writeCodeSample = async (dirPath, component, llmProvider) => {
+    const destPath = dirPath + `/${component}/index.ts`;
+    try {
+        await writeCodeSampleForComponents(llmProvider, component, destPath);
+    }
+    catch (err) {
+        throw err;
+    }
+};
+export const interactivePrompt = async () => {
+    const depCheck = await checkDependencies();
+    if (depCheck !== 'ok') {
+        logger.log(depCheck);
+        process.exit(0);
+    }
+    p.intro(color.inverse(' Initializing Mastra '));
+    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' },
+            ],
+        }),
+        addExample: () => p.confirm({
+            message: 'Add example',
+            initialValue: false,
+        }),
+    }, {
+        onCancel: () => {
+            p.cancel('Operation cancelled.');
+            process.exit(0);
+        },
+    });
+    const s = p.spinner();
+    s.start('Initializing Mastra');
+    const { shouldAddTools, components, ...rest } = mastraProject;
+    const mastraComponents = shouldAddTools ? [...components, 'tools'] : components;
+    try {
+        const result = { ...rest, components: mastraComponents };
+        const { success } = await init(result);
+        if (!success) {
+            return;
+        }
+        s.stop('Mastra initialized successfully');
+        p.note('You are all set!');
+        p.outro(`Problems? ${color.underline(color.cyan('https://github.com/mastra-ai/mastra'))}`);
+    }
+    catch (err) {
+        s.stop('Could not initialize Mastra');
+        logger.error(err);
+    }
+};
+export const initializeMinimal = async () => {
+    const confirm = await p.confirm({
+        message: 'No package.json detected. Create a new project?',
+        initialValue: true,
+    });
+    if (p.isCancel(confirm)) {
+        p.cancel('Operation cancelled');
+        process.exit(0);
+    }
+    if (!confirm) {
+        p.cancel('Operation cancelled');
+        process.exit(0);
+    }
+    const s = p.spinner();
+    s.start('Creating project');
+    await exec(`npm init -y`);
+    await exec(`npm i zod@3.23.7 typescript tsx @types/node --save-dev >> output.txt`);
+    s.message('Installing dependencies');
+    await exec(`echo output.txt >> .gitignore`);
+    await exec(`echo node_modules >> .gitignore`);
+    await exec(`npm i @mastra/core@alpha`);
+    s.stop('Project creation successful');
+    logger.break();
+};
+export const checkPkgJsonAndCreateStarter = async () => {
+    const cwd = process.cwd();
+    const pkgJsonPath = path.join(cwd, 'package.json');
+    let isPkgJsonPresent = false;
+    try {
+        await fsExtra.readJSON(pkgJsonPath);
+        isPkgJsonPresent = true;
+    }
+    catch (err) {
+        isPkgJsonPresent = false;
+    }
+    if (isPkgJsonPresent) {
+        return;
+    }
+    try {
+        await initializeMinimal();
+        return { isStarter: true };
+    }
+    catch (err) {
+        logger.error(`Could not create project: ${err}`);
+        process.exit(0);
+    }
+};

package/dist/commands/{installEngineDeps.js → install-engine-deps.js}

@@ -1,21 +1,16 @@
-import chalk from 'chalk';
+import * as p from '@clack/prompts';
 import { execa } from 'execa';
-import inquirer from 'inquirer';
 import yoctoSpinner from 'yocto-spinner';
-import getPackageManager from '../utils/getPackageManager.js';
+import getPackageManager from '../utils/get-package-manager.js';
 const spinner = yoctoSpinner({ text: 'Install engine deps\n' });
 export async function installEngineDeps() {
     try {
-        const { confirm } = await inquirer.prompt([
-            {
-                type: 'confirm',
-                name: 'confirm',
-                message: chalk.bold.yellow('Do you want to install the dependencies?'),
-                default: true,
-            },
-        ]);
-        if (!confirm) {
-            console.log(chalk.redBright('Installation Cancelled'));
+        const confirm = await p.confirm({
+            message: 'Do you want to install dependencies?',
+            initialValue: false,
+        });
+        if (p.isCancel(confirm)) {
+            p.cancel('Installation Canelled');
             return;
         }
         spinner.start();
@@ -36,7 +31,7 @@ async function installPackages() {
     else {
         runCommand = `${packageManager} add`;
     }
-    return execa(`${runCommand} @mastra/engine@alpha`, {
+    return execa(`${runCommand} @mastra/engine@alpha drizzle-kit`, {
         all: true,
         shell: true,
         stdio: 'inherit',

package/dist/commands/migrate.js

@@ -1,17 +1,20 @@
-import { runMigrations } from '@mastra/engine';
+import { intro, note, spinner } from '@clack/prompts';
 import { execa, ExecaError } from 'execa';
-import yoctoSpinner from 'yocto-spinner';
-import { getEnginePath } from '../utils.js';
-const spinner = yoctoSpinner({ text: 'Migrating Database\n' });
+import path from 'path';
+import color from 'picocolors';
+import { getEnginePath } from '../utils/get-engine-path.js';
+const s = spinner();
 export async function migrate(dbUrl) {
-    spinner.start();
+    intro(`${color.bgCyan(color.black(' Mastra migrate '))}`);
+    s.start('Migrating Database\n');
     try {
         await checkPostgresReady(dbUrl);
-        spinner.success('Migration complete! Your project is ready to go.');
+        s.stop();
+        note('Migration complete! Your project is ready to go.');
         process.exit(0);
     }
     catch (error) {
-        spinner.error('Could not migrate database');
+        s.stop('Could not migrate database');
         if (error instanceof ExecaError) {
             console.error('error');
         }
@@ -23,19 +26,19 @@ export async function migrate(dbUrl) {
 }
 export async function _migrate(dbUrl, swallow = false) {
     const enginePath = getEnginePath();
-    // const migrateScript = require(path.join(enginePath, 'dist/postgres/migrate.js'));
     const stdioMode = swallow ? 'pipe' : 'inherit';
-    const subprocess = execa(`pnpx tsx ./dist/postgres/migrate.js`, {
+    const newPath = path.join(enginePath, 'dist', 'postgres', 'migrate.js');
+    const subprocess = execa(`node`, [`${newPath}`], {
         env: {
             ...process.env,
             DB_URL: dbUrl,
         },
-        cwd: enginePath,
         shell: true,
         all: true,
         stdio: ['pipe', stdioMode, stdioMode],
         timeout: 60000,
     });
+    subprocess.stdout?.pipe(process.stdout);
     if (subprocess.stdin) {
         subprocess.on('spawn', () => {
             const responses = ['y\n', 'yes\n'];
@@ -66,7 +69,7 @@ export async function _migrate(dbUrl, swallow = false) {
 async function checkPostgresReady(dbUrl) {
     for (let i = 0; i < 10; i++) {
         try {
-            await runMigrations(dbUrl); // attempts to create the migration w/o applying it
+            await _migrate(dbUrl); // attempts to create the migration w/o applying it
             return true;
         }
         catch (error) {

package/dist/commands/provision.js

@@ -1,9 +1,9 @@
 import { execa } from 'execa';
 import yoctoSpinner from 'yocto-spinner';
-import { getInfraPorts, sanitizeForDockerName } from '../utils.js';
-import { getProjectName } from '../utils/getProjectName.js';
-import { prepareDockerComposeFile } from '../utils/setupDockerCompose.js';
-import { setupRoutes } from '../utils/setupRoutes.js';
+import { getProjectName } from '../utils/get-project-name.js';
+import { getInfraPorts } from '../utils/port-utils.js';
+import { sanitizeForDockerName } from '../utils/sanitize-docker-name.js';
+import { prepareDockerComposeFile } from '../utils/setup-docker-compose.js';
 const DOCKER_COMPOSE_FILE = 'mastra-pg.docker-compose.yaml';
 const spinner = yoctoSpinner({ text: 'Provisioning docker file\n' });
 export async function provision() {
@@ -32,14 +32,5 @@ export async function provision() {
         spinner.error('Failed to start Docker containers\n');
         console.error(error);
     }
-    spinner.start('Setting up routes');
-    try {
-        await setupRoutes();
-        spinner.success('Routes setup successfully\n');
-    }
-    catch (err) {
-        spinner.error('Could no setup routes\n');
-        console.error(err);
-    }
     return { dbUrl };
 }