@mastra/dane 0.0.2-alpha.115 → 0.0.2-alpha.117

package/dist/mastra/agents/package-publisher.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"package-publisher.d.ts","sourceRoot":"","sources":["../../../src/mastra/agents/package-publisher.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,KAAK,EAAE,MAAM,oBAAoB,CAAC;AAqD3C,eAAO,MAAM,oBAAoB,iwBAa5B,CAAC;AAEN,eAAO,MAAM,qBAAqB,aAAc,MAAM,EAAE,WAyDvD,CAAC;AAEF,eAAO,MAAM,uBAAuB,u2BAwBnC,CAAC;AAEF,eAAO,MAAM,oBAAoB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iDA+B/B,CAAC"}
+{"version":3,"file":"package-publisher.d.ts","sourceRoot":"","sources":["../../../src/mastra/agents/package-publisher.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,KAAK,EAAE,MAAM,oBAAoB,CAAC;AA0D3C,eAAO,MAAM,oBAAoB,iwBAa5B,CAAC;AAEN,eAAO,MAAM,qBAAqB,aAAc,MAAM,EAAE,WA8DvD,CAAC;AAEF,eAAO,MAAM,uBAAuB,u2BAwBnC,CAAC;AAEF,eAAO,MAAM,oBAAoB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iDA+B/B,CAAC"}

package/dist/mastra/agents/package-publisher.js

@@ -31,11 +31,16 @@ const packages_llm_text = `
   - Format: @mastra/store-{name} -> storage/{name}
   - Example: @mastra/store-pg -> storage/pg
 
-  ## 5. Speech packages - STRICT RULES:
+  ## 5. Store packages - STRICT RULES:
+  - ALL store packages must be directly under stores/
+  - Format: @mastra/{name} -> stores/{name}
+  - Example: @mastra/pg -> stores/pg
+
+  ## 6. Speech packages - STRICT RULES:
   - ALL speech packages must be directly under speech/
   - Format: @mastra/speech-{name} -> speech/{name}
 
-  ## 6. Integrations - STRICT RULES:
+  ## 7. Integrations - STRICT RULES:
   - ALL integration packages are under integrations/
   @mastra/composio -> integrations/composio
   @mastra/github -> integrations/github
@@ -104,6 +109,11 @@ export const BUILD_PACKAGES_PROMPT = (packages) => `
               <description>Build storage/ directory packages</description>
               <action>Use pnpmBuild for each @mastra/store-* package</action>
             </parallel_phase>
+
+            <parallel_phase name="stores">
+              <description>Build stores/ directory packages</description>
+              <action>Use pnpmBuild for each @mastra/* package in stores/</action>
+            </parallel_phase>
           </phase>
         </execution_plan>
 

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,EAAuB,MAAM,cAAc,CAAC;AAc3D,eAAO,MAAM,MAAM;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;mJAiCjB,CAAC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/mastra/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,MAAM,EAAE,MAAM,cAAc,CAAC;AAetC,eAAO,MAAM,MAAM;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;mJAiCjB,CAAC"}

package/dist/mastra/index.js

@@ -1,6 +1,7 @@
-import { Mastra, MastraStorageLibSql } from '@mastra/core';
+import { Mastra } from '@mastra/core';
+import { DefaultStorage } from '@mastra/core/storage';
 import { Memory } from '@mastra/memory';
-import { UpstashStore } from '@mastra/store-upstash';
+import { UpstashStore } from '@mastra/upstash';
 import { dane, daneChangeLog, daneCommitMessage, daneIssueLabeler, daneLinkChecker } from './agents/index.js';
 import { daneNewContributor } from './agents/new-contributor.js';
 import { danePackagePublisher } from './agents/package-publisher.js';
@@ -20,7 +21,7 @@ export const mastra = new Mastra({
         daneChangeLog,
         daneNewContributor,
     },
-    storage: new MastraStorageLibSql({
+    storage: new DefaultStorage({
         config: {
             url: ':memory:',
         },

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

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

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

@@ -1,387 +1,299 @@
 import { Step, Workflow } from '@mastra/core/workflows';
 import chalk from 'chalk';
+import { execa } from 'execa';
 import { existsSync } from 'fs';
+import { readFileSync } from 'fs';
 import path from 'path';
-import { z } from 'zod';
-import { PACKAGES_LIST_PROMPT, PUBLISH_PACKAGES_PROMPT } from '../agents/package-publisher.js';
-import { pnpmBuild } from '../tools/pnpm.js';
+// import { z } from 'zod';
+// import { PACKAGES_LIST_PROMPT, /*PUBLISH_PACKAGES_PROMPT*/ } from '../agents/package-publisher.js';
+// import { pnpmBuild } from '../tools/pnpm.js';
 export const packagePublisher = new Workflow({
     name: 'pnpm-changset-publisher',
 });
