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

package/dist/commands/dev.js

@@ -1,311 +1,47 @@
+import { config } from 'dotenv';
 import { execa } from 'execa';
-import fs, { existsSync, mkdirSync, writeFileSync } from 'fs';
-import path, { join } from 'path';
-import process from 'process';
-import fse from 'fs-extra/esm';
-import { createRequire } from 'module';
-const require = createRequire(import.meta.url);
-// Explicitly register ts-node before any imports
-import { register } from 'ts-node';
-register({
-    transpileOnly: true,
-    esm: true,
-    experimentalResolver: true,
-});
-// Enable module aliases if tsconfig.json exists
-const tsconfigPath = path.resolve(process.cwd(), 'tsconfig.json');
-if (existsSync(tsconfigPath)) {
-    try {
-        require('tsconfig-paths/register');
-    }
-    catch (e) {
-        console.warn('Warning: Could not load tsconfig paths');
-    }
-}
-import { spawn } from 'child_process';
-async function copyUserEnvFileToAdmin(adminPath, envFile = '.env.development') {
-    const sourcePath = path.resolve(process.cwd(), envFile);
-    const destinationPath = path.resolve(process.cwd(), adminPath, envFile);
-    fse.copy(sourcePath, destinationPath, { overwrite: true }, err => {
-        if (err) {
-            console.log('An error occurred while trying to copy the .env file from mastra project directory to admin.');
-            console.error(err);
-        }
+import { writeFileSync } from 'fs';
+import { join } from 'path';
+import path from 'path';
+import { fileURLToPath } from 'url';
+import fsExtra from 'fs-extra/esm';
+import fs from 'fs/promises';
+import { bundle, bundleServer } from '../utils/bundle.js';
+import { getFirstExistingFile } from '../utils/get-first-existing-file.js';
+import { EXPRESS_SERVER } from './deploy/server.js';
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = path.dirname(__filename);
+export async function dev({ port, env, dir }) {
+    const dotMastraPath = join(process.cwd(), '.mastra');
+    const agentChatServePath = join(dotMastraPath, 'agent-chat');
+    const key = env[0]?.name;
+    const value = env[0]?.value;
+    // Ensure agent-chat directory exists
+    await fsExtra.ensureDir(agentChatServePath);
+    // Copy agent-chat dist files
+    await fsExtra.copy(join(path.dirname(path.dirname(__dirname)), 'src/chat/agent/dist'), agentChatServePath, {
+        overwrite: true,
     });
-}
-const objectToEnvString = (envObject) => {
-    return Object.entries(envObject)
-        .map(([key, value]) => {
-        // Ensure the value is stringified and handle special characters if needed
-        const stringValue = String(value).replace(/\\/g, '\\\\').replace(/"/g, '\\"');
-        return `${key}="${stringValue}"`;
-    })
-        .join('\n');
-};
-async function copyEnvToAdmin(adminPath, envFile = '.env.development') {
-    const destinationPath = path.resolve(process.cwd(), adminPath, envFile);
-    fs.writeFileSync(destinationPath, objectToEnvString(process.env), 'utf-8');
-}
-async function watchUserEnvAndSyncWithAdminEnv(adminPath, envFile = '.env.development') {
-    const userEnvPath = path.resolve(process.cwd(), envFile);
     try {
-        fs.watch(userEnvPath, eventType => {
-            if (eventType === 'change') {
-                copyUserEnvFileToAdmin(adminPath, envFile);
-            }
-        });
+        const envFile = getFirstExistingFile(['.env.development', '.env']);
+        config({ path: envFile });
     }
     catch (err) {
-        console.log('An error occurred while trying to watch the .env file in the mastra project directory.');
-        console.error(err);
-    }
-}
-async function addDotMastraToUserGitIgnore() {
-    const userGitIgnorePath = path.resolve(process.cwd(), '.gitignore');
-    try {
-        const gitignoreFileData = fs.readFileSync(userGitIgnorePath, 'utf8');
-        const mastraIgnoreStatement = '\n.mastra/\n';
-        if (gitignoreFileData.includes(mastraIgnoreStatement)) {
-            console.log('.mastra already ignored');
-            return false;
-        }
-        fs.appendFileSync(userGitIgnorePath, `\n# mastra${mastraIgnoreStatement}`);
-        console.log('.mastra successfully ignored');
-        return true;
-    }
-    catch (err) {
-        console.log('An error occurred while trying to add .mastra folder to user gitignore');
-        console.error(err);
-    }
-}
-async function generateUserDefinedIntegrations({ adminPath, integrationsPath, }) {
-    const buildUserDefinedIntegrationScript = path.resolve(adminPath, 'scripts', 'build-user-defined-integrations.mjs');
-    await execa(`node`, [buildUserDefinedIntegrationScript], {
-        cwd: adminPath,
+        //create .env file
+        await fsExtra.ensureFile('.env');
+        await fs.writeFile(path.join(process.cwd(), '.env'), `${key}=${value}`);
+    }
+    const dirPath = dir || path.join(process.cwd(), 'src/mastra');
+    await bundle(dirPath);
+    writeFileSync(join(dotMastraPath, 'index.mjs'), EXPRESS_SERVER);
+    await bundleServer(join(dotMastraPath, 'index.mjs'));
+    const proc = execa('node', ['server.mjs'], {
+        cwd: dotMastraPath,
         env: {
-            ...process.env,
-            INTEGRATION_PATH: integrationsPath,
+            port: `${port} || 4111`,
         },
     });
+    proc.stdout.pipe(process.stdout);
+    proc.stderr.pipe(process.stderr);
+    return proc;
 }
-const copyFolder = async (src, dest, excludedFolders) => {
-    if (fs.existsSync(dest)) {
-        fs.rmSync(dest, { recursive: true });
-    }
-    fs.mkdirSync(dest, { recursive: true });
-    // Resolve the paths to ensure they are absolute
-    const resolvedSrc = path.resolve(src);
-    const resolvedDest = path.resolve(dest);
-    try {
-        // Use the `cp` command with the `-r` flag for recursive copying
-        await execa('cp', ['-R', '-L', resolvedSrc, resolvedDest]);
-        console.log(`Folder copied from ${resolvedSrc} to ${resolvedDest}`);
-        // Remove exlcuded folders
-        if (excludedFolders?.length) {
-            excludedFolders.forEach(folder => {
-                const pathToRemove = path.join(resolvedDest, folder);
-                if (fs.existsSync(pathToRemove)) {
-                    fs.rmSync(pathToRemove, { recursive: true });
-                }
-            });
-        }
-    }
-    catch (error) {
-        console.error(`Error copying folder: ${error.message}`);
-    }
-};
-async function listFiles(directory) {
-    try {
-        const { stdout } = await execa('ls', ['-l', directory]);
-        console.log(stdout);
-    }
-    catch (error) {
-        console.error('Error listing files:', error);
-    }
-}
-export async function startServer({ port: _port, }) {
-    console.log('starting server...');
-    const cwd = process.cwd();
-    const possiblePaths = [
-        join(cwd, 'mastra'), // for "mastra" directory
-        join(cwd, 'src', 'mastra'), // for source directory
-        cwd // if we're already in the mastra directory
-    ];
-    let frameworkPath;
-    for (const path of possiblePaths) {
-        const indexPath = join(path, 'index.ts');
-        frameworkPath = join(path, 'framework.ts');
-        if (existsSync(indexPath)) {
-            frameworkPath = indexPath;
-            break;
-        }
-        if (existsSync(frameworkPath)) {
-            frameworkPath = frameworkPath;
-            break;
-        }
-    }
-    // Create a temporary runner file
-    const runnerCode = `
-    import { mastra } from '${frameworkPath?.replace('.ts', '.js')}';
-
-    async function run() {
-      try {
-        console.log(mastra)
-        console.log(JSON.stringify({ success: true, result }));
-      } catch (error) {
-        console.log(JSON.stringify({ success: false, error: error.message }));
-      }
-    }
-
-    run();
-  `;
-    console.log(runnerCode);
-    if (!existsSync(join(cwd, '.mastra'))) {
-        mkdirSync(join(cwd, '.mastra'));
-    }
-    // Write the runner file
-    writeFileSync(path.join(cwd, '.mastra', '/server.js'), runnerCode);
-    // Create package.json for the temporary directory
-    writeFileSync(join(path.join(cwd, '.mastra'), 'package.json'), JSON.stringify({
-        "type": "module"
-    }));
-    // Execute the code using ts-node
-    const tsNode = spawn('ts-node', [
-        '--esm',
-        path.join(cwd, '.mastra', 'server.js')
-    ], {
-        stdio: ['inherit', 'pipe', 'inherit'],
-        env: {
-            ...process.env,
-            TS_NODE_PROJECT: join(process.cwd(), 'tsconfig.json')
-        }
-    });
-    let output = '';
-    tsNode.stdout.on('data', (data) => {
-        output += data.toString();
-    });
-    tsNode.on('close', (code) => {
-        if (code === 0 && output) {
-            try {
-                const result = JSON.parse(output);
-                if (result.success) {
-                    console.log('Result:', result.result);
-                }
-                else {
-                    console.error('Error:', result.error);
-                    process.exit(1);
-                }
-            }
-            catch (e) {
-                console.log(output);
-            }
-        }
-        else if (code !== 0) {
-            console.error('Failed to execute method');
-            process.exit(1);
-        }
-    });
-    // // TODO: fix cwd so it works from project directory, not just from the cli directory
-    // const __filename = fileURLToPath(import.meta.url);
-    // const __dirname = path.dirname(__filename);
-    // const targetDir = process.cwd();
-    // // const result = await build({
-    // //   entryPoints: [`${targetDir}/src/mastra/index.ts`],
-    // //   bundle: true,
-    // //   write: false,
-    // //   format: 'esm',
-    // //   platform: 'node',
-    // //   target: 'node16',
-    // //   loader: { '.ts': 'ts' },
-    // //   packages: 'external', // Keep all packages as external
-    // //   external: [
-    // //     // '@mastra/*',  // External packages
-    // //     'fs',
-    // //     'path',
-    // //     'http',
-    // //     'https',
-    // //     'crypto',
-    // //     'os',
-    // //     'util',
-    // //     'stream',
-    // //     'zlib',
-    // //     'events',
-    // //     'node:*'
-    // //   ],
-    // //   mainFields: ['module', 'main'],
-    // //   conditions: ['import', 'node'],
-    // //   // alias: {
-    // //   //   '@mastra/core': path.join(process.cwd(), 'node_modules/@mastra/core/dist/core.esm.js'),
-    // //   // }
-    // // });
-    // // Write to current directory instead of tmp
-    // if (!fs.existsSync(path.join(process.cwd(), `.mastra`))) {
-    //   fs.mkdirSync(path.join(process.cwd(), `.mastra`));
-    // }
-    // const outFile = path.join(process.cwd(), `.mastra/server.ts`);
-    // writeFileSync(outFile, `
-    //   import { mastra } from '../src/mastra'
-    //   mastra.createServer(${port});
-    // `);
-    // Import using the file path
-    // const module = await import(pathToFileURL(outFile).href);
-    // console.log(module)
-    // const possibleAdminPaths = [path.resolve(__dirname, '..', '..', 'admin', 'next.config.mjs')];
-    // // Determine the admin path.
-    // let adminPath = getFirstExistingFile(possibleAdminPaths);
-    // // Remove the next.config.js file from the admin path
-    // adminPath = path.resolve(adminPath, '..');
-    // const configPath = path.resolve(process.cwd(), 'mastra.config');
-    // copyUserEnvFileToAdmin(adminPath, envFile);
-    // watchUserEnvAndSyncWithAdminEnv(adminPath, envFile);
-    // const integrationsPath = path.resolve(process.cwd(), 'integrations');
-    // if (fs.existsSync(integrationsPath)) {
-    //   generateUserDefinedIntegrations({ adminPath, integrationsPath });
-    // }
-    // console.log('Installing Admin deps...');
-    // const packageManager = getPackageManager();
-    // await execa(`${packageManager} install`, {
-    //   cwd: adminPath,
-    //   all: true,
-    //   buffer: false,
-    //   env: {
-    //     ...process.env,
-    //     MASTRA_APP_DIR: process.cwd(),
-    //   },
-    //   shell: true,
-    //   stdio: 'inherit', // This will pipe directly to parent process stdout/stderr
-    // });
-    // // Move prisma client to root node_modules
-    // const corePrismaPath = path.resolve(adminPath, 'node_modules', '@mastra', 'core', 'node_modules', '@prisma-app');
-    // const rootPrismaPath = path.resolve(adminPath, 'node_modules', '@prisma-app');
-    // await copyFolder(corePrismaPath, rootPrismaPath);
-    // console.log('Starting Next.js dev server...');
-    // let devCommand = `${packageManager} run dev -p ${port}`;
-    // if (packageManager === 'npm') {
-    //   devCommand = `${packageManager} run dev -- -p ${port}`;
-    // }
-    // const nextServer = execa(devCommand, {
-    //   cwd: adminPath,
-    //   all: true,
-    //   buffer: false,
-    //   env: {
-    //     ...process.env,
-    //     MASTRA_APP_DIR: process.cwd(),
-    //   },
-    //   shell: true,
-    //   stdio: 'inherit', // This will pipe directly to parent process stdout/stderr
-    // });
-    // process.on('SIGINT', async () => {
-    //   console.log('Stopping Next.js dev server...');
-    //   nextServer.kill();
-    //   process.exit();
-    // });
-    // await nextServer;
-    // } catch (error: any) {
-    //   if (error instanceof ExecaError) {
-    //     console.error(error);
-    //   }
-    //   console.error(`Error: ${error.message}`);
-    // }
-}
-//# sourceMappingURL=dev.js.map

package/dist/commands/generate.d.ts

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

package/dist/commands/generate.js

@@ -1,10 +1,43 @@
 import { execa } from 'execa';
+import path from 'path';
 import yoctoSpinner from 'yocto-spinner';
-import { getEnginePath } from '../utils.js';
+import fsExtra from 'fs-extra/esm';
+import { getEnginePath } from '../utils/get-engine-path.js';
+import getPackageManager from '../utils/get-package-manager.js';
 const spinner = yoctoSpinner({ text: 'Generating drizzle client\n' });
+const checkDrizzleInstallation = async () => {
+    const pkgJsonPath = path.join(process.cwd(), 'package.json');
+    const pkgJson = (await fsExtra.readJSON(pkgJsonPath));
+    if (pkgJson.dependencies && !pkgJson.dependencies['drizzle-kit']) {
+        return false;
+    }
+    else {
+        return true;
+    }
+};
+const installDrizzleKit = async () => {
+    const packageManager = getPackageManager();
+    let runCommand = packageManager;
+    if (packageManager === 'npm') {
+        runCommand = `${packageManager} i`;
+    }
+    else {
+        runCommand = `${packageManager} add`;
+    }
+    await execa(`${runCommand} drizzle-kit`, {
+        all: true,
+        shell: true,
+        stdio: 'inherit',
+    });
+};
 export async function generate(dbUrl) {
     try {
         spinner.start();
+        const isDrizzleInstalled = await checkDrizzleInstallation();
+        if (!isDrizzleInstalled) {
+            spinner.text = 'Installing drizzle kit\n';
+            await installDrizzleKit();
+        }
         await generateDrizzleClient(dbUrl);
         spinner.success('Drizzle client generated\n');
     }
@@ -31,4 +64,3 @@ async function generateDrizzleClient(dbUrl) {
         throw err;
     }
 }
-//# sourceMappingURL=generate.js.map

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

@@ -0,0 +1,10 @@
+import { LLMProvider } from './utils.js';
+export declare const init: ({ directory, addExample, components, llmProvider, showSpinner, }: {
+    directory: string;
+    components: string[];
+    llmProvider: LLMProvider;
+    addExample: boolean;
+    showSpinner?: boolean;
+}) => Promise<{
+    success: boolean;
+}>;

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>;