@mastra/dane 0.0.2-alpha.24 → 0.0.2-alpha.26

package/dist/commands/publish-packages.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"publish-packages.d.ts","sourceRoot":"","sources":["../../src/commands/publish-packages.ts"],"names":[],"mappings":"AAOA,wBAAsB,eAAe,kBAuFpC"}
+{"version":3,"file":"publish-packages.d.ts","sourceRoot":"","sources":["../../src/commands/publish-packages.ts"],"names":[],"mappings":"AAIA,wBAAsB,eAAe,kBASpC"}

package/dist/commands/publish-packages.js

@@ -1,73 +1,9 @@
 import chalk from 'chalk';
-import { readFileSync } from 'fs';
-import path from 'path';
-import { z } from 'zod';
 import { mastra } from '../mastra/index.js';
 export async function publishPackages() {
     console.log(chalk.green("Hi! I'm Dane!"));
     console.log(chalk.green('Let me publish your packages..\n'));
-    const agent = mastra.getAgent('danePackagePublisher');
-    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/dane should be listed after packages and integrations.
-        `, {
-        schema: z.object({
-            packages: z.array(z.string()),
-            integrations: z.array(z.string()),
-            danePackage: z.string(),
-        }),
-    });
-    console.log(resultObj.object);
-    const packagesToBuild = new Set();
-    if (resultObj?.object?.packages) {
-        const packages = resultObj.object.packages;
-        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 (resultObj?.object?.integrations) {
-        const integrations = resultObj.object.integrations;
-        integrations.forEach((integration) => {
-            let pkgName = integration.replace('@mastra/', '');
-            const integrationPath = path.join(process.cwd(), 'integrations', pkgName);
-            packagesToBuild.add(integrationPath);
-        });
-    }
-    if (resultObj?.object?.danePackage) {
-        const danePackage = resultObj.object.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);
-            packagesToBuild.add(pkgPath);
-        });
-        packagesToBuild.add(danePackage);
-    }
-    const pkgSet = Array.from(packagesToBuild.keys());
-    if (!packagesToBuild.size) {
-        console.error(chalk.red('No packages to build.'));
-        process.exit(0);
-    }
-    let res = await agent.generate(`
-        Here are the packages that need to be built: ${pkgSet.join(',')}.
-        We need to build core first. And dane last. The rest can be done in parallel.
-    `);
-    console.log(chalk.green(res.text));
-    res = await agent.generate(`
-        Publish the changeset and then set the dist-tag of latest to the new version.
-    `);
-    console.log(chalk.green(result.text));
+    const workflow = mastra.getWorkflow('packagePublisher');
+    const result = await workflow.execute();
+    console.log(result);
 }

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

@@ -66,6 +66,25 @@ export declare const danePackagePublisher: Agent<{
     }, {
         message: string[];
     }>, import("@mastra/core").ToolExecutionContext<import("zod").ZodObject<{}, "strip", import("zod").ZodTypeAny, {}, {}>, import("@mastra/core").WorkflowContext<any>>>;
+    activeDistTag: import("@mastra/core").Tool<"activeDistTag", import("zod").ZodObject<{
+        packagePath: import("zod").ZodString;
+    }, "strip", import("zod").ZodTypeAny, {
+        packagePath: string;
+    }, {
+        packagePath: string;
+    }>, import("zod").ZodObject<{
+        message: import("zod").ZodString;
+    }, "strip", import("zod").ZodTypeAny, {
+        message: string;
+    }, {
+        message: string;
+    }>, import("@mastra/core").ToolExecutionContext<import("zod").ZodObject<{
+        packagePath: import("zod").ZodString;
+    }, "strip", import("zod").ZodTypeAny, {
+        packagePath: string;
+    }, {
+        packagePath: string;
+    }>, import("@mastra/core").WorkflowContext<any>>>;
 }>;
 export declare const dane: Agent<{
     fsTool: import("@mastra/core").Tool<"fsTool", import("zod").ZodObject<{

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

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/mastra/agents/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,KAAK,EAAE,MAAM,cAAc,CAAC;AAkBrC,eAAO,MAAM,iBAAiB,8EAU5B,CAAC;AAEH,eAAO,MAAM,gBAAgB,8EAO3B,CAAC;AAEH,eAAO,MAAM,oBAAoB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAa/B,CAAC;AAEH,eAAO,MAAM,IAAI;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAuDf,CAAC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/mastra/agents/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,KAAK,EAAE,MAAM,cAAc,CAAC;AAmBrC,eAAO,MAAM,iBAAiB,8EAU5B,CAAC;AAEH,eAAO,MAAM,gBAAgB,8EAO3B,CAAC;AAEH,eAAO,MAAM,oBAAoB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAc/B,CAAC;AAEH,eAAO,MAAM,IAAI;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAuDf,CAAC"}

package/dist/mastra/agents/index.js

@@ -3,10 +3,11 @@ import { config } from '../../config/index.js';
 import { browserTool, googleSearch } from '../tools/browser.js';
 import { listEvents } from '../tools/calendar.js';
 import { crawl } from '../tools/crawl.js';
-import { execaTool, pnpmBuild, pnpmChangesetPublish, pnpmChangesetStatus } from '../tools/execa.js';
+import { execaTool } from '../tools/execa.js';
 import { fsTool } from '../tools/fs.js';
 import { imageTool } from '../tools/image.js';
 import { readPDF } from '../tools/pdf.js';
+import { activeDistTag, pnpmBuild, pnpmChangesetPublish, pnpmChangesetStatus } from '../tools/pnpm.js';
 const getBaseModelConfig = () => ({
     provider: 'ANTHROPIC',
     toolChoice: 'auto',
@@ -44,6 +45,7 @@ export const danePackagePublisher = new Agent({
         pnpmBuild,
         pnpmChangesetPublish,
         pnpmChangesetStatus,
+        activeDistTag,
     },
 });
 export const dane = new Agent({

package/dist/mastra/index.d.ts

@@ -260,6 +260,25 @@ export declare const mastra: Mastra<{
         }, {
             message: string[];
         }>, import("@mastra/core").ToolExecutionContext<import("zod").ZodObject<{}, "strip", import("zod").ZodTypeAny, {}, {}>, import("@mastra/core").WorkflowContext<any>>>;
+        activeDistTag: import("@mastra/core").Tool<"activeDistTag", import("zod").ZodObject<{
+            packagePath: import("zod").ZodString;
+        }, "strip", import("zod").ZodTypeAny, {
+            packagePath: string;
+        }, {
+            packagePath: string;
+        }>, import("zod").ZodObject<{
+            message: import("zod").ZodString;
+        }, "strip", import("zod").ZodTypeAny, {
+            message: string;
+        }, {
+            message: string;
+        }>, import("@mastra/core").ToolExecutionContext<import("zod").ZodObject<{
+            packagePath: import("zod").ZodString;
+        }, "strip", import("zod").ZodTypeAny, {
+            packagePath: string;
+        }, {
+            packagePath: string;
+        }>, import("@mastra/core").WorkflowContext<any>>>;
     }>;
     daneIssueLabeler: import("@mastra/core").Agent<Record<string, import("@mastra/core").ToolAction<any, any, any, any>>>;
     daneCommitMessage: import("@mastra/core").Agent<Record<string, import("@mastra/core").ToolAction<any, any, any, any>>>;
@@ -294,5 +313,6 @@ export declare const mastra: Mastra<{
     }, {
         repoPath: string;
     }>>;
+    packagePublisher: import("@mastra/core").Workflow<any, any>;
 }, import("@mastra/core").BaseLogger<import("@mastra/core").BaseLogMessage>>;
 //# sourceMappingURL=index.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/mastra/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,MAAM,EAAE,MAAM,cAAc,CAAC;AAYtC,eAAO,MAAM,MAAM;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;4EAsBjB,CAAC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/mastra/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,MAAM,EAAE,MAAM,cAAc,CAAC;AAatC,eAAO,MAAM,MAAM;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;4EAuBjB,CAAC"}

package/dist/mastra/index.js

@@ -4,6 +4,7 @@ import { UpstashKVMemory } from '@mastra/memory';
 import { dane, daneCommitMessage, daneIssueLabeler, danePackagePublisher } from './agents/index.js';
 import { firecrawl } from './integrations/index.js';
 import { messageWorkflow, githubIssueLabeler, commitMessageGenerator } from './workflows/index.js';
+import { packagePublisher } from './workflows/publish-packages.js';
 const engine = new PostgresEngine({
     url: 'postgres://postgres:postgres@localhost:5433/mastra',
 });
@@ -24,6 +25,7 @@ export const mastra = new Mastra({
         message: messageWorkflow,
         githubIssueLabeler: githubIssueLabeler,
         commitMessage: commitMessageGenerator,
+        packagePublisher: packagePublisher,
     },
     logger: false,
     syncs: {

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

@@ -24,43 +24,4 @@ export declare const execaTool: import("@mastra/core").Tool<"execaTool", z.ZodOb
     command: string;
     args: string[];
 }>, import("@mastra/core").WorkflowContext<any>>>;
-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>>>;
 //# sourceMappingURL=execa.d.ts.map

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

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

package/dist/mastra/tools/execa.js

@@ -41,93 +41,3 @@ export const execaTool = createTool({
         }
     },
 });
-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' };
-        }
-    },
-});

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...`));
+            const p = execa(`npm`, ['dist-tag', `${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/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,188 @@
+import { Step, Workflow } from '@mastra/core';
+import chalk from 'chalk';
+import { 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/dane should be listed after packages and integrations.
+              `, {
+            schema: 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);
+                packagesToBuild.add(pkgPath);
+            });
+            packagesToBuild.add(danePackage);
+        }
+        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(',')}.
+              We need to build core first. And dane last. The rest can be done in parallel.
+          `);
+        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/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@mastra/dane",
-  "version": "0.0.2-alpha.24",
+  "version": "0.0.2-alpha.26",
   "main": "dist/index.js",
   "type": "module",
   "files": [
@@ -42,9 +42,9 @@
     "@mastra/engine": "0.0.5-alpha.40",
     "@mastra/firecrawl": "1.0.4-alpha.32",
     "@mastra/memory": "0.0.2-alpha.26",
+    "@mastra/rag": "0.0.2-alpha.30",
     "@mastra/github": "1.0.3-alpha.30",
-    "@mastra/stabilityai": "1.0.1-alpha.21",
-    "@mastra/rag": "0.0.2-alpha.30"
+    "@mastra/stabilityai": "1.0.1-alpha.21"
   },
   "scripts": {
     "build": "npx tsc",