-const outputSchema = z.object({
-    packages: z.array(z.string()),
-    integrations: z.array(z.string()),
-    deployers: z.array(z.string()),
-    vector_stores: z.array(z.string()),
-    stores: z.array(z.string()),
-    speech: z.array(z.string()),
-});
-const defaultSet = {
-    packages: [],
-    deployers: [],
-    integrations: [],
-    vector_stores: [],
-    stores: [],
-    speech: [],
-};
-const getPacakgesToPublish = new Step({
-    id: 'getPacakgesToPublish',
-    outputSchema,
-    execute: async ({ mastra }) => {
-        const agent = mastra?.agents?.['danePackagePublisher'];
-        if (!agent) {
-            throw new Error('Agent not found');
-        }
-        const result = await agent.generate(PACKAGES_LIST_PROMPT);
-        console.log(chalk.green(`\n${result.text}`));
-        const resultObj = await agent.generate(`
-      Please convert this into a structured object:
-
-      Input Text: ${result.text}
-
-      1. Order Requirements:
-         - @mastra/core MUST be first within packages
-         - @mastra/deployer MUST be second within packages
-         - Group parallel builds by directory type
-
-      2. Output Format:
-         - Group into: packages[], integrations[], deployers[], vector_stores[], stores[]
-         - Place create-mastra in packages[] array
-         - Maintain correct order within each group
-
-      3. Critical Rules:
-         - Never publish without building first
-         - Only include packages that need updates
-         - Follow dependency order strictly
-    `, {
-            output: z.object({
-                packages: z.array(z.string()),
-                integrations: z.array(z.string()),
-                deployers: z.array(z.string()),
-                vector_stores: z.array(z.string()),
-                stores: z.array(z.string()),
-                speech: z.array(z.string()),
-            }),
+// const outputSchema = z.object({
+//   packages: z.array(z.string()),
+//   integrations: z.array(z.string()),
+//   deployers: z.array(z.string()),
+//   speech: z.array(z.string()),
+//   // deprecated
+//   vector_stores: z.array(z.string()),
+//   stores: z.array(z.string()),
+//   // combined deprecated stores
+//   combined_stores: z.array(z.string()),
+// });
+// const defaultSet = {
+//   packages: [],
+//   deployers: [],
+//   integrations: [],
+//   speech: [],
+//   // deprecated
+//   vector_stores: [],
+//   stores: [],
+//   // combined vector + storage
+//   combined_stores: [],
+// };
+// const getPacakgesToPublish = new Step({
+//   id: 'getPacakgesToPublish',
+//   outputSchema,
+//   execute: async ({ mastra }) => {
+//     const agent = mastra?.agents?.['danePackagePublisher'];
+//     if (!agent) {
+//       throw new Error('Agent not found');
+//     }
+//     const result = await agent.generate(PACKAGES_LIST_PROMPT);
+//     console.log(chalk.green(`\n${result.text}`));
+//     const resultObj = await agent.generate(
+//       `
+//       Please convert this into a structured object:
+//       Input Text: ${result.text}
+//       1. Order Requirements:
+//          - @mastra/core MUST be first within packages
+//          - @mastra/deployer MUST be second within packages
+//          - Group parallel builds by directory type
+//       2. Output Format:
+//          - Group into: packages[], integrations[], deployers[], vector_stores[], stores[], combined_stores[]
+//          - Place create-mastra in packages[] array
+//          - Maintain correct order within each group
+//       3. Critical Rules:
+//          - Never publish without building first
+//          - Only include packages that need updates
+//          - Follow dependency order strictly
+//     `,
+//       {
+//         output: z.object({
+//           packages: z.array(z.string()),
+//           integrations: z.array(z.string()),
+//           deployers: z.array(z.string()),
+//           vector_stores: z.array(z.string()),
+//           stores: z.array(z.string()),
+//           combined_stores: z.array(z.string()),
+//           speech: z.array(z.string()),
+//         }),
+//       },
+//     );
+//     return {
+//       packages: resultObj?.object?.packages!,
+//       integrations: resultObj?.object?.integrations!,
+//       deployers: resultObj?.object?.deployers!,
+//       vector_stores: resultObj?.object?.vector_stores!,
+//       stores: resultObj?.object?.stores!,
+//       combined_stores: resultObj?.object?.stores!,
+//       speech: resultObj?.object?.speech!,
+//     };
+//   },
+// });
+// const assemblePackages = new Step({
+//   id: 'assemblePackages',
+//   outputSchema,
+//   execute: async ({ context }) => {
+//     if (context.machineContext?.stepResults.getPacakgesToPublish?.status !== 'success') {
+//       return {
+//         packages: [],
+//         integrations: [],
+//         deployers: [],
+//         vector_stores: [],
+//         stores: [],
+//         combined_stores: [],
+//         speech: [],
+//       };
+//     }
+//     const payload = context.machineContext.stepResults.getPacakgesToPublish.payload;
+//     const packagesToBuild: Set<string> = new Set();
+//     const deployersToBuild: Set<string> = new Set();
+//     const integrationsToBuild: Set<string> = new Set();
+//     const vector_storesToBuild: Set<string> = new Set();
+//     const storesToBuild: Set<string> = new Set();
+//     const combined_storesToBuild: Set<string> = new Set();
+//     const speechToBuild: Set<string> = new Set();
+//     if (payload?.packages) {
+//       payload.packages.forEach((pkg: string) => {
+//         let pkgName = pkg.replace('@mastra/', '');
+//         if (pkgName === 'mastra') {
+//           pkgName = 'cli';
+//         }
+//         const pkgPath = path.join(process.cwd(), 'packages', pkgName);
+//         packagesToBuild.add(pkgPath);
+//       });
+//     }
+//     if (payload?.deployers) {
+//       payload.deployers.forEach((pkg: string) => {
+//         let pkgName = pkg.replace('@mastra/deployer-', '');
+//         if (pkgName === 'mastra') {
+//           pkgName = 'cli';
+//         }
+//         const pkgPath = path.join(process.cwd(), 'deployers', pkgName);
+//         deployersToBuild.add(pkgPath);
+//       });
+//     }
+//     if (payload?.vector_stores) {
+//       payload.vector_stores.forEach((pkg: string) => {
+//         let pkgName = pkg.replace('@mastra/vector-', '');
+//         const pkgPath = path.join(process.cwd(), 'vector-stores', pkgName);
+//         vector_storesToBuild.add(pkgPath);
+//       });
+//     }
+//     if (payload?.stores) {
+//       payload.stores.forEach((pkg: string) => {
+//         let pkgName = pkg.replace('@mastra/store-', '');
+//         const pkgPath = path.join(process.cwd(), 'storage', pkgName);
+//         storesToBuild.add(pkgPath);
+//       });
+//     }
+//     if (payload?.combined_stores) {
+//       payload.combined_stores.forEach((pkg: string) => {
+//         let pkgName = pkg.replace('@mastra/', '');
+//         const pkgPath = path.join(process.cwd(), 'stores', pkgName);
+//         combined_storesToBuild.add(pkgPath);
+//       });
+//     }
+//     if (payload?.integrations) {
+//       const integrations = payload.integrations;
+//       integrations.forEach((integration: string) => {
+//         let pkgName = integration.replace('@mastra/', '');
+//         const integrationPath = path.join(process.cwd(), 'integrations', pkgName);
+//         integrationsToBuild.add(integrationPath);
+//       });
+//     }
+//     if (payload?.speech) {
+//       const speecs = payload.speech;
+//       speecs.forEach((speech: string) => {
+//         let pkgName = speech.replace('@mastra/speech-', '');
+//         const speechPath = path.join(process.cwd(), 'speech', pkgName);
+//         speechToBuild.add(speechPath);
+//       });
+//     }
+//     const pkgSet = Array.from(packagesToBuild.keys());
+//     const deploySet = Array.from(deployersToBuild.keys());
+//     const integrationSet = Array.from(integrationsToBuild.keys());
+//     const vectorStoreSet = Array.from(vector_storesToBuild.keys());
+//     const storeSet = Array.from(storesToBuild.keys());
+//     const combinedStoreSet = Array.from(combined_storesToBuild.keys());
+//     const speechSet = Array.from(speechToBuild.keys());
+//     if (
+//       !packagesToBuild.size &&
+//       !deployersToBuild.size &&
+//       !integrationsToBuild.size &&
+//       !vector_storesToBuild.size &&
+//       !storesToBuild.size &&
+//       !combined_storesToBuild.size
+//     ) {
+//       console.error(chalk.red('No packages to build.'));
+//       return defaultSet;
+//     }
+//     console.log(chalk.green(`\nBuilding packages:\n`));
+//     pkgSet.forEach((pkg: string) => {
+//       console.log(chalk.green(pkg));
+//     });
+//     if (deploySet.length > 0) {
+//       console.log(chalk.green(`\nBuilding deployers:\n`));
+//       deploySet.forEach((pkg: string) => {
+//         console.log(chalk.green(pkg));
+//       });
+//     }
+//     if (integrationSet.length > 0) {
+//       console.log(chalk.green(`\nBuilding integrations:\n`));
+//       integrationSet.forEach((pkg: string) => {
+//         console.log(chalk.green(pkg));
+//       });
+//     }
+//     if (vectorStoreSet.length > 0) {
+//       console.log(chalk.green(`\nBuilding vector stores:\n`));
+//       vectorStoreSet.forEach((pkg: string) => {
+//         console.log(chalk.green(pkg));
+//       });
+//     }
+//     if (storeSet.length > 0) {
+//       console.log(chalk.green(`\nBuilding storage packages:\n`));
+//       storeSet.forEach((pkg: string) => {
+//         console.log(chalk.green(pkg));
+//       });
+//     }
+//     if (combinedStoreSet.length > 0) {
+//       console.log(chalk.green(`\nBuilding store packages:\n`));
+//       combinedStoreSet.forEach((pkg: string) => {
+//         console.log(chalk.green(pkg));
+//       });
+//     }
+//     if (speechSet.length > 0) {
+//       console.log(chalk.green(`\nBuilding speech:\n`));
+//       speechSet.forEach((pkg: string) => {
+//         console.log(chalk.green(pkg));
+//       });
+//     }
+//     return {
+//       packages: pkgSet!,
+//       deployers: deploySet!,
+//       integrations: integrationSet!,
+//       vector_stores: vectorStoreSet!,
+//       stores: storeSet!,
+//       combined_stores: combinedStoreSet!,
+//       speech: speechSet!,
+//     };
+//   },
+// });
+const buildAllPackages = new Step({
+    id: 'buildPackages',
+    execute: async () => {
+        console.log(chalk.green('Building all packages'));
+        await execa('pnpm', ['run', 'build'], {
+            stdio: 'inherit',
+            reject: false,
+            cwd: process.cwd(),
         });
-        return {
-            packages: resultObj?.object?.packages,
-            integrations: resultObj?.object?.integrations,
-            deployers: resultObj?.object?.deployers,
-            vector_stores: resultObj?.object?.vector_stores,
-            stores: resultObj?.object?.stores,
-            speech: resultObj?.object?.speech,
-        };
     },
 });
-const assemblePackages = new Step({
-    id: 'assemblePackages',
-    outputSchema,
-    execute: async ({ context }) => {
-        if (context.machineContext?.stepResults.getPacakgesToPublish?.status !== 'success') {
-            return {
-                packages: [],
-                integrations: [],
-                deployers: [],
-                vector_stores: [],
-                stores: [],
-                speech: [],
-            };
-        }
-        const payload = context.machineContext.stepResults.getPacakgesToPublish.payload;
-        const packagesToBuild = new Set();
-        const deployersToBuild = new Set();
-        const integrationsToBuild = new Set();
-        const vector_storesToBuild = new Set();
-        const storesToBuild = new Set();
-        const speechToBuild = 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?.deployers) {
-            payload.deployers.forEach((pkg) => {
-                let pkgName = pkg.replace('@mastra/deployer-', '');
-                if (pkgName === 'mastra') {
-                    pkgName = 'cli';
-                }
-                const pkgPath = path.join(process.cwd(), 'deployers', pkgName);
-                deployersToBuild.add(pkgPath);
-            });
-        }
-        if (payload?.vector_stores) {
-            payload.vector_stores.forEach((pkg) => {
-                let pkgName = pkg.replace('@mastra/vector-', '');
-                const pkgPath = path.join(process.cwd(), 'vector-stores', pkgName);
-                vector_storesToBuild.add(pkgPath);
-            });
-        }
-        if (payload?.stores) {
-            payload.stores.forEach((pkg) => {
-                let pkgName = pkg.replace('@mastra/store-', '');
-                const pkgPath = path.join(process.cwd(), 'storage', pkgName);
-                storesToBuild.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);
-                integrationsToBuild.add(integrationPath);
-            });
-        }
-        if (payload?.speech) {
-            const speecs = payload.speech;
-            speecs.forEach((speech) => {
-                let pkgName = speech.replace('@mastra/speech-', '');
-                const speechPath = path.join(process.cwd(), 'speech', pkgName);
-                speechToBuild.add(speechPath);
-            });
-        }
-        const pkgSet = Array.from(packagesToBuild.keys());
-        const deploySet = Array.from(deployersToBuild.keys());
-        const integrationSet = Array.from(integrationsToBuild.keys());
-        const vectorStoreSet = Array.from(vector_storesToBuild.keys());
-        const storeSet = Array.from(storesToBuild.keys());
-        const speechSet = Array.from(speechToBuild.keys());
-        if (!packagesToBuild.size &&
-            !deployersToBuild.size &&
-            !integrationsToBuild.size &&
-            !vector_storesToBuild.size &&
-            !storesToBuild.size) {
-            console.error(chalk.red('No packages to build.'));
-            return defaultSet;
-        }
-        console.log(chalk.green(`\nBuilding packages:\n`));
-        pkgSet.forEach((pkg) => {
-            console.log(chalk.green(pkg));
+const publishAllPackages = new Step({
+    id: 'publishPackages',
+    execute: async () => {
+        console.log(chalk.green('Publishing all packages'));
+        await execa('pnpm', ['changeset', 'publish'], {
+            stdio: 'inherit',
+            reject: false,
+            cwd: process.cwd(),
         });
-        if (deploySet.length > 0) {
-            console.log(chalk.green(`\nBuilding deployers:\n`));
-            deploySet.forEach((pkg) => {
-                console.log(chalk.green(pkg));
-            });
-        }
-        if (integrationSet.length > 0) {
-            console.log(chalk.green(`\nBuilding integrations:\n`));
-            integrationSet.forEach((pkg) => {
-                console.log(chalk.green(pkg));
-            });
-        }
-        if (vectorStoreSet.length > 0) {
-            console.log(chalk.green(`\nBuilding vector stores:\n`));
-            vectorStoreSet.forEach((pkg) => {
-                console.log(chalk.green(pkg));
-            });
-        }
-        if (storeSet.length > 0) {
-            console.log(chalk.green(`\nBuilding storage packages:\n`));
-            storeSet.forEach((pkg) => {
-                console.log(chalk.green(pkg));
-            });
-        }
-        if (speechSet.length > 0) {
-            console.log(chalk.green(`\nBuilding speech:\n`));
-            speechSet.forEach((pkg) => {
-                console.log(chalk.green(pkg));
-            });
-        }
-        return {
-            packages: pkgSet,
-            deployers: deploySet,
-            integrations: integrationSet,
-            vector_stores: vectorStoreSet,
-            stores: storeSet,
-            speech: speechSet,
-        };
     },
 });
-const buildPackages = new Step({
-    id: 'buildPackages',
-    outputSchema,
-    execute: async ({ context, mastra }) => {
-        if (context.machineContext?.stepResults.assemblePackages?.status !== 'success') {
-            return defaultSet;
-        }
-        const pkgSet = context.machineContext.stepResults.assemblePackages.payload.packages;
-        const deploySet = context.machineContext.stepResults.assemblePackages.payload.deployers;
-        const integrationSet = context.machineContext.stepResults.assemblePackages.payload.integrations;
-        const vectorStoreSet = context.machineContext.stepResults.assemblePackages.payload.vector_stores;
-        const storeSet = context.machineContext.stepResults.assemblePackages.payload.stores;
-        const speechSet = context.machineContext.stepResults.assemblePackages.payload.speech;
-        console.log({
-            pkgSet,
-            deploySet,
-            integrationSet,
-            vectorStoreSet,
-            storeSet,
-            speechSet,
-        });
-        const agent = mastra?.agents?.['danePackagePublisher'];
-        if (!agent) {
-            throw new Error('Agent not found');
+const setAllDistTags = new Step({
+    id: 'setAllDistTags',
+    execute: async () => {
+        console.log(chalk.green('Setting dist tags for all packages'));
+        // Get all package.json files from relevant directories
+        const packageDirs = ['packages', 'deployers', 'storage', 'vector-stores', 'stores', 'integrations', 'speech'];
+        const packages = [];
+        for (const dir of packageDirs) {
+            const dirPath = path.join(process.cwd(), dir);
+            if (!existsSync(dirPath))
+                continue;
+            const { stdout } = await execa('find', [dirPath, '-name', 'package.json'], {
+                reject: false,
+            });
+            const packagePaths = stdout.split('\n').filter(Boolean);
+            for (const packagePath of packagePaths) {
+                const pkgJson = JSON.parse(readFileSync(packagePath, 'utf-8'));
+                if (pkgJson.name && pkgJson.version) {
+                    packages.push({
+                        name: pkgJson.name,
+                        version: pkgJson.version,
+                        path: path.dirname(packagePath),
+                    });
+                }
+            }
         }
-        async function buildSet(list) {
-            for (const pkg of list) {
-                await pnpmBuild.execute({
-                    context: {
-                        name: pkg,
-                        packagePath: pkg,
-                    },
-                    suspend: async () => { },
+        console.log(packages);
+        // Set dist tags for each package
+        for (const pkg of packages) {
+            console.log(chalk.blue(`Setting dist tag for ${pkg.name}@${pkg.version}`));
+            try {
+                await execa('npm', ['dist-tag', 'add', `${pkg.name}@${pkg.version}`, 'latest'], {
+                    stdio: 'inherit',
+                    cwd: pkg.path,
+                    reject: false,
                 });
             }
-        }
-        let built = false;
-        if (pkgSet.length > 0) {
-            built = true;
-            await buildSet(pkgSet);
-        }
-        if (deploySet.length > 0) {
-            await buildSet(deploySet);
-            built = true;
-        }
-        if (integrationSet.length > 0) {
-            await buildSet(integrationSet);
-            built = true;
-        }
-        if (vectorStoreSet.length > 0) {
-            await buildSet(vectorStoreSet);
-            built = true;
-        }
-        if (speechSet.length > 0) {
-            await buildSet(speechSet);
-            built = true;
-        }
-        if (!built) {
-            console.error(chalk.red('Failed to build one or more packages'));
-            throw new Error('Failed to build one or more packages');
-        }
-        return {
-            packages: pkgSet,
-            deployers: deploySet,
-            integrations: integrationSet,
-            vector_stores: vectorStoreSet,
-            stores: storeSet,
-            speech: speechSet,
-        };
-    },
-});
-const verifyBuild = new Step({
-    id: 'verifyBuild',
-    outputSchema: z.object({
-        packages: z.array(z.string()),
-    }),
-    execute: async ({ context }) => {
-        if (context.machineContext?.stepResults.buildPackages?.status !== 'success') {
-            return {
-                packages: [],
-            };
-        }
-        const pkgSet = context.machineContext.stepResults.buildPackages.payload.packages;
-        const deploySet = context.machineContext.stepResults.buildPackages.payload.deployers;
-        const integrationSet = context.machineContext.stepResults.buildPackages.payload.integrations;
-        const vectorStoreSet = context.machineContext.stepResults.buildPackages.payload.vector_stores;
-        const storeSet = context.machineContext.stepResults.buildPackages.payload.stores;
-        const speechSet = context.machineContext.stepResults.buildPackages.payload.speech;
-        const allPackages = [...pkgSet, ...deploySet, ...integrationSet, ...vectorStoreSet, ...storeSet, ...speechSet];
-        function checkMissingPackages(pkgSet) {
-            const missingPackages = [];
-            for (const pkg of pkgSet) {
-                if (!existsSync(`${pkg}/dist`)) {
-                    console.error(chalk.red(`We did not find the dist folder for ${pkg}.`));
-                    missingPackages.push(pkg);
-                }
+            catch (error) {
+                console.error(chalk.red(`Failed to set dist tag for ${pkg.name}: ${error.message}`));
             }
-            return missingPackages;
-        }
-        console.log('Verifying the output for:', context.machineContext.stepResults.buildPackages.payload.allPackages);
-        const missingPackages = checkMissingPackages(allPackages);
-        if (missingPackages.length > 0) {
-            console.error(chalk.red(`Missing packages: ${missingPackages.join(', ')}`));
-            throw new Error('Failed to build one or more packages');
-        }
-        return {
-            packages: allPackages,
-        };
-    },
-});
-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');
-        }
-        const res = await agent.generate(PUBLISH_PACKAGES_PROMPT);
-        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(verifyBuild, {
-    when: async ({ context }) => {
-        return (context.stepResults.buildPackages?.status === 'success' &&
-            context.stepResults.buildPackages?.payload?.packages.length > 0);
-    },
-})
-    .after(verifyBuild)
-    .step(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();
+packagePublisher.step(buildAllPackages).then(publishAllPackages).then(setAllDistTags).commit();

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@mastra/dane",
-  "version": "0.0.2-alpha.115",
+  "version": "0.0.2-alpha.117",
   "main": "dist/index.js",
   "type": "module",
   "files": [
@@ -20,7 +20,7 @@
     "@types/node": "^22.10.2",
     "@types/pdf-parse": "^1.1.4",
     "tsx": "^4.19.2",
-    "mastra": "0.2.0-alpha.144"
+    "mastra": "0.2.0-alpha.150"
   },
   "dependencies": {
     "@inquirer/prompts": "^7.2.1",
@@ -41,13 +41,13 @@
     "sqlite3": "^5.1.7",
     "typescript": "^5.7.3",
     "zod": "^3.24.0",
-    "@mastra/core": "0.2.0-alpha.91",
-    "@mastra/mcp": "0.1.0-alpha.33",
-    "@mastra/github": "1.0.3-alpha.76",
-    "@mastra/rag": "0.1.0-alpha.83",
-    "@mastra/store-upstash": "0.0.0-alpha.10",
-    "@mastra/memory": "0.1.0-alpha.73",
-    "@mastra/stabilityai": "1.0.1-alpha.66"
+    "@mastra/core": "0.2.0-alpha.93",
+    "@mastra/mcp": "0.1.0-alpha.35",
+    "@mastra/memory": "0.1.0-alpha.75",
+    "@mastra/github": "1.0.3-alpha.78",
+    "@mastra/upstash": "0.1.0-alpha.3",
+    "@mastra/rag": "0.1.0-alpha.86",
+    "@mastra/stabilityai": "1.0.1-alpha.68"
   },
   "scripts": {
     "build": "npx tsc",