@mastra/dane 0.0.2-alpha.7 → 0.0.2-alpha.71

package/dist/mastra/workflows/chat.js

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

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

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

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

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

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

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

package/dist/mastra/workflows/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/index.d.ts

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

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

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

package/dist/mastra/workflows/index.js

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

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

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

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

@@ -0,0 +1,13 @@
+import { Workflow } from '@mastra/core';
+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,cAAc,CAAC;AAI9C,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';
+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.machineContext?.getStepPayload('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.machineContext?.getStepPayload('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';
+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"}