@mastra/dane 0.0.3 → 0.0.4

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

@@ -0,0 +1,124 @@
+import { Step, Workflow } from '@mastra/core/workflows';
+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?.triggerData?.owner,
+                repo: context?.triggerData?.repo,
+                pull_number: context?.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({
+        intro: z.string(),
+        checklist: z.string().array(),
+        outro: z.string(),
+    }),
+    execute: async ({ context, mastra }) => {
+        const parentStep = context?.steps?.getPullRequest;
+        if (!parentStep || parentStep.status !== 'success') {
+            return { intro: '', checklist: [], outro: '' };
+        }
+        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?.output?.title}
+END TITLE
+
+START BODY
+${parentStep?.output?.body}
+END BODY
+START DIFF
+${parentStep?.output?.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?.steps?.['message-generator'];
+        if (!parentStep || parentStep.status !== 'success') {
+            return;
+        }
+        const client = await github.getApiClient();
+        const res = await client.issuesCreateComment({
+            path: {
+                owner: context?.triggerData?.owner,
+                repo: context?.triggerData?.repo,
+                issue_number: context?.triggerData?.pr_number,
+            },
+            body: {
+                body: `${parentStep.output.intro}
+
+${parentStep.output.checklist.map((s) => `- [ ] ${s}`).join('\n')}
+
+${parentStep.output.outro}`,
+            },
+        });
+        console.log(res);
+    },
+});
+githubFirstContributorMessage.step(getPullRequest).then(generateMessage).then(createMessage).commit();

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

@@ -0,0 +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

@@ -0,0 +1 @@
+{"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

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

package/dist/mastra/workflows/issue-labeler.d.ts

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

package/dist/mastra/workflows/issue-labeler.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"issue-labeler.d.ts","sourceRoot":"","sources":["../../../src/mastra/workflows/issue-labeler.ts"],"names":[],"mappings":"AAAA,OAAO,EAAQ,QAAQ,EAAE,MAAM,wBAAwB,CAAC;AACxD,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAIxB,eAAO,MAAM,kBAAkB;;;;;;;;;;;;GAO7B,CAAC"}

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

@@ -0,0 +1,85 @@
+import { Step, Workflow } from '@mastra/core/workflows';
+import { z } from 'zod';
+import { github } from '../integrations/index.js';
+export const githubIssueLabeler = new Workflow({
+    name: 'github-issue-labeler',
+    triggerSchema: z.object({
+        repo: z.string(),
+        owner: z.string(),
+        issue_number: z.number(),
+    }),
+});
+const getIssue = new Step({
+    id: 'getIssue',
+    outputSchema: z.object({
+        title: z.string(),
+        body: z.string(),
+        labelNames: z.array(z.string()),
+    }),
+    execute: async ({ context }) => {
+        const client = await github.getApiClient();
+        const issue = await client.issuesGet({
+            path: {
+                // TODO: Type triggerData in context to the triggerSchema
+                owner: context?.triggerData?.owner,
+                repo: context?.triggerData?.repo,
+                issue_number: context?.triggerData?.issue_number,
+            },
+        });
+        const labels = await client.issuesListLabelsForRepo({
+            path: {
+                owner: context?.triggerData?.owner,
+                repo: context?.triggerData?.repo,
+            },
+        });
+        const labelNames = labels?.data?.map((label) => label.name);
+        return { title: issue?.data?.title, body: issue?.data?.body, labelNames: labelNames };
+    },
+});
+const labelIssue = new Step({
+    id: 'labelIssue',
+    outputSchema: z.object({
+        labels: z.array(z.string()),
+    }),
+    execute: async ({ context, mastra }) => {
+        const parentStep = context?.steps?.getIssue;
+        if (!parentStep || parentStep.status !== 'success') {
+            return { labels: [] };
+        }
+        const daneIssueLabeler = mastra?.agents?.daneIssueLabeler;
+        const res = await daneIssueLabeler?.generate(`
+            Hey Dane, given:
+            * this issue title: ${parentStep?.output?.title}
+            * this issue body: ${parentStep?.output?.body}
+            * these labels: ${parentStep?.output?.labelNames}
+
+            What label or labels would you assign?
+        `, {
+            output: z.object({
+                labels: z.array(z.string()),
+            }),
+        });
+        return { labels: res?.object?.labels };
+    },
+});
+const applyLabels = new Step({
+    id: 'applyLabels',
+    execute: async ({ context }) => {
+        const parentStep = context?.steps?.labelIssue;
+        if (!parentStep || parentStep.status !== 'success') {
+            return;
+        }
+        const client = await github.getApiClient();
+        await client.issuesAddLabels({
+            path: {
+                owner: context?.triggerData?.owner,
+                repo: context?.triggerData?.repo,
+                issue_number: context?.triggerData?.issue_number,
+            },
+            body: {
+                labels: parentStep.output.labels,
+            },
+        });
+    },
+});
+githubIssueLabeler.step(getIssue).then(labelIssue).then(applyLabels).commit();

