@mastra/dane 0.0.2-alpha.4 → 0.0.2-alpha.40

package/dist/mastra/tools/image.js

@@ -0,0 +1,37 @@
+import { createTool } from '@mastra/core';
+import chalk from 'chalk';
+import { writeFileSync } from 'fs';
+import { resolve } from 'path';
+import { z } from 'zod';
+import { stabilityai } from '../integrations/index.js';
+export const imageTool = createTool({
+    id: 'imageTool',
+    name: 'imageTool',
+    description: 'Generate an image based on a text prompt',
+    inputSchema: z.object({
+        directory: z.string(),
+        prompt: z.string(),
+    }),
+    outputSchema: z.object({
+        message: z.string(),
+    }),
+    execute: async ({ context: { directory, prompt } }) => {
+        try {
+            console.log('\n' + chalk.blue(`Generating image...`));
+            const generateImageResult = await stabilityai.generateImage(prompt);
+            const file = resolve(directory, generateImageResult.filename);
+            writeFileSync(file, generateImageResult.buffer);
+            console.log(chalk.blue(`Successfully generated: ${file}`));
+            return {
+                message: `Successfully created ${file}`,
+            };
+        }
+        catch (e) {
+            if (e instanceof Error) {
+                console.log(`\n${chalk.red(e.message)}`);
+                return { message: e.message };
+            }
+            return { message: 'Error' };
+        }
+    },
+});

package/dist/mastra/tools/pdf.d.ts

@@ -18,3 +18,4 @@ export declare const readPDF: import("@mastra/core").Tool<"readPDF", z.ZodObject
 }, {
     pdfPath: string;
 }>, import("@mastra/core").WorkflowContext<any>>>;
+//# sourceMappingURL=pdf.d.ts.map

package/dist/mastra/tools/pdf.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"pdf.d.ts","sourceRoot":"","sources":["../../../src/mastra/tools/pdf.ts"],"names":[],"mappings":"AAIA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAKxB,eAAO,MAAM,OAAO;;;;;;;;;;;;;;;;;;iDAsClB,CAAC"}

package/dist/mastra/tools/pdf.js

@@ -2,8 +2,9 @@ import { createTool } from '@mastra/core';
 import chalk from 'chalk';
 import { existsSync, readFileSync } from 'fs';
 import path from 'path';
-import pdf from 'pdf-parse';
 import { z } from 'zod';
+// @ts-ignore
+import pdfParse from 'pdf-parse/lib/pdf-parse.js';
 export const readPDF = createTool({
     id: 'readPDF',
     name: 'Read PDF',
@@ -27,7 +28,7 @@ export const readPDF = createTool({
             // Read the PDF file
             const dataBuffer = readFileSync(pdfPath);
             // Parse PDF content
-            const data = await pdf(dataBuffer);
+            const data = await pdfParse(dataBuffer);
             console.log(chalk.blue('\n'));
             console.log(chalk.blue('PDF Information:'));
             console.log(chalk.blue('-----------------'));

package/dist/mastra/tools/pnpm.d.ts

@@ -0,0 +1,60 @@
+import { z } from 'zod';
+export declare const pnpmBuild: import("@mastra/core").Tool<"pnpmBuild", z.ZodObject<{
+    name: z.ZodString;
+    packagePath: z.ZodString;
+}, "strip", z.ZodTypeAny, {
+    name: string;
+    packagePath: string;
+}, {
+    name: string;
+    packagePath: string;
+}>, z.ZodObject<{
+    message: z.ZodString;
+}, "strip", z.ZodTypeAny, {
+    message: string;
+}, {
+    message: string;
+}>, import("@mastra/core").ToolExecutionContext<z.ZodObject<{
+    name: z.ZodString;
+    packagePath: z.ZodString;
+}, "strip", z.ZodTypeAny, {
+    name: string;
+    packagePath: string;
+}, {
+    name: string;
+    packagePath: string;
+}>, import("@mastra/core").WorkflowContext<any>>>;
+export declare const pnpmChangesetStatus: import("@mastra/core").Tool<"pnpmChangesetStatus", z.ZodObject<{}, "strip", z.ZodTypeAny, {}, {}>, z.ZodObject<{
+    message: z.ZodArray<z.ZodString, "many">;
+}, "strip", z.ZodTypeAny, {
+    message: string[];
+}, {
+    message: string[];
+}>, import("@mastra/core").ToolExecutionContext<z.ZodObject<{}, "strip", z.ZodTypeAny, {}, {}>, import("@mastra/core").WorkflowContext<any>>>;
+export declare const pnpmChangesetPublish: import("@mastra/core").Tool<"pnpmChangesetPublish", z.ZodObject<{}, "strip", z.ZodTypeAny, {}, {}>, z.ZodObject<{
+    message: z.ZodString;
+}, "strip", z.ZodTypeAny, {
+    message: string;
+}, {
+    message: string;
+}>, import("@mastra/core").ToolExecutionContext<z.ZodObject<{}, "strip", z.ZodTypeAny, {}, {}>, import("@mastra/core").WorkflowContext<any>>>;
+export declare const activeDistTag: import("@mastra/core").Tool<"activeDistTag", z.ZodObject<{
+    packagePath: z.ZodString;
+}, "strip", z.ZodTypeAny, {
+    packagePath: string;
+}, {
+    packagePath: string;
+}>, z.ZodObject<{
+    message: z.ZodString;
+}, "strip", z.ZodTypeAny, {
+    message: string;
+}, {
+    message: string;
+}>, import("@mastra/core").ToolExecutionContext<z.ZodObject<{
+    packagePath: z.ZodString;
+}, "strip", z.ZodTypeAny, {
+    packagePath: string;
+}, {
+    packagePath: string;
+}>, import("@mastra/core").WorkflowContext<any>>>;
+//# sourceMappingURL=pnpm.d.ts.map

package/dist/mastra/tools/pnpm.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"pnpm.d.ts","sourceRoot":"","sources":["../../../src/mastra/tools/pnpm.ts"],"names":[],"mappings":"AAKA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAExB,eAAO,MAAM,SAAS;;;;;;;;;;;;;;;;;;;;;;;;iDA8BpB,CAAC;AAEH,eAAO,MAAM,mBAAmB;;;;;;6IA8B9B,CAAC;AAEH,eAAO,MAAM,oBAAoB;;;;;;6IA0B/B,CAAC;AAEH,eAAO,MAAM,aAAa;;;;;;;;;;;;;;;;;;iDA8BxB,CAAC"}

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 to latest for ${pkgJson.name}@${version}`));
+            const p = execa(`npm`, ['dist-tag', `add`, `${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

@@ -10,3 +10,4 @@ export declare const messageWorkflow: Workflow<any, z.ZodObject<{
     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

@@ -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,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
+      `, {
+            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/index.d.ts

@@ -1,2 +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

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

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

@@ -13,3 +13,4 @@ export declare const githubIssueLabeler: Workflow<any, z.ZodObject<{
     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

@@ -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/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"}