@mastra/dane 0.0.2-alpha.67 → 0.0.2-alpha.69

package/dist/commands/new-contributor-message.d.ts

@@ -0,0 +1,2 @@
+export declare function newContributorMessage(): Promise<void>;
+//# sourceMappingURL=new-contributor-message.d.ts.map

package/dist/commands/new-contributor-message.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"new-contributor-message.d.ts","sourceRoot":"","sources":["../../src/commands/new-contributor-message.ts"],"names":[],"mappings":"AAIA,wBAAsB,qBAAqB,kBAkC1C"}

package/dist/commands/new-contributor-message.js

@@ -0,0 +1,43 @@
+import chalk from 'chalk';
+import { mastra } from '../mastra';
+export async function newContributorMessage() {
+    console.log(chalk.green("Hi! I'm Dane!"));
+    console.log(chalk.green('Let me create a welcoming message..\n'));
+    try {
+        const workflow = mastra.getWorkflow('githubFirstContributorMessage');
+        if (!workflow) {
+            console.error(chalk.red('First contributor workflow not found. Make sure it is properly set up.'));
+            process.exit(1);
+        }
+        const { start } = workflow.createRun();
+        const result = await start({
+            triggerData: {
+                pr_number: parseInt(process.env.PR_NUMBER, 10),
+                owner: process.env.OWNER,
+                repo: normalizeRepo(process.env.REPO),
+            },
+        });
+        console.log(result);
+        const errorMessage = Object.values(result.results).find(result => result.status === 'failed')?.error;
+        if (result.results?.commit?.status !== 'success') {
+            console.error(chalk.red(`\n${errorMessage}`));
+            return;
+        }
+        console.log(chalk.green('\New contributor message generated and published successfully'));
+    }
+    catch (error) {
+        console.error(chalk.red('Error:', error?.message || 'An unknown error occurred'));
+        process.exit(1);
+    }
+}
+/**
+ * Extracts the repo name from owner/repo format provided by github
+ * @param repo - The repo name to normalize
+ * @returns The normalized repo name
+ */
+function normalizeRepo(repo) {
+    if (repo.includes('/')) {
+        return repo.split('/')[1] || repo;
+    }
+    return repo;
+}

package/dist/index.js

@@ -7,6 +7,7 @@ import { configCommand } from './commands/config.js';
 import { issueLabelerCommand } from './commands/issue-labeler.js';
 import { linkChecker } from './commands/link-checker.js';
 import { message } from './commands/message.js';
+import { newContributorMessage } from './commands/new-contributor-message.js';
 import { publishPackages } from './commands/publish-packages.js';
 import { telephone } from './commands/telephone-game.js';
 dotenv.config();
@@ -25,6 +26,7 @@ program.addCommand(configCommand);
 program.command('publish').description('Publish packages to the registry').action(publishPackages);
 program.command('telephone-game').description('Play a classic game of telephone').action(telephone);
 program.command('changelog').description('Mastra Changelog').action(changelog);
+program.command('new-contributor').description('Create a new contributor message').action(newContributorMessage);
 program
     .command('link-checker')
     .description('Check for broken links')

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;AAmBrC,eAAO,MAAM,iBAAiB,8EAU5B,CAAC;AAEH,eAAO,MAAM,gBAAgB,8EAO3B,CAAC;AAEH,eAAO,MAAM,oBAAoB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAc/B,CAAC;AAEH,eAAO,MAAM,eAAe,8EAa1B,CAAC;AAEH,eAAO,MAAM,aAAa,8EAcxB,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;AAarC,eAAO,MAAM,iBAAiB,8EAU5B,CAAC;AAEH,eAAO,MAAM,gBAAgB,8EAO3B,CAAC;AAEH,eAAO,MAAM,oBAAoB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAc/B,CAAC;AAEH,eAAO,MAAM,eAAe,8EAa1B,CAAC;AAEH,eAAO,MAAM,aAAa,8EAcxB,CAAC;AAEH,eAAO,MAAM,IAAI;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAuDf,CAAC"}

package/dist/mastra/agents/index.js

@@ -1,5 +1,4 @@
 import { Agent } from '@mastra/core';
