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

package/dist/mastra/index.js

@@ -1,16 +1,27 @@
 import { Mastra } from '@mastra/core';
 import { PostgresEngine } from '@mastra/engine';
 import { UpstashKVMemory } from '@mastra/memory';
-import { dane, daneIssueLabeler } from './agents/index.js';
+import { dane, daneChangeLog, daneCommitMessage, daneIssueLabeler, daneLinkChecker, danePackagePublisher, } from './agents/index.js';
+import { daneNewContributor } from './agents/new-contributor';
 import { firecrawl } from './integrations/index.js';
-import { messageWorkflow, githubIssueLabeler } from './workflows/index.js';
+import { changelogWorkflow } from './workflows/changelog.js';
+import { githubFirstContributorMessage } from './workflows/first-contributor';
+import { messageWorkflow, githubIssueLabeler, commitMessageGenerator } from './workflows/index.js';
+import { linkCheckerWorkflow } from './workflows/link-checker.js';
+import { packagePublisher } from './workflows/publish-packages.js';
+import { telephoneGameWorkflow } from './workflows/telephone-game.js';
 const engine = new PostgresEngine({
     url: 'postgres://postgres:postgres@localhost:5433/mastra',
 });
 export const mastra = new Mastra({
     agents: {
         dane,
+        danePackagePublisher,
+        daneLinkChecker,
         daneIssueLabeler,
+        daneCommitMessage,
+        daneChangeLog,
+        daneNewContributor,
     },
     engine,
     memory: new UpstashKVMemory({
@@ -21,8 +32,13 @@ export const mastra = new Mastra({
     workflows: {
         message: messageWorkflow,
         githubIssueLabeler: githubIssueLabeler,
+        commitMessage: commitMessageGenerator,
+        packagePublisher: packagePublisher,
+        telephoneGame: telephoneGameWorkflow,
+        changelog: changelogWorkflow,
+        githubFirstContributorMessage: githubFirstContributorMessage,
+        linkChecker: linkCheckerWorkflow,
     },
-    logger: false,
     syncs: {
         ...firecrawl.getSyncs(),
     },

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

@@ -1,5 +1,7 @@
 import { FirecrawlIntegration } from "@mastra/firecrawl";
 import { GithubIntegration } from "@mastra/github";
+import { StabilityAiIntegration } from "@mastra/stabilityai";
 export declare const firecrawl: FirecrawlIntegration;
 export declare const github: GithubIntegration;
+export declare const stabilityai: StabilityAiIntegration;
 //# sourceMappingURL=index.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/mastra/integrations/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,oBAAoB,EAAE,MAAM,mBAAmB,CAAC;AACzD,OAAO,EAAE,iBAAiB,EAAE,MAAM,gBAAgB,CAAC;AAEnD,eAAO,MAAM,SAAS,sBAIpB,CAAC;AAEH,eAAO,MAAM,MAAM,mBAIjB,CAAA"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/mastra/integrations/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,oBAAoB,EAAE,MAAM,mBAAmB,CAAC;AACzD,OAAO,EAAE,iBAAiB,EAAE,MAAM,gBAAgB,CAAC;AACnD,OAAO,EAAE,sBAAsB,EAAE,MAAM,qBAAqB,CAAC;AAc7D,eAAO,MAAM,SAAS,sBAIpB,CAAC;AAEH,eAAO,MAAM,MAAM,mBAIjB,CAAC;AAEH,eAAO,MAAM,WAAW,wBAItB,CAAC"}

package/dist/mastra/integrations/index.js

@@ -1,12 +1,29 @@
 import { FirecrawlIntegration } from "@mastra/firecrawl";
 import { GithubIntegration } from "@mastra/github";
+import { StabilityAiIntegration } from "@mastra/stabilityai";
+import { config } from "../../config/index.js";
+// Helper function to get key from config or env
+const getApiKey = (configKey, envKey) => {
+    const configValue = config.get(configKey);
+    if (configValue)
+        return configValue;
+    const envValue = process.env[envKey];
+    if (envValue)
+        return envValue;
+    return '';
+};
 export const firecrawl = new FirecrawlIntegration({
     config: {
-        API_KEY: process.env.FIRECRAWL_API_KEY,
+        API_KEY: getApiKey('FIRECRAWL_API_KEY', 'FIRECRAWL_API_KEY'),
     },
 });
 export const github = new GithubIntegration({
     config: {
-        PERSONAL_ACCESS_TOKEN: process.env.GITHUB_PERSONAL_ACCESS_TOKEN,
+        PERSONAL_ACCESS_TOKEN: getApiKey('GITHUB_PERSONAL_ACCESS_TOKEN', 'GITHUB_PERSONAL_ACCESS_TOKEN'),
+    }
+});
+export const stabilityai = new StabilityAiIntegration({
+    config: {
+        API_KEY: getApiKey('STABILITYAI_API_KEY', 'STABILITYAI_API_KEY'),
     }
 });

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

@@ -13,10 +13,13 @@ export declare const crawl: import("@mastra/core").Tool<"crawler", z.ZodObject<{
     limit?: number | undefined;
 }>, z.ZodObject<{
     message: z.ZodString;
+    crawlData: z.ZodAny;
 }, "strip", z.ZodTypeAny, {
     message: string;
+    crawlData?: any;
 }, {
     message: string;
+    crawlData?: any;
 }>, import("@mastra/core").ToolExecutionContext<z.ZodObject<{
     url: z.ZodString;
     limit: z.ZodDefault<z.ZodNumber>;

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

@@ -1 +1 @@
-{"version":3,"file":"crawl.d.ts","sourceRoot":"","sources":["../../../src/mastra/tools/crawl.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAExB,eAAO,MAAM,KAAK;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iDAsBhB,CAAC"}
+{"version":3,"file":"crawl.d.ts","sourceRoot":"","sources":["../../../src/mastra/tools/crawl.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAExB,eAAO,MAAM,KAAK;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iDAwBhB,CAAC"}

package/dist/mastra/tools/crawl.js

@@ -11,14 +11,16 @@ export const crawl = createTool({
     }),
     outputSchema: z.object({
         message: z.string(),
+        crawlData: z.any(),
     }),
     execute: async ({ context, mastra }) => {
-        await mastra?.syncs?.['FIRECRAWL:CRAWL_AND_SYNC']?.execute({
+        const crawlData = await mastra?.syncs?.['FIRECRAWL:CRAWL_AND_SYNC']?.execute({
             context,
-            mastra,
+            engine: mastra?.engine,
         });
         return {
             message: 'The website has been successfully crawled and chunks have been synced to the database. Finish.',
+            crawlData,
         };
     },
 });

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;;;;;;;;;;;;;;;;;;;;;;;;iDAwBpB,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"}

package/dist/mastra/tools/execa.js

@@ -1,6 +1,6 @@
 import { createTool } from '@mastra/core';
 import chalk from 'chalk';
-import { execa } from 'execa';
+import { execa, ExecaError } from 'execa';
 import { Transform } from 'stream';
 import { z } from 'zod';
 // Create transform stream that applies chalk
@@ -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);
@@ -33,6 +34,9 @@ export const execaTool = createTool({
             return { message: r.stdout };
         }
         catch (e) {
+            if (e instanceof ExecaError) {
+                return { message: e.message };
+            }
             return { message: 'Error' };
         }
     },

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

@@ -0,0 +1,27 @@
+import { z } from 'zod';
+export declare const imageTool: import("@mastra/core").Tool<"imageTool", z.ZodObject<{
+    directory: z.ZodString;
+    prompt: z.ZodString;
+}, "strip", z.ZodTypeAny, {
+    directory: string;
+    prompt: string;
+}, {
+    directory: string;
+    prompt: string;
+}>, z.ZodObject<{
+    message: z.ZodString;
+}, "strip", z.ZodTypeAny, {
+    message: string;
+}, {
+    message: string;
+}>, import("@mastra/core").ToolExecutionContext<z.ZodObject<{
+    directory: z.ZodString;
+    prompt: z.ZodString;
+}, "strip", z.ZodTypeAny, {
+    directory: string;
+    prompt: string;
+}, {
+    directory: string;
+    prompt: string;
+}>, import("@mastra/core").WorkflowContext<any>>>;
+//# sourceMappingURL=image.d.ts.map

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

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

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/mcp.d.ts

@@ -0,0 +1,3 @@
+import { MastraMCPClient } from '@mastra/mcp';
+export declare const slack: MastraMCPClient;
+//# sourceMappingURL=mcp.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"mcp.d.ts","sourceRoot":"","sources":["../../../src/mastra/tools/mcp.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,eAAe,EAAE,MAAM,aAAa,CAAC;AAE9C,eAAO,MAAM,KAAK,iBAUhB,CAAC"}

package/dist/mastra/tools/mcp.js

@@ -0,0 +1,12 @@
+import { MastraMCPClient } from '@mastra/mcp';
+export const slack = new MastraMCPClient({
+    name: 'Slack',
+    server: {
+        command: '/usr/local/bin/docker',
+        args: ['run', '-i', '--rm', '-e', 'SLACK_BOT_TOKEN', '-e', 'SLACK_TEAM_ID', 'mcp/slack'],
+        env: {
+            SLACK_BOT_TOKEN: process.env.SLACK_BOT_TOKEN,
+            SLACK_TEAM_ID: process.env.SLACK_TEAM_ID,
+        },
+    },
+});

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

@@ -1 +1 @@
-{"version":3,"file":"pdf.d.ts","sourceRoot":"","sources":["../../../src/mastra/tools/pdf.ts"],"names":[],"mappings":"AAKA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAExB,eAAO,MAAM,OAAO;;;;;;;;;;;;;;;;;;iDAsClB,CAAC"}
+{"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(`\n 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/changelog.d.ts

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

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

@@ -0,0 +1 @@
+{"version":3,"file":"changelog.d.ts","sourceRoot":"","sources":["../../../src/mastra/workflows/changelog.ts"],"names":[],"mappings":"AAAA,OAAO,EAAQ,QAAQ,EAAE,MAAM,cAAc,CAAC;AAI9C,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAIxB,eAAO,MAAM,iBAAiB;;;;;;GAK5B,CAAC"}

package/dist/mastra/workflows/changelog.js

@@ -0,0 +1,149 @@
+import { Step, Workflow } from '@mastra/core';
+import chalk from 'chalk';
+import { execa } from 'execa';
+import { existsSync, readFileSync, writeFileSync } from 'fs';
+import { z } from 'zod';
+import { slack } from '../tools/mcp.js';
+export const changelogWorkflow = new Workflow({
+    name: 'changelog',
+    triggerSchema: z.object({
+        channelId: z.string(),
+    }),
+});
+const stepA1 = new Step({
+    id: 'stepA1',
+    description: 'Get a git diff',
+    outputSchema: z.object({
+        message: z.string(),
+    }),
+    execute: async () => {
+        console.log('SUH');
+        // For today
+        try {
+            await slack.connect();
+        }
+        catch (e) {
+            console.error(e);
+        }
+        const today = new Date().toISOString().split('T')[0];
+        console.log(today);
+        // For 7 days ago
+        const weekAgo = new Date(Date.now() - 7 * 24 * 60 * 60 * 1000).toISOString().split('T')[0];
+        console.log(weekAgo);
+        const cwd = process.cwd();
+        console.log(cwd);
+        const args = [
+            '--no-pager',
+            'diff',
+            '--unified=1', // Reduced context to 1 line
+            '--no-prefix',
+            '--color=never',
+            '--shortstat', // Get size first to check
+            `main@{${weekAgo}}`,
+            `main@{${today}}`,
+            '--',
+            'packages/**',
+            // 'docs/**'
+        ];
+        console.log(args);
+        const p = execa('git', args, {
+            cwd,
+        });
+        try {
+            const diff = await p;
+            return {
+                message: diff.stdout,
+            };
+        }
+        catch (e) {
+            console.error(e);
+            return {
+                message: 'Error, do not compute',
+            };
+        }
+    },
+});
+const stepA2 = new Step({
+    id: 'stepA2',
+    description: 'Make changelog',
+    outputSchema: z.object({
+        message: z.string(),
+    }),
+    execute: async ({ context, mastra }) => {
+        if (context.machineContext?.stepResults.stepA1?.status !== 'success') {
+            throw new Error('Message not found');
+        }
+        const agent = mastra?.agents?.daneChangeLog;
+        if (!agent) {
+            throw new Error('LLM not found');
+        }
+        const today = new Date().toISOString().split('T')[0];
+        const weekAgo = new Date(Date.now() - 7 * 24 * 60 * 60 * 1000).toISOString().split('T')[0];
+        const tools = await slack.tools();
+        if (existsSync(`changelog-${today}`)) {
+            const existing = readFileSync(`changelog-${today}`, 'utf-8');
+            await agent.generate(`
+                Send this ${existing} to this slack channel: "${context.machineContext.triggerData.channelId}" with the tool slack_post_message.
+                Format it in markdown so it displays nicely in slack.
+                `, {
+                toolsets: {
+                    slack: tools,
+                },
+            });
+            return {
+                message: existing,
+            };
+        }
+        const channelId = context.machineContext.triggerData.channelId;
+        const prompt = `
+            Time: ${weekAgo} - ${today}
+
+            Git diff to generate from: ${context.machineContext.stepResults.stepA1.payload.message}
+            # Task
+            1. create a structured narrative changelog that highlights key updates and improvements.
+            2. Include what packages were changed
+
+            ## Structure
+
+            1. Opening
+            - Brief welcome/context (1-2 sentences)
+            - Time period covered
+
+            2. Major Updates (3-4 key highlights)
+            - Lead with the most impactful changes
+            - Include brief technical context where needed
+            - Reference relevant PR numbers
+            - Link to examples/docs where applicable
+
+            3. Technical Improvements
+            - Group related changes
+            - Focus on developer impact
+            - Include code snippets if helpful
+
+            4. Documentation & Examples
+            - New guides/tutorials
+            - Updated examples
+            - API documentation changes
+
+            5. Bug Fixes & Infrastructure
+            - Notable bug fixes
+            - Build/deployment improvements
+            - Performance optimizations
+
+
+            Finally send this to this slack channel: "${channelId}" with the tool slack_post_message
+        `;
+        console.log(chalk.green(`Generating...`));
+        const result = await agent.generate(prompt, {
+            toolsets: {
+                slack: tools,
+            },
+        });
+        console.log(chalk.green(result.text));
+        writeFileSync(`changelog-${today}`, result.text);
+        return {
+            message: result.text,
+        };
+    },
+});
+changelogWorkflow.step(stepA1).then(stepA2).commit();

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

@@ -1 +1 @@
-{"version":3,"file":"chat.d.ts","sourceRoot":"","sources":["../../../src/mastra/workflows/chat.ts"],"names":[],"mappings":"AAAA,OAAO,EAAQ,QAAQ,EAAE,MAAM,cAAc,CAAC;AAG9C,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAIxB,eAAO,MAAM,eAAe;;;;;;;;;GAM1B,CAAC"}
+{"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"}