@mastra/dane 0.0.2-alpha.5 → 0.0.2-alpha.50

package/dist/mastra/tools/pdf.js

@@ -2,8 +2,9 @@ import { createTool } from '@mastra/core';
 import chalk from 'chalk';
 import { existsSync, readFileSync } from 'fs';
 import path from 'path';
-import pdf from 'pdf-parse';
 import { z } from 'zod';
+// @ts-ignore
+import pdfParse from 'pdf-parse/lib/pdf-parse.js';
 export const readPDF = createTool({
     id: 'readPDF',
     name: 'Read PDF',
@@ -27,7 +28,7 @@ export const readPDF = createTool({
             // Read the PDF file
             const dataBuffer = readFileSync(pdfPath);
             // Parse PDF content
-            const data = await pdf(dataBuffer);
+            const data = await pdfParse(dataBuffer);
             console.log(chalk.blue('\n'));
             console.log(chalk.blue('PDF Information:'));
             console.log(chalk.blue('-----------------'));

package/dist/mastra/tools/pnpm.d.ts

@@ -0,0 +1,60 @@
+import { z } from 'zod';
+export declare const pnpmBuild: import("@mastra/core").Tool<"pnpmBuild", z.ZodObject<{
+    name: z.ZodString;
+    packagePath: z.ZodString;
+}, "strip", z.ZodTypeAny, {
+    name: string;
+    packagePath: string;
+}, {
+    name: string;
+    packagePath: string;
+}>, z.ZodObject<{
+    message: z.ZodString;
+}, "strip", z.ZodTypeAny, {
+    message: string;
+}, {
+    message: string;
+}>, import("@mastra/core").ToolExecutionContext<z.ZodObject<{
+    name: z.ZodString;
+    packagePath: z.ZodString;
+}, "strip", z.ZodTypeAny, {
+    name: string;
+    packagePath: string;
+}, {
+    name: string;
+    packagePath: string;
+}>, import("@mastra/core").WorkflowContext<any>>>;
+export declare const pnpmChangesetStatus: import("@mastra/core").Tool<"pnpmChangesetStatus", z.ZodObject<{}, "strip", z.ZodTypeAny, {}, {}>, z.ZodObject<{
+    message: z.ZodArray<z.ZodString, "many">;
+}, "strip", z.ZodTypeAny, {
+    message: string[];
+}, {
+    message: string[];
+}>, import("@mastra/core").ToolExecutionContext<z.ZodObject<{}, "strip", z.ZodTypeAny, {}, {}>, import("@mastra/core").WorkflowContext<any>>>;
+export declare const pnpmChangesetPublish: import("@mastra/core").Tool<"pnpmChangesetPublish", z.ZodObject<{}, "strip", z.ZodTypeAny, {}, {}>, z.ZodObject<{
+    message: z.ZodString;
+}, "strip", z.ZodTypeAny, {
+    message: string;
+}, {
+    message: string;
+}>, import("@mastra/core").ToolExecutionContext<z.ZodObject<{}, "strip", z.ZodTypeAny, {}, {}>, import("@mastra/core").WorkflowContext<any>>>;
+export declare const activeDistTag: import("@mastra/core").Tool<"activeDistTag", z.ZodObject<{
+    packagePath: z.ZodString;
+}, "strip", z.ZodTypeAny, {
+    packagePath: string;
+}, {
+    packagePath: string;
+}>, z.ZodObject<{
+    message: z.ZodString;
+}, "strip", z.ZodTypeAny, {
+    message: string;
+}, {
+    message: string;
+}>, import("@mastra/core").ToolExecutionContext<z.ZodObject<{
+    packagePath: z.ZodString;
+}, "strip", z.ZodTypeAny, {
+    packagePath: string;
+}, {
+    packagePath: string;
+}>, import("@mastra/core").WorkflowContext<any>>>;
+//# sourceMappingURL=pnpm.d.ts.map

package/dist/mastra/tools/pnpm.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"pnpm.d.ts","sourceRoot":"","sources":["../../../src/mastra/tools/pnpm.ts"],"names":[],"mappings":"AAKA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAExB,eAAO,MAAM,SAAS;;;;;;;;;;;;;;;;;;;;;;;;iDA8BpB,CAAC;AAEH,eAAO,MAAM,mBAAmB;;;;;;6IA8B9B,CAAC;AAEH,eAAO,MAAM,oBAAoB;;;;;;6IA0B/B,CAAC;AAEH,eAAO,MAAM,aAAa;;;;;;;;;;;;;;;;;;iDA8BxB,CAAC"}

package/dist/mastra/tools/pnpm.js

@@ -0,0 +1,128 @@
+import { createTool } from '@mastra/core';
+import chalk from 'chalk';
+import { execa, ExecaError } from 'execa';
+import { readFileSync } from 'fs';
+import path from 'path';
+import { z } from 'zod';
+export const pnpmBuild = createTool({
+    id: 'pnpmBuild',
+    name: 'PNPM Build Tool',
+    description: 'Used to build the pnpm module',
+    inputSchema: z.object({
+        name: z.string(),
+        packagePath: z.string(),
+    }),
+    outputSchema: z.object({
+        message: z.string(),
+    }),
+    execute: async ({ context: { name, packagePath } }) => {
+        try {
+            console.log(chalk.green(`Building: ${name} at ${packagePath}`));
+            const p = execa(`pnpm`, ['build'], {
+                stdio: 'inherit',
+                cwd: packagePath,
+                reject: false,
+            });
+            console.log(`\n`);
+            await p;
+            return { message: 'Done' };
+        }
+        catch (e) {
+            console.error(e);
+            if (e instanceof ExecaError) {
+                return { message: e.message };
+            }
+            return { message: 'Error' };
+        }
+    },
+});
+export const pnpmChangesetStatus = createTool({
+    id: 'pnpmChangesetStatus',
+    name: 'PNPM Changeset Status Tool',
+    description: 'Used to check which pnpm modules need to be published',
+    inputSchema: z.object({}),
+    outputSchema: z.object({
+        message: z.array(z.string()),
+    }),
+    execute: async () => {
+        try {
+            console.log('Checking');
+            const { stdout } = await execa('pnpm', ['publish', '-r', '--dry-run', '--no-git-checks'], {
+                all: true,
+                // We want to see stderr too since pnpm sometimes puts important info there
+                stderr: 'inherit',
+            });
+            const lines = stdout.split('\n');
+            const filteredLines = lines.filter(line => line.startsWith('+'));
+            const packages = filteredLines.map(line => line.trim().substring(2).split('@').slice(0, -1).join('@'));
+            return { message: packages };
+        }
+        catch (e) {
+            console.error(e);
+            if (e instanceof ExecaError) {
+                return { message: [e.message] };
+            }
+            return { message: ['Error'] };
+        }
+    },
+});
+export const pnpmChangesetPublish = createTool({
+    id: 'pnpmChangesetPublish',
+    name: 'PNPM Changeset Publish Tool',
+    description: 'Used to publish the pnpm module',
+    inputSchema: z.object({}),
+    outputSchema: z.object({
+        message: z.string(),
+    }),
+    execute: async () => {
+        try {
+            console.log(chalk.green(`Publishing...`));
+            const p = execa(`pnpm`, ['changeset', 'publish'], {
+                stdio: 'inherit',
+                reject: false,
+            });
+            console.log(`\n`);
+            await p;
+            return { message: 'Done' };
+        }
+        catch (e) {
+            console.error(e);
+            if (e instanceof ExecaError) {
+                return { message: e.message };
+            }
+            return { message: 'Error' };
+        }
+    },
+});
+export const activeDistTag = createTool({
+    id: 'activeDistTag',
+    name: 'PNPM Changeset set active tag',
+    description: 'Used to set active tag on the pnpm module',
+    inputSchema: z.object({
+        packagePath: z.string(),
+    }),
+    outputSchema: z.object({
+        message: z.string(),
+    }),
+    execute: async ({ context }) => {
+        try {
+            const pkgJson = JSON.parse(readFileSync(path.join(context.packagePath, 'package.json'), 'utf-8'));
+            const version = pkgJson.version;
+            console.log(chalk.green(`Setting active tag to latest for ${pkgJson.name}@${version}`));
+            const p = execa(`npm`, ['dist-tag', `add`, `${pkgJson.name}@${version}`, `latest`], {
+                stdio: 'inherit',
+                reject: false,
+            });
+            console.log(`\n`);
+            await p;
+            return { message: 'Done' };
+        }
+        catch (e) {
+            console.error(e);
+            if (e instanceof ExecaError) {
+                return { message: e.message };
+            }
+            return { message: 'Error' };
+        }
+    },
+});

package/dist/mastra/workflows/chat.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"chat.d.ts","sourceRoot":"","sources":["../../../src/mastra/workflows/chat.ts"],"names":[],"mappings":"AAAA,OAAO,EAAQ,QAAQ,EAAE,MAAM,cAAc,CAAC;AAG9C,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAIxB,eAAO,MAAM,eAAe;;;;;;;;;GAM1B,CAAC"}
+{"version":3,"file":"chat.d.ts","sourceRoot":"","sources":["../../../src/mastra/workflows/chat.ts"],"names":[],"mappings":"AACA,OAAO,EAAQ,QAAQ,EAAE,MAAM,cAAc,CAAC;AAE9C,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAIxB,eAAO,MAAM,eAAe;;;;;;;;;GAM1B,CAAC"}

package/dist/mastra/workflows/chat.js

@@ -1,6 +1,6 @@
+import { input } from '@inquirer/prompts';
 import { Step, Workflow } from '@mastra/core';
 import chalk from 'chalk';
-import inquirer from 'inquirer';
 import { z } from 'zod';
 import { dane } from '../agents/index.js';
 export const messageWorkflow = new Workflow({
@@ -16,14 +16,10 @@ const messageStep = new Step({
         message: z.string(),
     }),
     execute: async () => {
-        const { content } = await inquirer.prompt([
-            {
-                type: 'input',
-                name: 'content',
-                message: '\n You:',
-                validate: input => input.trim().length > 0 || 'Message cannot be empty',
-            },
-        ]);
+        const content = await input({
+            message: '\n You:',
+            validate: input => input.trim().length > 0 || 'Message cannot be empty',
+        });
         return { message: content };
     },
 });
@@ -51,8 +47,7 @@ const messageOutputStep = new Step({
             if (!messages || messages.length === 0) {
                 messages = [];
             }
-            const res = await mastra?.agents?.['dane']?.generate(message, {
-                stream: true,
+            const res = await mastra?.agents?.['dane']?.stream(message, {
                 maxSteps: 5,
                 resourceid,
                 threadId,

package/dist/mastra/workflows/commit-message.d.ts

@@ -0,0 +1,10 @@
+import { Workflow } from '@mastra/core';
+import { z } from 'zod';
+export declare const commitMessageGenerator: Workflow<any, z.ZodObject<{
+    repoPath: z.ZodString;
+}, "strip", z.ZodTypeAny, {
+    repoPath: string;
+}, {
+    repoPath: string;
+}>>;
+//# sourceMappingURL=commit-message.d.ts.map

package/dist/mastra/workflows/commit-message.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"commit-message.d.ts","sourceRoot":"","sources":["../../../src/mastra/workflows/commit-message.ts"],"names":[],"mappings":"AACA,OAAO,EAAQ,QAAQ,EAAE,MAAM,cAAc,CAAC;AAG9C,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAIxB,eAAO,MAAM,sBAAsB;;;;;;GAKjC,CAAC"}

package/dist/mastra/workflows/commit-message.js

@@ -0,0 +1,137 @@
+import { confirm } from '@inquirer/prompts';
+import { Step, Workflow } from '@mastra/core';
+import chalk from 'chalk';
+import { execSync } from 'child_process';
+import { z } from 'zod';
+import { fsTool } from '../tools/fs.js';
+export const commitMessageGenerator = new Workflow({
+    name: 'commit-message',
+    triggerSchema: z.object({
+        repoPath: z.string(),
+    }),
+});
+const getDiff = new Step({
+    id: 'getDiff',
+    outputSchema: z.object({
+        diff: z.string(),
+    }),
+    execute: async ({ context }) => {
+        const repoPath = context?.machineContext?.getStepPayload('trigger')?.repoPath;
+        // Get the git diff of staged changes
+        const diff = execSync('git diff --staged', {
+            cwd: repoPath,
+            encoding: 'utf-8',
+        });
+        return { diff };
+    },
+});
+const readConventionalCommitSpec = new Step({
+    id: 'readConventionalCommitSpec',
+    outputSchema: z.object({
+        fileData: z.any(),
+    }),
+    execute: async () => {
+        const fileData = await fsTool.execute({
+            context: { action: 'read', file: 'data/crawl/conventional-commit.json', data: '' },
+        });
+        return { fileData };
+    },
+});
+const generateMessage = new Step({
+    id: 'generateMessage',
+    outputSchema: z.object({
+        commitMessage: z.string(),
+        generated: z.boolean(),
+        guidelines: z.array(z.string()),
+    }),
+    execute: async ({ context, mastra }) => {
+        const diffData = context?.machineContext?.getStepPayload('getDiff');
+        const fileData = context?.machineContext?.getStepPayload('readConventionalCommitSpec');
+        if (!diffData) {
+            return { commitMessage: '', generated: false, guidelines: [] };
+        }
+        const daneCommitGenerator = mastra?.agents?.daneCommitMessage;
+        const res = await daneCommitGenerator?.generate(`
+        Given this git diff:
+        ${diffData.diff}
+
+        IF THE DIFF IS EMPTY, RETURN "No staged changes found", AND SET GENERATED TO FALSE,
+        OTHERWISE, SET GENERATED TO TRUE
+
+        ${fileData && fileData.fileData?.message
+            ? `USE THE FOLLOWING GUIDELINES: ${fileData.fileData?.message}`
+            : `USE THE FOLLOWING GUIDELINES:
+        - Start with a verb in the present tense
+        - Be specific but concise
+        - Focus on the "what" and "why" of the changes
+        IF THERE ARE MULTIPLE LOGICAL CHANGES, USE THE DESCRIPTION TO EXPLAIN THE CHANGES IN BULLET POINTS.
+
+        - Keep the first line under 50 characters
+        - If needed, add more detailed description after a blank line`}
+
+        RETURN THE GUIDELINES YOU ARE USING AS AN ARRAY OF STRINGS ON THE GUIDELINES KEY, AND THE COMMIT MESSAGE ON THE COMMIT MESSAGE KEY
+      `, {
+            output: z.object({
+                commitMessage: z.string(),
+                generated: z.boolean(),
+                guidelines: z.array(z.string()),
+            }),
+        });
+        if (!res?.object?.generated) {
+            throw new Error(res?.object?.commitMessage);
+        }
+        return {
+            commitMessage: res?.object?.commitMessage,
+            generated: res?.object?.generated,
+            guidelines: res?.object?.guidelines,
+        };
+    },
+});
+const confirmationStep = new Step({
+    id: 'confirmation',
+    outputSchema: z.object({
+        confirm: z.boolean(),
+    }),
+    execute: async ({ context }) => {
+        const parentStep = context?.machineContext?.stepResults?.generateMessage;
+        if (!parentStep || parentStep.status !== 'success') {
+            return { confirm: false };
+        }
+        if (!parentStep.payload.generated) {
+            return { confirm: false };
+        }
+        const commitMessage = parentStep.payload.commitMessage;
+        const confirmationMessage = await confirm({
+            message: `\n Would you like to use this commit message? \n\n ${chalk.yellow(commitMessage)}\n\n`,
+        });
+        return { confirm: confirmationMessage };
+    },
+});
+const commitStep = new Step({
+    id: 'commit',
+    outputSchema: z.object({
+        commit: z.boolean(),
+    }),
+    execute: async ({ context }) => {
+        const parentStep = context?.machineContext?.stepResults?.confirmation;
+        if (!parentStep || parentStep.status !== 'success' || !parentStep.payload.confirm) {
+            throw new Error('Commit message generation cancelled');
+        }
+        if (context?.machineContext?.stepResults?.generateMessage?.status !== 'success') {
+            throw new Error('Failed to generate commit message');
+        }
+        const commitMessage = context?.machineContext?.stepResults?.generateMessage?.payload?.commitMessage;
+        execSync(`git commit -m "${commitMessage}"`, {
+            cwd: context?.machineContext?.triggerData?.repoPath,
+            encoding: 'utf-8',
+        });
+        return { commit: true };
+    },
+});
+commitMessageGenerator
+    .step(getDiff)
+    .then(readConventionalCommitSpec)
+    .then(generateMessage)
+    .then(confirmationStep)
+    .then(commitStep)
+    .commit();

package/dist/mastra/workflows/index.d.ts

@@ -1,3 +1,4 @@
 export * from './chat.js';
 export * from './issue-labeler.js';
+export * from './commit-message.js';
 //# sourceMappingURL=index.d.ts.map

package/dist/mastra/workflows/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/mastra/workflows/index.ts"],"names":[],"mappings":"AAAA,cAAc,WAAW,CAAC;AAC1B,cAAc,oBAAoB,CAAC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/mastra/workflows/index.ts"],"names":[],"mappings":"AAAA,cAAc,WAAW,CAAC;AAC1B,cAAc,oBAAoB,CAAC;AACnC,cAAc,qBAAqB,CAAC"}

package/dist/mastra/workflows/index.js

@@ -1,2 +1,3 @@
 export * from './chat.js';
 export * from './issue-labeler.js';
+export * from './commit-message.js';

package/dist/mastra/workflows/issue-labeler.js

@@ -55,7 +55,7 @@ const labelIssue = new Step({
 
             What label or labels would you assign?
         `, {
-            schema: z.object({
+            output: z.object({
                 labels: z.array(z.string()),
             }),
         });

package/dist/mastra/workflows/publish-packages.d.ts

@@ -0,0 +1,3 @@
+import { Workflow } from '@mastra/core';
+export declare const packagePublisher: Workflow<any, any>;
+//# sourceMappingURL=publish-packages.d.ts.map

package/dist/mastra/workflows/publish-packages.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"publish-packages.d.ts","sourceRoot":"","sources":["../../../src/mastra/workflows/publish-packages.ts"],"names":[],"mappings":"AAAA,OAAO,EAAQ,QAAQ,EAAE,MAAM,cAAc,CAAC;AAM9C,eAAO,MAAM,gBAAgB,oBAE3B,CAAC"}

package/dist/mastra/workflows/publish-packages.js

@@ -0,0 +1,205 @@
+import { Step, Workflow } from '@mastra/core';
+import chalk from 'chalk';
+import { existsSync, readFileSync } from 'fs';
+import path from 'path';
+import { z } from 'zod';
+export const packagePublisher = new Workflow({
+    name: 'pnpm-changset-publisher',
+});
+const getPacakgesToPublish = new Step({
+    id: 'getPacakgesToPublish',
+    outputSchema: z.object({
+        packages: z.array(z.string()),
+        integrations: z.array(z.string()),
+        danePackage: z.string(),
+    }),
+    execute: async ({ mastra }) => {
+        const agent = mastra?.agents?.['danePackagePublisher'];
+        if (!agent) {
+            throw new Error('Agent not found');
+        }
+        const result = await agent.generate(`
+              Can you tell me which packages within the packages and integrations directory need to be published to npm?
+              `);
+        const resultObj = await agent.generate(`
+              ONLY RETURN DATA IF WE HAVE PACKAGES TO PUBLISH. If we do not, return empty arrays.
+              Can you format this for me ${result.text}?
+              @mastra/core must be first. mastra must be second. 
+              create-mastra is a package (not an integration) and should be listed in packages array.
+              @mastra/dane should be listed after packages and integrations.
+              `, {
+            output: z.object({
+                packages: z.array(z.string()),
+                integrations: z.array(z.string()),
+                danePackage: z.string(),
+            }),
+        });
+        return {
+            packages: resultObj?.object?.packages,
+            integrations: resultObj?.object?.integrations,
+            danePackage: resultObj?.object?.danePackage,
+        };
+    },
+});
+const assemblePackages = new Step({
+    id: 'assemblePackages',
+    outputSchema: z.object({
+        packages: z.array(z.string()),
+    }),
+    execute: async ({ context }) => {
+        if (context.machineContext?.stepResults.getPacakgesToPublish?.status !== 'success') {
+            return {
+                packages: [],
+            };
+        }
+        const payload = context.machineContext.stepResults.getPacakgesToPublish.payload;
+        const packagesToBuild = new Set();
+        if (payload?.packages) {
+            payload.packages.forEach((pkg) => {
+                let pkgName = pkg.replace('@mastra/', '');
+                if (pkgName === 'mastra') {
+                    pkgName = 'cli';
+                }
+                const pkgPath = path.join(process.cwd(), 'packages', pkgName);
+                packagesToBuild.add(pkgPath);
+            });
+        }
+        if (payload?.integrations) {
+            const integrations = payload.integrations;
+            integrations.forEach((integration) => {
+                let pkgName = integration.replace('@mastra/', '');
+                const integrationPath = path.join(process.cwd(), 'integrations', pkgName);
+                packagesToBuild.add(integrationPath);
+            });
+        }
+        if (payload?.danePackage) {
+            const danePackage = payload.danePackage;
+            let pkgName = danePackage.replace('@mastra/', '');
+            const danePackageMapped = path.join(process.cwd(), 'examples', pkgName);
+            const pkgJsonPath = readFileSync(path.join(danePackageMapped, 'package.json'), 'utf-8');
+            const pkgJson = JSON.parse(pkgJsonPath);
+            const dependencies = Object.keys(pkgJson.dependencies || {}).filter((dep) => dep.startsWith('@mastra/'));
+            dependencies.forEach((dep) => {
+                const pkgName = dep.replace('@mastra/', '');
+                const pkgPath = path.join(process.cwd(), 'packages', pkgName);
+                const integrationPath = path.join(process.cwd(), 'integrations', pkgName);
+                try {
+                    if (existsSync(pkgPath)) {
+                        packagesToBuild.add(pkgPath);
+                    }
+                    else {
+                        packagesToBuild.add(integrationPath);
+                    }
+                }
+                catch (e) {
+                    console.error(e);
+                }
+            });
+            packagesToBuild.add(path.join(process.cwd(), 'examples', 'dane'));
+        }
+        const pkgSet = Array.from(packagesToBuild.keys());
+        if (!packagesToBuild.size) {
+            console.error(chalk.red('No packages to build.'));
+            return {
+                packages: [],
+            };
+        }
+        return { packages: pkgSet };
+    },
+});
+const buildPackages = new Step({
+    id: 'buildPackages',
+    outputSchema: z.object({
+        packages: z.array(z.string()),
+    }),
+    execute: async ({ context, mastra }) => {
+        if (context.machineContext?.stepResults.assemblePackages?.status !== 'success') {
+            return {
+                packages: [],
+            };
+        }
+        const pkgSet = context.machineContext.stepResults.assemblePackages.payload.packages;
+        const agent = mastra?.agents?.['danePackagePublisher'];
+        if (!agent) {
+            throw new Error('Agent not found');
+        }
+        let res = await agent.generate(`
+              Here are the packages that need to be built: ${pkgSet.join(',')}.
+              Always build @mastra/core first.
+              Always build mastra second.
+              Next packages found within the 'packages' directory should be built next in parallel.
+              After packages found within the 'integrations' directory should be built in parallel.
+              dane should be built last.
+          `);
+        console.log(chalk.green(res.text));
+        return { packages: pkgSet };
+    },
+});
+const publishChangeset = new Step({
+    id: 'publishChangeset',
+    outputSchema: z.object({
+        packages: z.array(z.string()),
+    }),
+    execute: async ({ context, mastra }) => {
+        if (context.machineContext?.stepResults.buildPackages?.status !== 'success') {
+            return {
+                packages: [],
+            };
+        }
+        const pkgSet = context.machineContext.stepResults.buildPackages.payload.packages;
+        const agent = mastra?.agents?.['danePackagePublisher'];
+        if (!agent) {
+            throw new Error('Agent not found');
+        }
+        let res = await agent.generate(`
+            Publish the changeset.
+        `);
+        console.log(chalk.green(res.text));
+        return { packages: pkgSet };
+    },
+});
+const setLatestDistTag = new Step({
+    id: 'setLatestDistTag',
+    outputSchema: z.object({
+        packages: z.array(z.string()),
+    }),
+    execute: async ({ context, mastra }) => {
+        if (context.machineContext?.stepResults.publishChangeset?.status !== 'success') {
+            return {
+                packages: [],
+            };
+        }
+        const pkgSet = context.machineContext.stepResults.publishChangeset.payload.packages;
+        const agent = mastra?.agents?.['danePackagePublisher'];
+        if (!agent) {
+            throw new Error('Agent not found');
+        }
+        let res = await agent.generate(`
+            Set the active tag for these packages ${pkgSet.join(',')}.
+        `);
+        console.log(chalk.green(res.text));
+        return { packages: pkgSet };
+    },
+});
+packagePublisher
+    .step(getPacakgesToPublish)
+    .then(assemblePackages)
+    .then(buildPackages, {
+    when: async ({ context }) => {
+        return (context.stepResults.assemblePackages?.status === 'success' &&
+            context.stepResults.assemblePackages?.payload?.packages.length > 0);
+    },
+})
+    .then(publishChangeset, {
+    when: async ({ context }) => {
+        return (context.stepResults.buildPackages?.status === 'success' &&
+            context.stepResults.buildPackages?.payload?.packages.length > 0);
+    },
+})
+    .then(setLatestDistTag, {
+    when: async ({ context }) => {
+        return (context.stepResults.publishChangeset?.status === 'success' &&
+            context.stepResults.publishChangeset?.payload?.packages.length > 0);
+    },
+})
+    .commit();

package/dist/mastra/workflows/telephone-game.d.ts

@@ -0,0 +1,3 @@
+import { Workflow } from '@mastra/core';
+export declare const telephoneGameWorkflow: Workflow<any, any>;
+//# sourceMappingURL=telephone-game.d.ts.map

package/dist/mastra/workflows/telephone-game.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"telephone-game.d.ts","sourceRoot":"","sources":["../../../src/mastra/workflows/telephone-game.ts"],"names":[],"mappings":"AACA,OAAO,EAAQ,QAAQ,EAAiB,MAAM,cAAc,CAAC;AAG7D,eAAO,MAAM,qBAAqB,oBAEhC,CAAC"}