-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';
@@ -8,12 +7,7 @@ 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',
-    name: 'claude-3-5-sonnet-20241022',
-    apiKey: config.getAnthropicApiKey(),
-});
+import { getBaseModelConfig } from './model';
 export const daneCommitMessage = new Agent({
     name: 'DaneCommitMessage',
     instructions: `

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

@@ -0,0 +1,7 @@
+export declare const getBaseModelConfig: () => {
+    provider: "ANTHROPIC";
+    toolChoice: "auto";
+    name: string;
+    apiKey: string;
+};
+//# sourceMappingURL=model.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"model.d.ts","sourceRoot":"","sources":["../../../src/mastra/agents/model.ts"],"names":[],"mappings":"AAEA,eAAO,MAAM,kBAAkB;;;;;CAK7B,CAAC"}

package/dist/mastra/agents/model.js

@@ -0,0 +1,7 @@
+import { config } from '../../config/index.js';
+export const getBaseModelConfig = () => ({
+    provider: 'ANTHROPIC',
+    toolChoice: 'auto',
+    name: 'claude-3-5-sonnet-20241022',
+    apiKey: config.getAnthropicApiKey(),
+});

package/dist/mastra/agents/new-contributor.d.ts

@@ -0,0 +1,3 @@
+import { Agent } from '@mastra/core';
+export declare const daneNewContributor: Agent<{}>;
+//# sourceMappingURL=new-contributor.d.ts.map

package/dist/mastra/agents/new-contributor.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"new-contributor.d.ts","sourceRoot":"","sources":["../../../src/mastra/agents/new-contributor.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,KAAK,EAAE,MAAM,cAAc,CAAC;AAIrC,eAAO,MAAM,kBAAkB,WAS7B,CAAC"}

package/dist/mastra/agents/new-contributor.js

@@ -0,0 +1,12 @@
+import { Agent } from '@mastra/core';
+import { getBaseModelConfig } from './model';
+export const daneNewContributor = new Agent({
+    name: 'DaneNewContributor',
+    instructions: `
+    You're Dane, the best GitHub open-source maintainer in the world.
+    Your tone is friendly and joyful.
+    When a new contributor creates a pull request, they see your message first.
+    `,
+    model: getBaseModelConfig(),
+    tools: {},
+});

package/dist/mastra/index.d.ts

@@ -284,6 +284,7 @@ export declare const mastra: Mastra<{
     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>>>;
     daneChangeLog: import("@mastra/core").Agent<Record<string, import("@mastra/core").ToolAction<any, any, any, any>>>;
+    daneNewContributor: import("@mastra/core").Agent<{}>;
 }, {
     message: import("@mastra/core").Workflow<any, import("zod").ZodObject<{
         resourceid: import("zod").ZodString;
@@ -324,6 +325,19 @@ export declare const mastra: Mastra<{
     }, {
         channelId: string;
     }>>;
+    githubFirstContributorMessage: import("@mastra/core").Workflow<any, import("zod").ZodObject<{
+        repo: import("zod").ZodString;
+        owner: import("zod").ZodString;
+        pr_number: import("zod").ZodNumber;
+    }, "strip", import("zod").ZodTypeAny, {
+        repo: string;
+        owner: string;
+        pr_number: number;
+    }, {
+        repo: string;
+        owner: string;
+        pr_number: number;
+    }>>;
     linkChecker: import("@mastra/core").Workflow<any, import("zod").ZodObject<{
         channelId: import("zod").ZodString;
         targetUrl: import("zod").ZodString;

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

package/dist/mastra/index.js

@@ -2,8 +2,10 @@ import { Mastra } from '@mastra/core';
 import { PostgresEngine } from '@mastra/engine';
 import { UpstashKVMemory } from '@mastra/memory';
 import { dane, daneChangeLog, daneCommitMessage, daneIssueLabeler, daneLinkChecker, danePackagePublisher, } from './agents/index.js';
+import { daneNewContributor } from './agents/new-contributor';
 import { firecrawl } from './integrations/index.js';
 import { changelogWorkflow } from './workflows/changelog.js';
+import { githubFirstContributorMessage } from './workflows/first-contributor';
 import { messageWorkflow, githubIssueLabeler, commitMessageGenerator } from './workflows/index.js';
 import { linkCheckerWorkflow } from './workflows/link-checker.js';
 import { packagePublisher } from './workflows/publish-packages.js';
@@ -19,6 +21,7 @@ export const mastra = new Mastra({
         daneIssueLabeler,
         daneCommitMessage,
         daneChangeLog,
+        daneNewContributor,
     },
     engine,
     memory: new UpstashKVMemory({
@@ -33,6 +36,7 @@ export const mastra = new Mastra({
         packagePublisher: packagePublisher,
         telephoneGame: telephoneGameWorkflow,
         changelog: changelogWorkflow,
+        githubFirstContributorMessage: githubFirstContributorMessage,
         linkChecker: linkCheckerWorkflow,
     },
     syncs: {

package/dist/mastra/tools/pnpm.js

@@ -17,7 +17,7 @@ export const pnpmBuild = createTool({
     }),
     execute: async ({ context: { name, packagePath } }) => {
         try {
-            console.log(chalk.green(`Building: ${name} at ${packagePath}`));
+            console.log(chalk.green(`\n Building: ${name} at ${packagePath}`));
             const p = execa(`pnpm`, ['build'], {
                 stdio: 'inherit',
                 cwd: packagePath,

package/dist/mastra/workflows/first-contributor.d.ts

@@ -0,0 +1,16 @@
+import { Workflow } from '@mastra/core';
+import { z } from 'zod';
+export declare const githubFirstContributorMessage: Workflow<any, z.ZodObject<{
+    repo: z.ZodString;
+    owner: z.ZodString;
+    pr_number: z.ZodNumber;
+}, "strip", z.ZodTypeAny, {
+    repo: string;
+    owner: string;
+    pr_number: number;
+}, {
+    repo: string;
+    owner: string;
+    pr_number: number;
+}>>;
+//# sourceMappingURL=first-contributor.d.ts.map

package/dist/mastra/workflows/first-contributor.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"first-contributor.d.ts","sourceRoot":"","sources":["../../../src/mastra/workflows/first-contributor.ts"],"names":[],"mappings":"AAAA,OAAO,EAAQ,QAAQ,EAAE,MAAM,cAAc,CAAC;AAC9C,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAIxB,eAAO,MAAM,6BAA6B;;;;;;;;;;;;GAOxC,CAAC"}

package/dist/mastra/workflows/first-contributor.js

@@ -0,0 +1,122 @@
+import { Step, Workflow } from '@mastra/core';
+import { z } from 'zod';
+import { github } from '../integrations/index.js';
+export const githubFirstContributorMessage = new Workflow({
+    name: 'github-first-contributor-message',
+    triggerSchema: z.object({
+        repo: z.string(),
+        owner: z.string(),
+        pr_number: z.number(),
+    }),
+});
+const getPullRequest = new Step({
+    id: 'getPullRequest',
+    outputSchema: z.object({
+        title: z.string(),
+        body: z.string(),
+        diff: z.string(),
+    }),
+    execute: async ({ context }) => {
+        const client = await github.getApiClient();
+        const pullRequest = await client.pullsGet({
+            path: {
+                owner: context?.machineContext?.triggerData?.owner,
+                repo: context?.machineContext?.triggerData?.repo,
+                pull_number: context?.machineContext?.triggerData?.pr_number,
+            },
+        });
+        if (!pullRequest?.data) {
+            throw new Error('Pull request not found');
+        }
+        const response = await fetch(pullRequest.data.diff_url);
+        const diff = await response.text();
+        return {
+            title: pullRequest.data.title,
+            body: pullRequest.data.body || '',
+            diff,
+        };
+    },
+});
+const generateMessage = new Step({
+    id: 'message-generator',
+    outputSchema: z.object({
+        message: z.array(z.string()),
+    }),
+    execute: async ({ context, mastra }) => {
+        const parentStep = context?.machineContext?.stepResults?.getPullRequest;
+        if (!parentStep || parentStep.status !== 'success') {
+            return { message: [] };
+        }
+        const mastraDocsRes = await fetch('https://mastra.ai/llms.txt');
+        const mastraDocs = await mastraDocsRes.text();
+        const daneNewContributor = mastra?.agents?.daneNewContributor;
+        const res = await daneNewContributor?.generate(`
+Hey Dane, given:
+START TITLE
+${parentStep?.payload?.title}
+END TITLE
+
+START BODY
+${parentStep?.payload?.body}
+END BODY
+START DIFF
+${parentStep?.payload?.diff}
+END DIFF
+
+I'll give you some more context about Mastra:
+MASTRA DOCS
+${mastraDocs}
+END MASTRA DOCS
+
+Write message to the contributor to thank them for their first contribution? And check if the following guidelines are followed, do not mention these checklist if they are actually checked:
+- Check if the body matches the diff and is not empty
+- Check if tests are added or updated
+- check if the code looks similar to what's already written
+- Ask if they have tested the changes on any of the examples
+
+VERY IMPORTANT:
+You should not summarize nor you should give advice on the code itself, only follow the guidelines.
+
+The message should bes strucutred like:
+an intro message to thank the user for their contribution
+the checklist
+and an outro that just says thank you again and that we will review it shortly. If there is no checklist we should skip thank you.
+        `, {
+            output: z.object({
+                intro: z.string(),
+                checklist: z.string().array(),
+                outro: z.string(),
+            }),
+        });
+        if (!res) {
+            throw new Error(`We couldn't generate a message`);
+        }
+        return res.object;
+    },
+});
+const createMessage = new Step({
+    id: 'create-message',
+    execute: async ({ context }) => {
+        const parentStep = context?.machineContext?.stepResults?.['message-generator'];
+        if (!parentStep || parentStep.status !== 'success') {
+            return;
+        }
+        const client = await github.getApiClient();
+        const res = await client.issuesCreateComment({
+            path: {
+                owner: context?.machineContext?.triggerData?.owner,
+                repo: context?.machineContext?.triggerData?.repo,
+                issue_number: context?.machineContext?.triggerData?.pr_number,
+            },
+            body: {
+                body: `${parentStep.payload.intro}
+
+${parentStep.payload.checklist.map((s) => `- [ ] ${s}`).join('\n')}
+
+${parentStep.payload.outro}`,
+            },
+        });
+        console.log(res);
+    },
+});
+githubFirstContributorMessage.step(getPullRequest).then(generateMessage).then(createMessage).commit();

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

