@mastra/dane 0.0.2-alpha.6 → 0.0.2-alpha.62

package/dist/index.js

@@ -1,9 +1,27 @@
 #! /usr/bin/env node
-process.env.NODE_NO_WARNINGS = '1';
 import { Command } from 'commander';
+import dotenv from 'dotenv';
+import { changelog } from './commands/changelog.js';
+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';
+import { telephone } from './commands/telephone-game.js';
+dotenv.config();
+process.env.NODE_NO_WARNINGS = '1';
 const program = new Command();
 program.command('chat').action(message);
-program.command('issue-labeler').action(issueLabelerCommand);
+program
+    .command('issue-labeler')
+    .description('Automatically label GitHub issues based on their content and context')
+    .action(issueLabelerCommand);
+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.command('telephone-game').description('Play a classic game of telephone').action(telephone);
+program.command('changelog').description('Mastra Changelog').action(changelog);
 program.parse(process.argv);

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

@@ -1,5 +1,92 @@
 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>>>;
+    pnpmChangesetStatus: import("@mastra/core").Tool<"pnpmChangesetStatus", import("zod").ZodObject<{}, "strip", import("zod").ZodTypeAny, {}, {}>, import("zod").ZodObject<{
+        message: import("zod").ZodArray<import("zod").ZodString, "many">;
+    }, "strip", import("zod").ZodTypeAny, {
+        message: string[];
+    }, {
+        message: string[];
+    }>, import("@mastra/core").ToolExecutionContext<import("zod").ZodObject<{}, "strip", import("zod").ZodTypeAny, {}, {}>, import("@mastra/core").WorkflowContext<any>>>;
+    activeDistTag: import("@mastra/core").Tool<"activeDistTag", import("zod").ZodObject<{
+        packagePath: import("zod").ZodString;
+    }, "strip", import("zod").ZodTypeAny, {
+        packagePath: 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<{
+        packagePath: import("zod").ZodString;
+    }, "strip", import("zod").ZodTypeAny, {
+        packagePath: string;
+    }, {
+        packagePath: string;
+    }>, import("@mastra/core").WorkflowContext<any>>>;
+}>;
+export declare const daneChangeLog: Agent<Record<string, import("@mastra/core").ToolAction<any, any, any, any>>>;
 export declare const dane: Agent<{
     fsTool: import("@mastra/core").Tool<"fsTool", import("zod").ZodObject<{
         action: import("zod").ZodString;
@@ -147,10 +234,13 @@ export declare const dane: Agent<{
         limit?: number | undefined;
     }>, import("zod").ZodObject<{
         message: import("zod").ZodString;
+        crawlData: import("zod").ZodAny;
     }, "strip", import("zod").ZodTypeAny, {
         message: string;
+        crawlData?: any;
     }, {
         message: string;
+        crawlData?: any;
     }>, import("@mastra/core").ToolExecutionContext<import("zod").ZodObject<{
         url: import("zod").ZodString;
         limit: import("zod").ZodDefault<import("zod").ZodNumber>;
@@ -164,5 +254,30 @@ export declare const dane: Agent<{
         pathRegex: string | null;
         limit?: number | undefined;
     }>, import("@mastra/core").WorkflowContext<any>>>;
+    imageTool: import("@mastra/core").Tool<"imageTool", import("zod").ZodObject<{
+        directory: import("zod").ZodString;
+        prompt: import("zod").ZodString;
+    }, "strip", import("zod").ZodTypeAny, {
+        directory: string;
+        prompt: string;
+    }, {
+        directory: string;
+        prompt: string;
+    }>, import("zod").ZodObject<{
+        message: import("zod").ZodString;
+    }, "strip", import("zod").ZodTypeAny, {
+        message: string;
+    }, {
+        message: string;
+    }>, import("@mastra/core").ToolExecutionContext<import("zod").ZodObject<{
+        directory: import("zod").ZodString;
+        prompt: import("zod").ZodString;
+    }, "strip", import("zod").ZodTypeAny, {
+        directory: string;
+        prompt: string;
+    }, {
+        directory: string;
+        prompt: string;
+    }>, import("@mastra/core").WorkflowContext<any>>>;
 }>;
 //# sourceMappingURL=index.d.ts.map

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;AASrC,eAAO,MAAM,gBAAgB,8EAW3B,CAAC;AAEH,eAAO,MAAM,IAAI;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAwDf,CAAC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/mastra/agents/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,KAAK,EAAE,MAAM,cAAc,CAAC;AAmBrC,eAAO,MAAM,iBAAiB,8EAU5B,CAAC;AAEH,eAAO,MAAM,gBAAgB,8EAO3B,CAAC;AAEH,eAAO,MAAM,oBAAoB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAc/B,CAAC;AAEH,eAAO,MAAM,aAAa,8EAcxB,CAAC;AAEH,eAAO,MAAM,IAAI;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAuDf,CAAC"}

package/dist/mastra/agents/index.js

@@ -1,22 +1,68 @@
 import { Agent } from '@mastra/core';
+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 { fsTool } from '../tools/fs.js';
+import { imageTool } from '../tools/image.js';
 import { readPDF } from '../tools/pdf.js';
+import { activeDistTag, pnpmBuild, pnpmChangesetPublish, pnpmChangesetStatus } from '../tools/pnpm.js';
+const getBaseModelConfig = () => ({
+    provider: 'ANTHROPIC',
+    toolChoice: 'auto',
+    name: 'claude-3-5-sonnet-20241022',
+    apiKey: config.getAnthropicApiKey(),
+});
+export const daneCommitMessage = new Agent({
+    name: 'DaneCommitMessage',
+    instructions: `
+    You are Dane, the ultimate GitHub operator.
+    You help engineers generate commit messages.
+
+    GENERATE A SCOPE FOR THE COMMIT MESSAGE IF NECESSARY.
+    FIGURE OUT THE BEST TOP LEVEL SEMANTIC MATCH TO USE AS THE SCOPE.
+    `,
+    model: getBaseModelConfig(),
+});
 export const daneIssueLabeler = new Agent({
     name: 'DaneIssueLabeler',
     instructions: `
-    You are Dane, the ultimate GitHub operator. 
+    You are Dane, the ultimate GitHub operator.
     You help engineers label their issues.
     `,
-    model: {
-        provider: 'ANTHROPIC',
-        toolChoice: 'auto',
-        name: 'claude-3-5-sonnet-20241022',
+    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,
+        pnpmChangesetStatus,
+        activeDistTag,
     },
 });
+export const daneChangeLog = new Agent({
+    name: 'DanePackagePublisher',
+    instructions: `
+    You are Dane, the changelog writer for Mastra AI. Every week we need to write a changelog for the Mastra AI project.
+    ## Style Guide
+    - Use active voice
+    - Lead with the change, not the PR number
+    - Include PR numbers in parentheses at end of line
+    - Keep descriptions concise but informative
+    - Avoid marketing language
+    - Link to relevant documentation
+    - Use consistent formatting for code references
+    `,
+    model: getBaseModelConfig(),
+});
 export const dane = new Agent({
     name: 'Dane',
     instructions: `
@@ -26,42 +72,42 @@ export const dane = new Agent({
     DO NOT ATTEMPT TO USE GENERAL KNOWLEDGE! We are only as good as the tools we use.
 
     # Our tools:
-    
+
     ## readPDF
     Makes you a powerful agent capable of reading PDF files.
 
     ## fsTool
     Makes you a powerful agent capable of reading and writing files to the local filesystem.
-    
+
     ## execaTool
-    Makes you a powerful agent capabale of executing files on the local system. 
-    
-    ## googleSearch 
+    Makes you a powerful agent capabale of executing files on the local system.
+
+    ## googleSearch
     Makes you a powerful agent capabale answering all questions by finding the answer on Google search.
     Pass the query as a JS object. If you have links, ALWAYS CITE YOUR SOURCES.
-    
+
     ## browserTool
-    Makes you a powerful agent capable of scraping the web. Pass the url as a JS object. 
+    Makes you a powerful agent capable of scraping the web. Pass the url as a JS object.
 
     ## listEvents
-    Makes you a powerful agent capable of listing events on a calendar. When using this tool ONLY RETURN RELEVANT EVENTS. 
+    Makes you a powerful agent capable of listing events on a calendar. When using this tool ONLY RETURN RELEVANT EVENTS.
     DO NOT ATTEMPT TO DO ANYTHING MORE.
 
     ## crawl
     Use this when the user asks you to crawl. CRAWL is the signal to use this tool.
-    Makes you a powerful agent capable of crawling a site and extracting markdown metadata. 
-    The data will be stored in a database. Confirm that it is sucessful.
-    
+    Makes you a powerful agent capable of crawling a site and extracting markdown metadata.
+    The data will be stored in a database if it is not already there. Confirm that it is sucessful.
+    The crawled data will be returned in the response on the 'crawlData' field.
+
+    ## imageTool
+    Makes you a powerful agent capable of generating images and saving them to disk. Pass the directory and an image prompt.
+
     # Rules
     * DO NOT ATTEMPT TO USE GENERAL KNOWLEDGE. Use the 'googleSearch' tool to find the answer.
-    * Don't reference tools when you communicate with the user. Do not mention what tools you are using. 
+    * Don't reference tools when you communicate with the user. Do not mention what tools you are using.
     * Tell the user what you are doing.
     `,
-    model: {
-        provider: 'ANTHROPIC',
-        toolChoice: 'auto',
-        name: 'claude-3-5-sonnet-20241022',
-    },
+    model: getBaseModelConfig(),
     tools: {
         fsTool,
         execaTool,
@@ -70,7 +116,6 @@ export const dane = new Agent({
         readPDF,
         listEvents,
         crawl,
-        // TODO I SHOULD BE ABLE TO PASS A WORKFLOW EXECUTE HERE
-        // browserAgentRelay,
+        imageTool,
     },
 });

package/dist/mastra/index.d.ts

@@ -149,10 +149,13 @@ export declare const mastra: Mastra<{
             limit?: number | undefined;
         }>, import("zod").ZodObject<{
             message: import("zod").ZodString;
+            crawlData: import("zod").ZodAny;
         }, "strip", import("zod").ZodTypeAny, {
             message: string;
+            crawlData?: any;
         }, {
             message: string;
+            crawlData?: any;
         }>, import("@mastra/core").ToolExecutionContext<import("zod").ZodObject<{
             url: import("zod").ZodString;
             limit: import("zod").ZodDefault<import("zod").ZodNumber>;
@@ -166,8 +169,120 @@ export declare const mastra: Mastra<{
             pathRegex: string | null;
             limit?: number | undefined;
         }>, import("@mastra/core").WorkflowContext<any>>>;
+        imageTool: import("@mastra/core").Tool<"imageTool", import("zod").ZodObject<{
+            directory: import("zod").ZodString;
+            prompt: import("zod").ZodString;
+        }, "strip", import("zod").ZodTypeAny, {
+            directory: string;
+            prompt: string;
+        }, {
+            directory: string;
+            prompt: string;
+        }>, import("zod").ZodObject<{
+            message: import("zod").ZodString;
+        }, "strip", import("zod").ZodTypeAny, {
+            message: string;
+        }, {
+            message: string;
+        }>, import("@mastra/core").ToolExecutionContext<import("zod").ZodObject<{
+            directory: import("zod").ZodString;
+            prompt: import("zod").ZodString;
+        }, "strip", import("zod").ZodTypeAny, {
+            directory: string;
+            prompt: string;
+        }, {
+            directory: string;
+            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>>>;
+        pnpmChangesetStatus: import("@mastra/core").Tool<"pnpmChangesetStatus", import("zod").ZodObject<{}, "strip", import("zod").ZodTypeAny, {}, {}>, import("zod").ZodObject<{
+            message: import("zod").ZodArray<import("zod").ZodString, "many">;
+        }, "strip", import("zod").ZodTypeAny, {
+            message: string[];
+        }, {
+            message: string[];
+        }>, import("@mastra/core").ToolExecutionContext<import("zod").ZodObject<{}, "strip", import("zod").ZodTypeAny, {}, {}>, import("@mastra/core").WorkflowContext<any>>>;
+        activeDistTag: import("@mastra/core").Tool<"activeDistTag", import("zod").ZodObject<{
+            packagePath: import("zod").ZodString;
+        }, "strip", import("zod").ZodTypeAny, {
+            packagePath: 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<{
+            packagePath: import("zod").ZodString;
+        }, "strip", import("zod").ZodTypeAny, {
+            packagePath: string;
+        }, {
+            packagePath: string;
+        }>, 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>>>;
+    daneChangeLog: import("@mastra/core").Agent<Record<string, import("@mastra/core").ToolAction<any, any, any, any>>>;
 }, {
     message: import("@mastra/core").Workflow<any, import("zod").ZodObject<{
         resourceid: import("zod").ZodString;
@@ -192,5 +307,21 @@ export declare const mastra: Mastra<{
         owner: string;
         issue_number: number;
     }>>;
-}, import("@mastra/core").BaseLogger<import("@mastra/core").BaseLogMessage>>;
+    commitMessage: import("@mastra/core").Workflow<any, import("zod").ZodObject<{
+        repoPath: import("zod").ZodString;
+    }, "strip", import("zod").ZodTypeAny, {
+        repoPath: string;
+    }, {
+        repoPath: string;
+    }>>;
+    packagePublisher: import("@mastra/core").Workflow<any, any>;
+    telephoneGame: import("@mastra/core").Workflow<any, any>;
+    changelog: import("@mastra/core").Workflow<any, import("zod").ZodObject<{
+        channelId: import("zod").ZodString;
+    }, "strip", import("zod").ZodTypeAny, {
+        channelId: string;
+    }, {
+        channelId: string;
+    }>>;
+}, Record<string, import("@mastra/core").MastraVector>, Record<string, import("@mastra/core").MastraTTS>, import("@mastra/core").BaseLogger<import("@mastra/core").BaseLogMessage>>;
 //# sourceMappingURL=index.d.ts.map

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

package/dist/mastra/index.js

@@ -1,16 +1,22 @@
 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, danePackagePublisher } from './agents/index.js';
 import { firecrawl } from './integrations/index.js';
-import { messageWorkflow, githubIssueLabeler } from './workflows/index.js';
+import { changelogWorkflow } from './workflows/changelog.js';
+import { messageWorkflow, githubIssueLabeler, commitMessageGenerator } from './workflows/index.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,
         daneIssueLabeler,
+        daneCommitMessage,
+        daneChangeLog,
     },
     engine,
     memory: new UpstashKVMemory({
@@ -21,8 +27,11 @@ export const mastra = new Mastra({
     workflows: {
         message: messageWorkflow,
         githubIssueLabeler: githubIssueLabeler,
+        commitMessage: commitMessageGenerator,
+        packagePublisher: packagePublisher,
+        telephoneGame: telephoneGameWorkflow,
+        changelog: changelogWorkflow,
     },
-    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' };
         }
     },