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

package/dist/mastra/tools/pnpm.js

@@ -0,0 +1,128 @@
+import { createTool } from '@mastra/core';
+import chalk from 'chalk';
+import { execa, ExecaError } from 'execa';
+import { readFileSync } from 'fs';
+import path from 'path';
+import { z } from 'zod';
+export const pnpmBuild = createTool({
+    id: 'pnpmBuild',
+    name: 'PNPM Build Tool',
+    description: 'Used to build the pnpm module',
+    inputSchema: z.object({
+        name: z.string(),
+        packagePath: z.string(),
+    }),
+    outputSchema: z.object({
+        message: z.string(),
+    }),
+    execute: async ({ context: { name, packagePath } }) => {
+        try {
+            console.log(chalk.green(`Building: ${name} at ${packagePath}`));
+            const p = execa(`pnpm`, ['build'], {
+                stdio: 'inherit',
+                cwd: packagePath,
+                reject: false,
+            });
+            console.log(`\n`);
+            await p;
+            return { message: 'Done' };
+        }
+        catch (e) {
+            console.error(e);
+            if (e instanceof ExecaError) {
+                return { message: e.message };
+            }
+            return { message: 'Error' };
+        }
+    },
+});
+export const pnpmChangesetStatus = createTool({
+    id: 'pnpmChangesetStatus',
+    name: 'PNPM Changeset Status Tool',
+    description: 'Used to check which pnpm modules need to be published',
+    inputSchema: z.object({}),
+    outputSchema: z.object({
+        message: z.array(z.string()),
+    }),
+    execute: async () => {
+        try {
+            console.log('Checking');
+            const { stdout } = await execa('pnpm', ['publish', '-r', '--dry-run', '--no-git-checks'], {
+                all: true,
+                // We want to see stderr too since pnpm sometimes puts important info there
+                stderr: 'inherit',
+            });
+            const lines = stdout.split('\n');
+            const filteredLines = lines.filter(line => line.startsWith('+'));
+            const packages = filteredLines.map(line => line.trim().substring(2).split('@').slice(0, -1).join('@'));
+            return { message: packages };
+        }
+        catch (e) {
+            console.error(e);
+            if (e instanceof ExecaError) {
+                return { message: [e.message] };
+            }
+            return { message: ['Error'] };
+        }
+    },
+});
+export const pnpmChangesetPublish = createTool({
+    id: 'pnpmChangesetPublish',
+    name: 'PNPM Changeset Publish Tool',
+    description: 'Used to publish the pnpm module',
+    inputSchema: z.object({}),
+    outputSchema: z.object({
+        message: z.string(),
+    }),
+    execute: async () => {
+        try {
+            console.log(chalk.green(`Publishing...`));
+            const p = execa(`pnpm`, ['changeset', 'publish'], {
+                stdio: 'inherit',
+                reject: false,
+            });
+            console.log(`\n`);
+            await p;
+            return { message: 'Done' };
+        }
+        catch (e) {
+            console.error(e);
+            if (e instanceof ExecaError) {
+                return { message: e.message };
+            }
+            return { message: 'Error' };
+        }
+    },
+});
+export const activeDistTag = createTool({
+    id: 'activeDistTag',
+    name: 'PNPM Changeset set active tag',
+    description: 'Used to set active tag on the pnpm module',
+    inputSchema: z.object({
+        packagePath: z.string(),
+    }),
+    outputSchema: z.object({
+        message: z.string(),
+    }),
+    execute: async ({ context }) => {
+        try {
+            const pkgJson = JSON.parse(readFileSync(path.join(context.packagePath, 'package.json'), 'utf-8'));
+            const version = pkgJson.version;
+            console.log(chalk.green(`Setting active tag...`));
+            const p = execa(`npm`, ['dist-tag', `${pkgJson.name}@${version}`, `latest`], {
+                stdio: 'inherit',
+                reject: false,
+            });
+            console.log(`\n`);
+            await p;
+            return { message: 'Done' };
+        }
+        catch (e) {
+            console.error(e);
+            if (e instanceof ExecaError) {
+                return { message: e.message };
+            }
+            return { message: 'Error' };
+        }
+    },
+});

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

@@ -0,0 +1,13 @@
+import { Workflow } from '@mastra/core';
+import { z } from 'zod';
+export declare const messageWorkflow: Workflow<any, z.ZodObject<{
+    resourceid: z.ZodString;
+    threadId: z.ZodString;
+}, "strip", z.ZodTypeAny, {
+    resourceid: string;
+    threadId: string;
+}, {
+    resourceid: string;
+    threadId: string;
+}>>;
+//# sourceMappingURL=chat.d.ts.map

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

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

package/dist/mastra/workflows/chat.js