@@ -19,25 +19,42 @@ const getPacakgesToPublish = new Step({
             throw new Error('Agent not found');
         }
         const result = await agent.generate(`
-              Can you tell me which packages within the packages, deployers, and integrations directory need to be published to npm?
-              `);
+        Here is my project structure in my monorepo.
+        * My core modules are in the 'packages' directory.
+        * My integrations are in the 'integrations' directory.
+        * My deployers are in the 'deployers' directory.
+
+        Can you tell me which packages within these folders 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.
-              deployers should be listed after packages.
-              @mastra/dane should be listed after packages and integrations.
-              `, {
+      Can you format the following text with my described format?
+
+      Formatting Rules:
+      * If the text I am giving you says there are no publishable packages, return empty arrays.
+      * @mastra/core must be first. 
+      * @mastra/deployer must be second.
+      * mastra must be third.
+      
+      Text: ${result.text}
+
+      Very Important:
+      * Do not include packages if we do not need to build them.
+      * create-mastra is a package (not an integration) and should be listed in packages array.
+      * @mastra/deployers-{name} should be listed after packages.
+      * @mastra/dane should be listed after packages and integrations.    
+    `, {
             output: z.object({
                 packages: z.array(z.string()),
                 integrations: z.array(z.string()),
+                deployers: z.array(z.string()),
                 danePackage: z.string(),
             }),
         });