package/dist/mastra/workflows/link-checker.d.ts

@@ -0,0 +1,13 @@
+import { Workflow } from '@mastra/core/workflows';
+import { z } from 'zod';
+export declare const linkCheckerWorkflow: Workflow<any, z.ZodObject<{
+    channelId: z.ZodString;
+    targetUrl: z.ZodString;
+}, "strip", z.ZodTypeAny, {
+    channelId: string;
+    targetUrl: string;
+}, {
+    channelId: string;
+    targetUrl: string;
+}>>;
+//# sourceMappingURL=link-checker.d.ts.map

package/dist/mastra/workflows/link-checker.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"link-checker.d.ts","sourceRoot":"","sources":["../../../src/mastra/workflows/link-checker.ts"],"names":[],"mappings":"AAAA,OAAO,EAAQ,QAAQ,EAAE,MAAM,wBAAwB,CAAC;AAIxD,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAMxB,eAAO,MAAM,mBAAmB;;;;;;;;;GAM9B,CAAC"}

package/dist/mastra/workflows/link-checker.js

@@ -0,0 +1,102 @@
+import { Step, Workflow } from '@mastra/core/workflows';
+import chalk from 'chalk';
+import child_process from 'node:child_process';
+import util from 'node:util';
+import { z } from 'zod';
+import { slack } from '../tools/mcp.js';
+const exec = util.promisify(child_process.exec);
+export const linkCheckerWorkflow = new Workflow({
+    name: 'link-checker',
+    triggerSchema: z.object({
+        channelId: z.string(),
+        targetUrl: z.string(),
+    }),
+});
+const linkSchema = z.object({
+    url: z.string(),
+    status: z.number(),
+    state: z.enum(['OK', 'BROKEN']),
+    parent: z.string().optional(),
+});
+const getBrokenLinks = new Step({
+    id: 'get-broken-links',
+    description: 'Get broken links',
+    inputSchema: z.object({
+        targetUrl: z.string(),
+    }),
+    outputSchema: z.object({
+        brokenLinks: z.array(linkSchema),
+    }),
+    execute: async ({ context }) => {
+        const targetUrl = context.targetUrl;
+        const res = await exec(`npx linkinator ${targetUrl} --format json`, {
+            encoding: 'utf-8',
+        });
+        if (res.stderr) {
+            throw new Error(res.stderr);
+        }
+        const data = JSON.parse(res.stdout);
+        const parsedData = linkSchema.array().parse(data.links);
+        return {
+            brokenLinks: parsedData.filter(link => link.state === 'BROKEN'),
+        };
+    },
+});
+const reportBrokenLinks = new Step({
+    id: 'report-broken-links',
+    description: 'Report broken links',
+    outputSchema: z.object({
+        message: z.string(),
+    }),
+    execute: async ({ context, mastra }) => {
+        const brokenLinks = context?.getStepResult('get-broken-links');
+        if (!brokenLinks) {
+            return {
+                message: 'No broken links found',
+            };
+        }
+        if (brokenLinks.brokenLinks.length === 0) {
+            return {
+                message: 'No broken links found',
+            };
+        }
+        try {
+            await slack.connect();
+        }
+        catch (e) {
+            console.error(e);
+        }
+        const triggerPayload = context?.getStepResult('trigger');
+        if (!triggerPayload) {
+            return {
+                message: 'Trigger payload not found',
+            };
+        }
+        const agent = mastra?.agents?.daneLinkChecker;
+        if (!agent) {
+            return {
+                message: 'Agent not found',
+            };
+        }
+        const tools = await slack.tools();
+        console.log(`🤖Generating...`);
+        const res = await agent.generate(`
+      Send this ${JSON.stringify(brokenLinks, null, 2)} to this slack channel: "${triggerPayload.channelId}" with the tool slack_post_message.
+      Format it in markdown so it displays nicely in slack.
+      `, {
+            toolsets: { slack: tools },
+        });
+        console.log(chalk.green(res.text));
+        return {
+            message: res.text,
+        };
+    },
+});
+linkCheckerWorkflow
+    .step(getBrokenLinks, {
+    variables: {
+        targetUrl: { step: 'trigger', path: 'targetUrl' },
+    },
+})
+    .then(reportBrokenLinks)
+    .commit();

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

