@mastra/dane 0.0.2-alpha.17 → 0.0.2-alpha.19

package/dist/commands/publish-packages.d.ts

@@ -0,0 +1,2 @@
+export declare function publishPackages(): Promise<void>;
+//# sourceMappingURL=publish-packages.d.ts.map

package/dist/commands/publish-packages.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"publish-packages.d.ts","sourceRoot":"","sources":["../../src/commands/publish-packages.ts"],"names":[],"mappings":"AAMA,wBAAsB,eAAe,kBA+EpC"}

package/dist/commands/publish-packages.js

@@ -0,0 +1,66 @@
+import chalk from 'chalk';
+import path from 'path';
+import { z } from 'zod';
+import { mastra } from '../mastra/index.js';
+export async function publishPackages() {
+    console.log(chalk.green("Hi! I'm Dane!"));
+    console.log(chalk.green('Let me publish your packages..\n'));
+    const agent = mastra.getAgent('danePackagePublisher');
+    const result = await agent.generate(`
+        Can you tell me which packages within the packages and integrations directory need to be published to npm?
+        `);
+    const resultObj = await agent.generate(`
+        Can you format this for me ${result.text}? 
+        @mastra/core must be first. 
+        @mastra/dane should be listed after packages and integrations.
+        `, {
+        schema: z.object({
+            packages: z.array(z.string()),
+            integrations: z.array(z.string()),
+            danePackage: z.string(),
+        }),
+    });
+    console.log(resultObj.object);
+    let packagesToBuild = [];
+    if (resultObj?.object?.packages) {
+        const packages = resultObj.object.packages;
+        const packagesMapped = packages.map((pkg) => {
+            let pkgName = pkg.replace('@mastra/', '');
+            if (pkgName === 'mastra') {
+                pkgName = 'cli';
+            }
+            const pkgPath = path.join(process.cwd(), 'packages', pkgName);
+            return pkgPath;
+        });
+        packagesToBuild = [...packagesMapped];
+    }
+    if (resultObj?.object?.integrations) {
+        const integrations = resultObj.object.integrations;
+        const integrationsMapped = integrations.map((integration) => {
+            let pkgName = integration.replace('@mastra/', '');
+            const integrationPath = path.join(process.cwd(), 'integrations', pkgName);
+            return integrationPath;
+        });
+        packagesToBuild = [...packagesToBuild, ...integrationsMapped];
+    }
+    if (resultObj?.object?.danePackage) {
+        const danePackage = resultObj.object.danePackage;
+        let pkgName = danePackage.replace('@mastra/', '');
+        const danePackageMapped = path.join(process.cwd(), 'examples', pkgName);
+        packagesToBuild = [...packagesToBuild, danePackageMapped];
+    }
+    console.log(packagesToBuild);
+    if (!packagesToBuild || !packagesToBuild.length) {
+        console.error(chalk.red('No packages to build.'));
+        process.exit(1);
+    }
+    let res = await agent.generate(`
+        Here are the packages that need to be built: ${packagesToBuild.join(',')}.
+        We need to build core first. And dane last. The rest can be done in parallel.
+    `);
+    console.log(chalk.green(res.text));
+    res = await agent.generate(`
+        Publish the changeset and then set the dist-tag of latest to the new version.
+    `);
+    console.log(chalk.green(result.text));
+}

package/dist/index.js

@@ -5,6 +5,7 @@ import { commitMessageCommand } from './commands/commit-message.js';
 import { configCommand } from './commands/config.js';
 import { issueLabelerCommand } from './commands/issue-labeler.js';
 import { message } from './commands/message.js';
+import { publishPackages } from './commands/publish-packages.js';
 dotenv.config();
 process.env.NODE_NO_WARNINGS = '1';
 const program = new Command();
@@ -13,6 +14,10 @@ program
     .command('issue-labeler')
     .description('Automatically label GitHub issues based on their content and context')
     .action(issueLabelerCommand);
-program.command('commit').action(commitMessageCommand);
+program
+    .command('commit')
+    .description('Create a sensible commit message based on the changes made')
+    .action(commitMessageCommand);
 program.addCommand(configCommand);