+        console.log(resultObj.object);
         return {
             packages: resultObj?.object?.packages,
             integrations: resultObj?.object?.integrations,
+            deployers: resultObj?.object?.deployers,
             danePackage: resultObj?.object?.danePackage,
         };
     },
@@ -65,6 +82,16 @@ const assemblePackages = new Step({
                 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);
+                packagesToBuild.add(pkgPath);
+            });
+        }
         if (payload?.integrations) {
             const integrations = payload.integrations;
             integrations.forEach((integration) => {
@@ -124,18 +151,52 @@ const buildPackages = new Step({
         if (!agent) {
             throw new Error('Agent not found');
         }
+        console.log(chalk.green(`Building packages:`));
+        pkgSet.forEach((pkg) => {
+            console.log(chalk.green(pkg));
+        });
         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.
-          `);
+      Here are the packages that need to be built: ${pkgSet.join(',')}.
+
+      ## Follow the rules:
+      * @mastra/core must be first. 
+      * @mastra/deployer must be second.
+      * mastra must be third.
+
+      Packages found within the 'packages' directory should be built next in parallel.
+      Packages found within the 'integrations' directory should be built in parallel.
+      Packages found within the 'deployers' directory should be built in parallel.
+
+      Build @mastra/dane last.
+      `);
         console.log(chalk.green(res.text));
         return { packages: pkgSet };
     },
 });
+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;
+        for (const pkg of pkgSet) {
+            if (!existsSync(`${pkg}/dist`)) {
+                console.error(chalk.red(`Failed to build ${pkg}.`));
+                throw new Error(`Failed to build ${pkg}.`);
+            }
+        }
+        console.log(pkgSet);
+        return {
+            packages: pkgSet,
+        };
+    },
+});
 const publishChangeset = new Step({
     id: 'publishChangeset',
     outputSchema: z.object({
@@ -190,6 +251,12 @@ packagePublisher
         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);
+    },
 })
     .then(publishChangeset, {
     when: async ({ context }) => {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@mastra/dane",
-  "version": "0.0.2-alpha.67",
+  "version": "0.0.2-alpha.69",
   "main": "dist/index.js",
   "type": "module",
   "files": [
@@ -40,12 +40,12 @@
     "typescript": "^5.5.4",
     "zod": "^3.24.0",
     "@mastra/core": "0.1.27-alpha.66",
-    "@mastra/engine": "0.0.5-alpha.60",
+    "@mastra/firecrawl": "1.0.4-alpha.54",
     "@mastra/github": "1.0.3-alpha.50",
+    "@mastra/engine": "0.0.5-alpha.60",
+    "@mastra/rag": "0.0.2-alpha.52",
     "@mastra/memory": "0.0.2-alpha.46",
     "@mastra/stabilityai": "1.0.1-alpha.41",
-    "@mastra/firecrawl": "1.0.4-alpha.54",
-    "@mastra/rag": "0.0.2-alpha.52",
     "@mastra/mcp": "0.0.1-alpha.6"
   },
   "scripts": {