@@ -0,0 +1,3 @@
+import { Workflow } from '@mastra/core/workflows';
+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,wBAAwB,CAAC;AAYxD,eAAO,MAAM,gBAAgB,oBAE3B,CAAC"}

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

@@ -0,0 +1,252 @@
+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';
+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()),
+//   speech: z.array(z.string()),
+//   // combined deprecated stores
+//   combined_stores: z.array(z.string()),
+// });
+// const defaultSet = {
+//   packages: [],
+//   deployers: [],
+//   integrations: [],
+//   speech: [],
+//   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[], 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()),
+//           combined_stores: z.array(z.string()),
+//           speech: z.array(z.string()),
+//         }),
+//       },
+//     );
+//     return {
+//       packages: resultObj?.object?.packages!,
+//       integrations: resultObj?.object?.integrations!,
+//       deployers: resultObj?.object?.deployers!,
+//       combined_stores: resultObj?.object?.stores!,
+//       speech: resultObj?.object?.speech!,
+//     };
+//   },
+// });
+// const assemblePackages = new Step({
+//   id: 'assemblePackages',
+//   outputSchema,
+//   execute: async ({ context }) => {
+//     if (context?.steps.getPacakgesToPublish?.status !== 'success') {
+//       return {
+//         packages: [],
+//         integrations: [],
+//         deployers: [],
+//         combined_stores: [],
+//         speech: [],
+//       };
+//     }
+//     const payload = context.steps.getPacakgesToPublish.output;
+//     const packagesToBuild: Set<string> = new Set();
+//     const deployersToBuild: Set<string> = new Set();
+//     const integrationsToBuild: 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?.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 combinedStoreSet = Array.from(combined_storesToBuild.keys());
+//     const speechSet = Array.from(speechToBuild.keys());
+//     if (
+//       !packagesToBuild.size &&
+//       !deployersToBuild.size &&
+//       !integrationsToBuild.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 (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!,
+//       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(),
+        });
+    },
+});
+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(),
+        });
+    },
+});
+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),
+                    });
+                }
+            }
+        }
+        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,
+                });
+            }
+            catch (error) {
+                console.error(chalk.red(`Failed to set dist tag for ${pkg.name}: ${error.message}`));
+            }
+        }
+    },
+});
+packagePublisher.step(buildAllPackages).then(publishAllPackages).then(setAllDistTags).commit();

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

@@ -0,0 +1,3 @@
+import { Workflow } from '@mastra/core/workflows';
+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":"AAGA,OAAO,EAAQ,QAAQ,EAAiB,MAAM,wBAAwB,CAAC;AAWvE,eAAO,MAAM,qBAAqB,oBAEhC,CAAC"}