+program.command('publish').description('Publish packages to the registry').action(publishPackages);
 program.parse(process.argv);

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

@@ -1,6 +1,65 @@
 import { Agent } from '@mastra/core';
 export declare const daneCommitMessage: Agent<Record<string, import("@mastra/core").ToolAction<any, any, any, any>>>;
 export declare const daneIssueLabeler: Agent<Record<string, import("@mastra/core").ToolAction<any, any, any, any>>>;
+export declare const danePackagePublisher: Agent<{
+    execaTool: import("@mastra/core").Tool<"execaTool", import("zod").ZodObject<{
+        command: import("zod").ZodString;
+        args: import("zod").ZodArray<import("zod").ZodString, "many">;
+    }, "strip", import("zod").ZodTypeAny, {
+        command: string;
+        args: string[];
+    }, {
+        command: string;
+        args: string[];
+    }>, import("zod").ZodObject<{
+        message: import("zod").ZodString;
+    }, "strip", import("zod").ZodTypeAny, {
+        message: string;
+    }, {
+        message: string;
+    }>, import("@mastra/core").ToolExecutionContext<import("zod").ZodObject<{
+        command: import("zod").ZodString;
+        args: import("zod").ZodArray<import("zod").ZodString, "many">;
+    }, "strip", import("zod").ZodTypeAny, {
+        command: string;
+        args: string[];
+    }, {
+        command: string;
+        args: string[];
+    }>, import("@mastra/core").WorkflowContext<any>>>;
+    pnpmBuild: import("@mastra/core").Tool<"pnpmBuild", import("zod").ZodObject<{
+        name: import("zod").ZodString;
+        packagePath: import("zod").ZodString;
+    }, "strip", import("zod").ZodTypeAny, {
+        name: string;
+        packagePath: string;
+    }, {
+        name: string;
+        packagePath: string;
+    }>, import("zod").ZodObject<{
+        message: import("zod").ZodString;
+    }, "strip", import("zod").ZodTypeAny, {
+        message: string;
+    }, {
+        message: string;
+    }>, import("@mastra/core").ToolExecutionContext<import("zod").ZodObject<{
+        name: import("zod").ZodString;
+        packagePath: import("zod").ZodString;
+    }, "strip", import("zod").ZodTypeAny, {
+        name: string;
+        packagePath: string;
+    }, {
+        name: string;
+        packagePath: string;
+    }>, import("@mastra/core").WorkflowContext<any>>>;
+    pnpmChangesetPublish: import("@mastra/core").Tool<"pnpmChangesetPublish", import("zod").ZodObject<{}, "strip", import("zod").ZodTypeAny, {}, {}>, import("zod").ZodObject<{
+        message: import("zod").ZodString;
+    }, "strip", import("zod").ZodTypeAny, {
+        message: string;
+    }, {
+        message: string;
+    }>, import("@mastra/core").ToolExecutionContext<import("zod").ZodObject<{}, "strip", import("zod").ZodTypeAny, {}, {}>, import("@mastra/core").WorkflowContext<any>>>;
+}>;
 export declare const dane: Agent<{
     fsTool: import("@mastra/core").Tool<"fsTool", import("zod").ZodObject<{
         action: import("zod").ZodString;

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;AAkBrC,eAAO,MAAM,iBAAiB,8EAU5B,CAAC;AAEH,eAAO,MAAM,gBAAgB,8EAO3B,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;AAkBrC,eAAO,MAAM,iBAAiB,8EAU5B,CAAC;AAEH,eAAO,MAAM,gBAAgB,8EAO3B,CAAC;AAEH,eAAO,MAAM,oBAAoB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAY/B,CAAC;AAEH,eAAO,MAAM,IAAI;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAuDf,CAAC"}

package/dist/mastra/agents/index.js

@@ -3,7 +3,7 @@ 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';
-import { execaTool } from '../tools/execa.js';
+import { execaTool, pnpmBuild, pnpmChangesetPublish } from '../tools/execa.js';
 import { fsTool } from '../tools/fs.js';
 import { imageTool } from '../tools/image.js';
 import { readPDF } from '../tools/pdf.js';
@@ -32,6 +32,19 @@ export const daneIssueLabeler = new Agent({
     `,
     model: getBaseModelConfig(),
 });
+export const danePackagePublisher = new Agent({
+    name: 'DanePackagePublisher',
+    instructions: `
+    You are Dane, the ultimate node module publisher.
+    You help engineers publish their pnpm changesets.
+    `,
+    model: getBaseModelConfig(),
+    tools: {
+        execaTool,
+        pnpmBuild,
+        pnpmChangesetPublish,
+    },
+});
 export const dane = new Agent({
     name: 'Dane',
     instructions: `

package/dist/mastra/index.d.ts

@@ -195,6 +195,65 @@ export declare const mastra: Mastra<{
             prompt: string;
         }>, import("@mastra/core").WorkflowContext<any>>>;
     }>;
+    danePackagePublisher: import("@mastra/core").Agent<{
+        execaTool: import("@mastra/core").Tool<"execaTool", import("zod").ZodObject<{
+            command: import("zod").ZodString;
+            args: import("zod").ZodArray<import("zod").ZodString, "many">;
+        }, "strip", import("zod").ZodTypeAny, {
+            command: string;
+            args: string[];
+        }, {
+            command: string;
+            args: string[];
+        }>, import("zod").ZodObject<{
+            message: import("zod").ZodString;
+        }, "strip", import("zod").ZodTypeAny, {
+            message: string;
+        }, {
+            message: string;
+        }>, import("@mastra/core").ToolExecutionContext<import("zod").ZodObject<{
+            command: import("zod").ZodString;
+            args: import("zod").ZodArray<import("zod").ZodString, "many">;
+        }, "strip", import("zod").ZodTypeAny, {
+            command: string;
+            args: string[];
+        }, {
+            command: string;
+            args: string[];
+        }>, import("@mastra/core").WorkflowContext<any>>>;
+        pnpmBuild: import("@mastra/core").Tool<"pnpmBuild", import("zod").ZodObject<{
+            name: import("zod").ZodString;
+            packagePath: import("zod").ZodString;
+        }, "strip", import("zod").ZodTypeAny, {
+            name: string;
+            packagePath: string;
+        }, {
+            name: string;
+            packagePath: string;
+        }>, import("zod").ZodObject<{
+            message: import("zod").ZodString;
+        }, "strip", import("zod").ZodTypeAny, {
+            message: string;
+        }, {
+            message: string;
+        }>, import("@mastra/core").ToolExecutionContext<import("zod").ZodObject<{
+            name: import("zod").ZodString;
+            packagePath: import("zod").ZodString;
+        }, "strip", import("zod").ZodTypeAny, {
+            name: string;
+            packagePath: string;
+        }, {
+            name: string;
+            packagePath: string;
+        }>, import("@mastra/core").WorkflowContext<any>>>;
+        pnpmChangesetPublish: import("@mastra/core").Tool<"pnpmChangesetPublish", import("zod").ZodObject<{}, "strip", import("zod").ZodTypeAny, {}, {}>, import("zod").ZodObject<{
+            message: import("zod").ZodString;
+        }, "strip", import("zod").ZodTypeAny, {
+            message: string;
+        }, {
+            message: string;
+        }>, import("@mastra/core").ToolExecutionContext<import("zod").ZodObject<{}, "strip", import("zod").ZodTypeAny, {}, {}>, import("@mastra/core").WorkflowContext<any>>>;
+    }>;
     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>>>;
 }, {

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

package/dist/mastra/index.js

@@ -1,7 +1,7 @@
 import { Mastra } from '@mastra/core';
 import { PostgresEngine } from '@mastra/engine';
 import { UpstashKVMemory } from '@mastra/memory';
-import { dane, daneCommitMessage, daneIssueLabeler } from './agents/index.js';
+import { dane, daneCommitMessage, daneIssueLabeler, danePackagePublisher } from './agents/index.js';
 import { firecrawl } from './integrations/index.js';
 import { messageWorkflow, githubIssueLabeler, commitMessageGenerator } from './workflows/index.js';
 const engine = new PostgresEngine({
@@ -10,6 +10,7 @@ const engine = new PostgresEngine({
 export const mastra = new Mastra({
     agents: {
         dane,
+        danePackagePublisher,
         daneIssueLabeler,
         daneCommitMessage,
     },

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

@@ -24,4 +24,36 @@ export declare const execaTool: import("@mastra/core").Tool<"execaTool", z.ZodOb
     command: string;
     args: string[];
 }>, import("@mastra/core").WorkflowContext<any>>>;
+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 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>>>;
 //# sourceMappingURL=execa.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"execa.d.ts","sourceRoot":"","sources":["../../../src/mastra/tools/execa.ts"],"names":[],"mappings":"AAIA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAYxB,eAAO,MAAM,SAAS;;;;;;;;;;;;;;;;;;;;;;;;iDA2BpB,CAAC"}
+{"version":3,"file":"execa.d.ts","sourceRoot":"","sources":["../../../src/mastra/tools/execa.ts"],"names":[],"mappings":"AAIA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAYxB,eAAO,MAAM,SAAS;;;;;;;;;;;;;;;;;;;;;;;;iDA4BpB,CAAC;AAEH,eAAO,MAAM,SAAS;;;;;;;;;;;;;;;;;;;;;;;;iDA8BpB,CAAC;AAEH,eAAO,MAAM,oBAAoB;;;;;;6IA0B/B,CAAC"}

package/dist/mastra/tools/execa.js

@@ -25,6 +25,7 @@ export const execaTool = createTool({
     }),
     execute: async ({ context: { command, args } }) => {
         try {
+            console.log(chalk.green(`Running command: ${command} ${args.join(' ')}`));
             const p = execa(command, args);
             console.log(`\n`);
             p.stdout.pipe(colorTransform).pipe(process.stdout);
@@ -40,3 +41,63 @@ export const execaTool = createTool({
         }
     },
 });
+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 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' };
+        }
+    },
+});

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

@@ -3,7 +3,7 @@ import { Step, Workflow } from '@mastra/core';
 import chalk from 'chalk';
 import { execSync } from 'child_process';
 import { z } from 'zod';
-import { fsTool } from '../tools/fs';
+import { fsTool } from '../tools/fs.js';
 export const commitMessageGenerator = new Workflow({
     name: 'commit-message',
     triggerSchema: z.object({

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@mastra/dane",
-  "version": "0.0.2-alpha.17",
+  "version": "0.0.2-alpha.19",
   "main": "dist/index.js",
   "type": "module",
   "files": [
@@ -38,17 +38,18 @@
     "sqlite3": "^5.1.7",
     "typescript": "^5.5.4",
     "zod": "^3.24.0",
-    "@mastra/core": "0.1.27-alpha.45",
-    "@mastra/engine": "0.0.5-alpha.39",
-    "@mastra/firecrawl": "1.0.4-alpha.31",
-    "@mastra/memory": "0.0.2-alpha.25",
-    "@mastra/github": "1.0.3-alpha.29",
-    "@mastra/rag": "0.0.2-alpha.29",
-    "@mastra/stabilityai": "1.0.1-alpha.20"
+    "@mastra/core": "0.1.27-alpha.46",
+    "@mastra/engine": "0.0.5-alpha.40",
+    "@mastra/firecrawl": "1.0.4-alpha.32",
+    "@mastra/github": "1.0.3-alpha.30",
+    "@mastra/memory": "0.0.2-alpha.26",
+    "@mastra/rag": "0.0.2-alpha.30",
+    "@mastra/stabilityai": "1.0.1-alpha.21"
   },
   "scripts": {
     "build": "npx tsc",
     "start": "npx bun src/index.ts",
-    "test": "echo \"Error: no test specified\" && exit 1"
+    "test": "echo \"Error: no test specified\" && exit 1",
+    "prepublish": "pnpm build"
   }
 }