@@ -0,0 +1,89 @@
+import { input } from '@inquirer/prompts';
+import { Step, Workflow } from '@mastra/core';
+import chalk from 'chalk';
+import { z } from 'zod';
+import { dane } from '../agents/index.js';
+export const messageWorkflow = new Workflow({
+    name: 'entry',
+    triggerSchema: z.object({
+        resourceid: z.string(),
+        threadId: z.string(),
+    }),
+});
+const messageStep = new Step({
+    id: 'message-input',
+    outputSchema: z.object({
+        message: z.string(),
+    }),
+    execute: async () => {
+        const content = await input({
+            message: '\n You:',
+            validate: input => input.trim().length > 0 || 'Message cannot be empty',
+        });
+        return { message: content };
+    },
+});
+const messageOutputStep = new Step({
+    id: 'message-output',
+    outputSchema: z.object({
+        message: z.string(),
+    }),
+    // SHOULD BE ABLE TO ACCESS ALL MASTRA PRIMS FROM EXECTUE
+    execute: async ({ context, mastra }) => {
+        // WISH THIS WAS TYPED
+        const threadId = context?.machineContext?.triggerData?.threadId;
+        const resourceid = context?.machineContext?.triggerData?.resourceid;
+        const messageInputStatus = context?.machineContext?.stepResults?.['message-input']?.status;
+        if (messageInputStatus !== 'success') {
+            return { message: 'Failure in workflow' };
+        }
+        // is there someway to know what steps are flowing into this one and type their props
+        const message = context?.machineContext?.stepResults?.['message-input']?.payload?.message;
+        try {
+            let messages = await mastra?.memory?.getContextWindow({
+                threadId,
+                format: 'core_message',
+            });
+            if (!messages || messages.length === 0) {
+                messages = [];
+            }
+            const res = await mastra?.agents?.['dane']?.generate(message, {
+                stream: true,
+                maxSteps: 5,
+                resourceid,
+                threadId,
+                context: [],
+            });
+            if (res) {
+                console.log(chalk.green(`\nDane: \n`));
+                for await (const chunk of res.textStream) {
+                    process.stdout.write(chalk.green(chunk));
+                }
+                console.log(chalk.green(`\n`));
+                return { message: 'success' };
+            }
+        }
+        catch (e) {
+            console.log(chalk.red(`\n`));
+            console.log(chalk.red(`\n`));
+            console.log(chalk.red(`Error streaming results. Let's try again.`));
+            if (e instanceof Error) {
+                console.log(chalk.red(e.message));
+            }
+        }
+        const res = await dane.generate(message, {
+            maxSteps: 5,
+            threadId,
+            resourceid,
+        });
+        console.log(chalk.green(res?.text));
+        return { message: res?.text };
+    },
+});
+messageWorkflow
+    .step(messageStep)
+    .after(messageStep)
+    .step(messageOutputStep)
+    .after(messageOutputStep)
+    .step(messageStep)
+    .commit();

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,137 @@
+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?.triggerData?.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 () => {
+        const fileData = await fsTool.execute({
+            context: { action: 'read', file: 'data/crawl/conventional-commit.json', data: '' },
+        });
+        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 diffStep = context?.machineContext?.stepResults?.getDiff;
+        const fileDataStep = context?.machineContext?.stepResults?.readConventionalCommitSpec;
+        if (!diffStep || diffStep.status !== 'success') {
+            return { commitMessage: '', generated: false, guidelines: [] };
+        }
+        const daneCommitGenerator = mastra?.agents?.daneCommitMessage;
+        const res = await daneCommitGenerator?.generate(`
+        Given this git diff:
+        ${diffStep.payload.diff}
+
+        IF THE DIFF IS EMPTY, RETURN "No staged changes found", AND SET GENERATED TO FALSE,
+        OTHERWISE, SET GENERATED TO TRUE
+
+        ${fileDataStep?.status === 'success' && fileDataStep?.payload?.fileData?.message
+            ? `USE THE FOLLOWING GUIDELINES: ${fileDataStep?.payload?.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
+      `, {
+            schema: 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/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';
+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,cAAc,CAAC;AAC9C,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';
+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 machineContext to the triggerSchema
+                owner: context?.machineContext?.triggerData?.owner,
+                repo: context?.machineContext?.triggerData?.repo,
+                issue_number: context?.machineContext?.triggerData?.issue_number,
+            },
+        });
+        const labels = await client.issuesListLabelsForRepo({
+            path: {
+                owner: context?.machineContext?.triggerData?.owner,
+                repo: context?.machineContext?.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?.machineContext?.stepResults?.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?.payload?.title}
+            * this issue body: ${parentStep?.payload?.body}
+            * these labels: ${parentStep?.payload?.labelNames}
+
+            What label or labels would you assign?
+        `, {
+            schema: z.object({
+                labels: z.array(z.string()),
+            }),
+        });
+        return { labels: res?.object?.labels };
+    },
+});
+const applyLabels = new Step({
+    id: 'applyLabels',
+    execute: async ({ context }) => {
+        const parentStep = context?.machineContext?.stepResults?.labelIssue;
+        if (!parentStep || parentStep.status !== 'success') {
+            return;
+        }
+        const client = await github.getApiClient();
+        await client.issuesAddLabels({
+            path: {
+                owner: context?.machineContext?.triggerData?.owner,
+                repo: context?.machineContext?.triggerData?.repo,
+                issue_number: context?.machineContext?.triggerData?.issue_number,
+            },
+            body: {
+                labels: parentStep.payload.labels,
+            },
+        });
+    },
+});
+githubIssueLabeler.step(getIssue).then(labelIssue).then(applyLabels).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"}