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

package/dist/src/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/src/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;
+}>;

package/dist/src/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/src/commands/install-engine-deps.d.ts

@@ -0,0 +1 @@
+export declare function installEngineDeps(): Promise<void>;

package/dist/src/commands/install-engine-deps.js

@@ -0,0 +1,39 @@
+import * as p from '@clack/prompts';
+import { execa } from 'execa';
+import yoctoSpinner from 'yocto-spinner';
+import getPackageManager from '../utils/get-package-manager.js';
+const spinner = yoctoSpinner({ text: 'Install engine deps\n' });
+export async function installEngineDeps() {
+    try {
+        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();
+        await installPackages();
+        spinner.success('Dependencies installed successfully');
+    }
+    catch (err) {
+        spinner.error('Could not install dependencies');
+        console.error(err);
+    }
+}
+async function installPackages() {
+    const packageManager = getPackageManager();
+    let runCommand = packageManager;
+    if (packageManager === 'npm') {
+        runCommand = `${packageManager} i`;
+    }
+    else {
+        runCommand = `${packageManager} add`;
+    }
+    return execa(`${runCommand} @mastra/engine@alpha drizzle-kit`, {
+        all: true,
+        shell: true,
+        stdio: 'inherit',
+    });
+}

package/dist/src/commands/migrate.d.ts

@@ -0,0 +1,7 @@
+export declare function migrate(dbUrl: string): Promise<void>;
+interface MigrationResult {
+    stdout: string;
+    stderr: string;
+}
+export declare function _migrate(dbUrl: string, swallow?: boolean): Promise<MigrationResult>;
+export {};

package/dist/src/commands/migrate.js

@@ -0,0 +1,84 @@
+import { intro, note, spinner } from '@clack/prompts';
+import { execa, ExecaError } from 'execa';
+import path from 'path';
+import color from 'picocolors';
+import { getEnginePath } from '../utils/get-engine-path.js';
+const s = spinner();
+export async function migrate(dbUrl) {
+    intro(`${color.bgCyan(color.black(' Mastra migrate '))}`);
+    s.start('Migrating Database\n');
+    try {
+        await checkPostgresReady(dbUrl);
+        s.stop();
+        note('Migration complete! Your project is ready to go.');
+        process.exit(0);
+    }
+    catch (error) {
+        s.stop('Could not migrate database');
+        if (error instanceof ExecaError) {
+            console.error('error');
+        }
+        else {
+            console.log(`Error: ${error.message}`);
+        }
+        process.exit(1);
+    }
+}
+export async function _migrate(dbUrl, swallow = false) {
+    const enginePath = getEnginePath();
+    const stdioMode = swallow ? 'pipe' : 'inherit';
+    const newPath = path.join(enginePath, 'dist', 'postgres', 'migrate.js');
+    const subprocess = execa(`node`, [`${newPath}`], {
+        env: {
+            ...process.env,
+            DB_URL: dbUrl,
+        },
+        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'];
+            const respondToPrompts = setInterval(() => {
+                if (subprocess.stdin && !subprocess.stdin.destroyed) {
+                    responses.forEach(response => {
+                        subprocess.stdin.write(response);
+                    });
+                }
+            }, 100);
+            subprocess.on('exit', () => {
+                clearInterval(respondToPrompts);
+                subprocess.stdin?.end();
+            });
+        });
+    }
+    try {
+        const { stdout, stderr } = await subprocess;
+        return { stdout: stdout || '', stderr: stderr || '' };
+    }
+    catch (error) {
+        if (error.killed && error.timedOut) {
+            throw new Error(`Command timed out after 60000ms`);
+        }
+        throw error;
+    }
+}
+async function checkPostgresReady(dbUrl) {
+    for (let i = 0; i < 10; i++) {
+        try {
+            await _migrate(dbUrl); // attempts to create the migration w/o applying it
+            return true;
+        }
+        catch (error) {
+            if (error instanceof Error) {
+                console.error(error.message);
+            }
+            console.log(`Waiting for postgres to be ready, attempt ${i + 1} of 10`);
+        }
+        await new Promise(resolve => setTimeout(resolve, 1000));
+    }
+    throw new Error('Postgres is not ready, aborting');
+}

package/dist/src/commands/provision.d.ts

@@ -0,0 +1,3 @@
+export declare function provision(): Promise<{
+    dbUrl: string;
+}>;

package/dist/src/commands/provision.js

@@ -0,0 +1,36 @@
+import { execa } from 'execa';
+import yoctoSpinner from 'yocto-spinner';
+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() {
+    spinner.start();
+    const projectName = await getProjectName();
+    const sanitizedProjectName = sanitizeForDockerName(projectName);
+    const { postgresPort } = await getInfraPorts();
+    try {
+        spinner.text = 'Checking if Docker is running...\n';
+        await execa('docker', ['info'], { stdio: 'ignore', shell: true });
+    }
+    catch (error) {
+        spinner.error('Docker Daemon is not running. Please start Docker and try again\n');
+        console.error();
+    }
+    const { dbUrl } = prepareDockerComposeFile({
+        sanitizedProjectName,
+        postgresPort,
+    });
+    spinner.text = 'Starting docker container\n';
+    try {
+        await execa('docker', ['compose', '-f', DOCKER_COMPOSE_FILE, 'up', '-d'], { stdio: 'inherit' });
+        spinner.success('Docker containers started successfully\n');
+    }
+    catch (error) {
+        spinner.error('Failed to start Docker containers\n');
+        console.error(error);
+    }
+    return { dbUrl };
+}

package/dist/src/commands/up.d.ts

@@ -0,0 +1,5 @@
+export declare function up(): Promise<import("execa").Result<{
+    shell: true;
+    all: true;
+    stdio: "inherit";
+}>>;

package/dist/src/commands/up.js

@@ -0,0 +1,8 @@
+import { execa } from 'execa';
+export async function up() {
+    return execa(`docker-compose --file mastra-pg.docker-compose.yaml up --detach`, {
+        shell: true,
+        all: true,
+        stdio: 'inherit', // inherit will pipe directly to parent process stdout/stderr
+    });
+}

package/dist/src/index.d.ts

@@ -0,0 +1,2 @@
+#! /usr/bin/env node
+export {};