@mastra/dane 0.0.2-alpha.9 → 0.0.2-alpha.91

package/dist/config/index.js

@@ -0,0 +1,75 @@
+import * as fs from 'fs';
+import * as os from 'os';
+import * as path from 'path';
+export class ConfigManager {
+    constructor() {
+        const homeDir = os.homedir();
+        const configDir = path.join(homeDir, '.dane');
+        this.configPath = path.join(configDir, 'config.json');
+        this.ensureConfigExists();
+    }
+    ensureConfigExists() {
+        const configDir = path.dirname(this.configPath);
+        if (!fs.existsSync(configDir)) {
+            fs.mkdirSync(configDir, { recursive: true });
+        }
+        if (!fs.existsSync(this.configPath)) {
+            fs.writeFileSync(this.configPath, JSON.stringify({}, null, 2));
+        }
+    }
+    get(key) {
+        try {
+            const config = JSON.parse(fs.readFileSync(this.configPath, 'utf-8'));
+            return config[key];
+        }
+        catch (error) {
+            return undefined;
+        }
+    }
+    set(key, value) {
+        try {
+            const config = fs.existsSync(this.configPath) ? JSON.parse(fs.readFileSync(this.configPath, 'utf-8')) : {};
+            config[key] = value;
+            fs.writeFileSync(this.configPath, JSON.stringify(config, null, 2));
+        }
+        catch (error) {
+            throw new Error(`Failed to set config value: ${error}`);
+        }
+    }
+    delete(key) {
+        try {
+            const config = fs.existsSync(this.configPath) ? JSON.parse(fs.readFileSync(this.configPath, 'utf-8')) : {};
+            if (key in config) {
+                delete config[key];
+                fs.writeFileSync(this.configPath, JSON.stringify(config, null, 2));
+            }
+        }
+        catch (error) {
+            throw new Error(`Failed to delete config value: ${error}`);
+        }
+    }
+    list() {
+        try {
+            return JSON.parse(fs.readFileSync(this.configPath, 'utf-8'));
+        }
+        catch (error) {
+            return {};
+        }
+    }
+    getAnthropicApiKey() {
+        const key = this.get('ANTHROPIC_API_KEY') || process.env.ANTHROPIC_API_KEY;
+        if (!key) {
+            // Check if we're in a command that requires the API key
+            const command = process.argv[2] || '';
+            const configCommands = ['config', '--help', '-h'];
+            // Only throw if we're not in a config-related command
+            if (!configCommands.includes(command)) {
+                throw new Error('ANTHROPIC_API_KEY not found in config. Please set it using: dane config --set ANTHROPIC_API_KEY=your_key_here');
+            }
+            return '';
+        }
+        return key;
+    }
+}
+// Create a singleton instance for easy access
+export const config = new ConfigManager();

package/dist/index.js

@@ -1,11 +1,37 @@
 #! /usr/bin/env node
-import dotenv from 'dotenv';
-dotenv.config();
-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 { linkChecker } from './commands/link-checker.js';
 import { message } from './commands/message.js';
+import { newContributorMessage } from './commands/new-contributor-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.command('new-contributor').description('Create a new contributor message').action(newContributorMessage);
+program
+    .command('link-checker')
+    .description('Check for broken links')
+    .option('-u, --url <url>', 'URL to check')
+    .action(args => {
+    linkChecker({ url: args.url });
+});
 program.parse(process.argv);

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

@@ -1,5 +1,8 @@
 import { Agent } from '@mastra/core';
-export declare const daneIssueLabeler: Agent<Record<string, import("@mastra/core").ToolAction<any, any, any, any>>>;
+export declare const daneCommitMessage: Agent<Record<string, import("@mastra/core").ToolAction<any, any, any, any>>, Record<string, import("@mastra/core").Metric>>;
+export declare const daneIssueLabeler: Agent<Record<string, import("@mastra/core").ToolAction<any, any, any, any>>, Record<string, import("@mastra/core").Metric>>;
+export declare const daneLinkChecker: Agent<Record<string, import("@mastra/core").ToolAction<any, any, any, any>>, Record<string, import("@mastra/core").Metric>>;
+export declare const daneChangeLog: Agent<Record<string, import("@mastra/core").ToolAction<any, any, any, any>>, Record<string, import("@mastra/core").Metric>>;
 export declare const dane: Agent<{
     fsTool: import("@mastra/core").Tool<"fsTool", import("zod").ZodObject<{
         action: import("zod").ZodString;
@@ -147,10 +150,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 +170,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>>>;
+}, Record<string, import("@mastra/core").Metric>>;
 //# 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;AAYrC,eAAO,MAAM,iBAAiB,6HAU5B,CAAC;AAEH,eAAO,MAAM,gBAAgB,6HAO3B,CAAC;AAEH,eAAO,MAAM,eAAe,6HAa1B,CAAC;AAEH,eAAO,MAAM,aAAa,6HAcxB,CAAC;AAEH,eAAO,MAAM,IAAI;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iDAuDf,CAAC"}

package/dist/mastra/agents/index.js

@@ -4,18 +4,56 @@ 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 { getBaseModelConfig } from './model.js';
+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 daneLinkChecker = new Agent({
+    name: 'DaneLinkChecker',
+    instructions: `
+    You are Dane, the link checker for Mastra AI. You report on broken links whenever you see them.
+    Make sure to include the url in the message.
+
+    ## Style Guide
+    - Use active voice
+    - Keep descriptions concise but informative
+    - Avoid marketing language
+    - Link to relevant documentation
+    `,
+    model: getBaseModelConfig(),
+});
+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',
@@ -26,42 +64,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 +108,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/agents/model.d.ts

@@ -0,0 +1,7 @@
+export declare const getBaseModelConfig: () => {
+    provider: "ANTHROPIC";
+    toolChoice: "auto";
+    name: string;
+    apiKey: string;
+};
+//# sourceMappingURL=model.d.ts.map

package/dist/mastra/agents/model.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"model.d.ts","sourceRoot":"","sources":["../../../src/mastra/agents/model.ts"],"names":[],"mappings":"AAEA,eAAO,MAAM,kBAAkB;;;;;CAK7B,CAAC"}

package/dist/mastra/agents/model.js

@@ -0,0 +1,7 @@
+import { config } from '../../config/index.js';
+export const getBaseModelConfig = () => ({
+    provider: 'ANTHROPIC',
+    toolChoice: 'auto',
+    name: 'claude-3-5-sonnet-20241022',
+    apiKey: config.getAnthropicApiKey(),
+});

package/dist/mastra/agents/new-contributor.d.ts

@@ -0,0 +1,3 @@
+import { Agent } from '@mastra/core';
+export declare const daneNewContributor: Agent<{}, Record<string, import("@mastra/core").Metric>>;
+//# sourceMappingURL=new-contributor.d.ts.map

package/dist/mastra/agents/new-contributor.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"new-contributor.d.ts","sourceRoot":"","sources":["../../../src/mastra/agents/new-contributor.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,KAAK,EAAE,MAAM,cAAc,CAAC;AAIrC,eAAO,MAAM,kBAAkB,0DAS7B,CAAC"}

package/dist/mastra/agents/new-contributor.js

@@ -0,0 +1,12 @@
+import { Agent } from '@mastra/core';
+import { getBaseModelConfig } from './model.js';
+export const daneNewContributor = new Agent({
+    name: 'DaneNewContributor',
+    instructions: `
+    You're Dane, the best GitHub open-source maintainer in the world.
+    Your tone is friendly and joyful.
+    When a new contributor creates a pull request, they see your message first.
+    `,
+    model: getBaseModelConfig(),
+    tools: {},
+});

package/dist/mastra/agents/package-publisher.d.ts

@@ -0,0 +1,65 @@
+import { Agent } from '@mastra/core';
+export declare const PACKAGES_LIST_PROMPT = "\n        Please analyze the following monorepo directories and identify packages that need pnpm publishing:\n        CRITICAL: This step is about planning. We do not want to build anything. All packages MUST be placed in the correct order.\n        \n        Publish Requirements:\n        - @mastra/core first, MUST be before any other package\n        - all packages in correct dependency order before building\n        - Identify packages that have changes requiring a new pnpm publish\n        - Include create-mastra in the packages list if changes exist\n        - EXCLUDE @mastra/dane from consideration\n\n        Please list all packages that need building grouped by their directory. \n        DO NOT NOT USE the 'pnpmBuild' tool during this step.\n    ";
+export declare const BUILD_PACKAGES_PROMPT: (packages: string[]) => string;
+export declare const PUBLISH_PACKAGES_PROMPT = "\n      <publish_changeset>\n        <context>\n          All packages have been successfully built and verified. Now we need to publish the changeset.\n        </context>\n\n        <execution_steps>\n          <step order=\"1\">\n            <action>Use pnpmChangesetPublish to publish all verified packages</action>\n            <verification>Ensure the publish command completes successfully</verification>\n          </step>\n        </execution_steps>\n\n        <critical_rules>\n          <rule>Do not proceed if any publish errors occur</rule>\n          <rule>Report any failed publishes immediately</rule>\n          <rule>Ensure all packages are published atomically</rule>\n        </critical_rules>\n\n        <output_format>\n          Report the publish status and any errors encountered.\n        </output_format>\n      </publish_changeset>\n    \n";
+export declare const danePackagePublisher: Agent<{
+    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>>>;
+    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>>>;
+    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>>>;
+}, Record<string, import("@mastra/core").Metric>>;
+//# sourceMappingURL=package-publisher.d.ts.map

package/dist/mastra/agents/package-publisher.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"package-publisher.d.ts","sourceRoot":"","sources":["../../../src/mastra/agents/package-publisher.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,KAAK,EAAE,MAAM,cAAc,CAAC;AAoDrC,eAAO,MAAM,oBAAoB,iwBAa5B,CAAC;AAEN,eAAO,MAAM,qBAAqB,aAAc,MAAM,EAAE,WAoDvD,CAAC;AAEF,eAAO,MAAM,uBAAuB,u2BAwBnC,CAAC;AAEF,eAAO,MAAM,oBAAoB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iDA+B/B,CAAC"}

package/dist/mastra/agents/package-publisher.js

@@ -0,0 +1,172 @@
+import { Agent } from '@mastra/core';
+import { pnpmChangesetStatus, pnpmBuild, pnpmChangesetPublish, activeDistTag } from '../tools/pnpm.js';
+import { getBaseModelConfig } from './model.js';
+const packages_llm_text = `
+  # PACKAGE LOCATION RULES - FOLLOW THESE EXACTLY:
+  
+  ## 1. Core packages - all must be directly under packages/:
+  @mastra/core -> packages/core
+  @mastra/deployer -> packages/deployer
+  mastra -> packages/cli
+  @mastra/engine -> packages/engine
+  @mastra/evals -> packages/evals
+  @mastra/rag -> packages/rag
+  @mastra/tts -> packages/tts
+  @mastra/memory -> packages/memory
+  @mastra/mcp -> packages/mcp
+  @mastra/loggers -> packages/loggers
+
+  ## 2. Deployer packages - STRICT RULES:
+  @mastra/deployer-cloudflare -> deployers/cloudflare
+  @mastra/deployer-vercel -> deployers/vercel
+  @mastra/deployer-netlify -> deployers/netlify
+  - NEVER in any other directory (not in integrations/, examples/, packages/, etc)
+
+  ## 3. Vector store packages - STRICT RULES:
+  - ALL vector packages must be directly under vector-stores/
+  - Format: @mastra/vector-{name} -> vector-stores/{name}
+  - Special case: @mastra/vector-astra -> vector-stores/astra-db
+
+  ## 4. Integrations - STRICT RULES:
+  - ALL integration packages are under integrations/
+  @mastra/apollos -> integrations/apollo
+  @mastra/ashby -> integrations/ashby
+  @mastra/github -> integrations/github
+  @mastra/twilio -> integrations/twilio
+  @mastra/stripe -> integrations/stripe
+  @mastra/stabilityai -> integrations/stabilityai
+  @mastra/sendgrid -> integrations/sendgrid
+  @mastra/ragie -> integrations/ragie
+  @mastra/resend -> integrations/resend
+  @mastra/coda -> integrations/coda
+  @mastra/firecrawl -> integrations/firecrawl
+  
+  ##VALIDATION:
+  1. Never mix examples/ or integrations/ with package paths
+  2. Package paths must exactly match these patterns
+  3. No additional subdirectories allowed
+`;
+export const PACKAGES_LIST_PROMPT = `
+        Please analyze the following monorepo directories and identify packages that need pnpm publishing:
+        CRITICAL: This step is about planning. We do not want to build anything. All packages MUST be placed in the correct order.
+        
+        Publish Requirements:
+        - @mastra/core first, MUST be before any other package
+        - all packages in correct dependency order before building
+        - Identify packages that have changes requiring a new pnpm publish
+        - Include create-mastra in the packages list if changes exist
+        - EXCLUDE @mastra/dane from consideration
+
+        Please list all packages that need building grouped by their directory. 
+        DO NOT NOT USE the 'pnpmBuild' tool during this step.
+    `;
+export const BUILD_PACKAGES_PROMPT = (packages) => `
+      <build_execution>
+        <context>
+          The following packages need to be built in sequence: ${packages.join(', ')}
+        </context>
+
+        <execution_plan>
+          <phase order="1">
+            <!-- Core packages must be built one at a time in this exact order -->
+            <step>Use pnpmBuild to build @mastra/core</step>
+            <step>Wait for completion, then use pnpmBuild to build @mastra/deployer</step>
+            <step>Wait for completion, then use pnpmBuild to build mastra</step>
+          </phase>
+
+          <phase order="2">
+            <!-- After core packages, build remaining packages by directory -->
+            <parallel_phase name="packages">
+              <description>Build remaining packages/ directory packages</description>
+              <action>Use pnpmBuild for each remaining package:
+                - All @mastra/* packages
+                - create-mastra package (in packages/create-mastra)
+              </action>
+            </parallel_phase>
+            
+            <parallel_phase name="integrations">
+              <description>Build integrations/ directory packages</description>
+              <action>Use pnpmBuild for each @mastra/integration-* package</action>
+            </parallel_phase>
+            
+            <parallel_phase name="deployers">
+              <description>Build deployers/ directory packages</description>
+              <action>Use pnpmBuild for each @mastra/deployer-* package</action>
+            </parallel_phase>
+            
+            <parallel_phase name="vector-stores">
+              <description>Build vector-stores/ directory packages</description>
+              <action>Use pnpmBuild for each @mastra/vector-* package</action>
+            </parallel_phase>
+          </phase>
+        </execution_plan>
+
+        <critical_rules>
+          <rule>Use pnpmBuild tool for each package</rule>
+          <rule>Wait for each core package to complete before starting the next</rule>
+          <rule>Only start parallel builds after ALL core packages are built</rule>
+          <rule>Verify each build succeeds before proceeding</rule>
+        </critical_rules>
+
+        <output_format>
+          Execute the builds in order and report any failures immediately.
+        </output_format>
+      </build_execution>
+`;
+export const PUBLISH_PACKAGES_PROMPT = `
+      <publish_changeset>
+        <context>
+          All packages have been successfully built and verified. Now we need to publish the changeset.
+        </context>
+
+        <execution_steps>
+          <step order="1">
+            <action>Use pnpmChangesetPublish to publish all verified packages</action>
+            <verification>Ensure the publish command completes successfully</verification>
+          </step>
+        </execution_steps>
+
+        <critical_rules>
+          <rule>Do not proceed if any publish errors occur</rule>
+          <rule>Report any failed publishes immediately</rule>
+          <rule>Ensure all packages are published atomically</rule>
+        </critical_rules>
+
+        <output_format>
+          Report the publish status and any errors encountered.
+        </output_format>
+      </publish_changeset>
+    
+`;
+export const danePackagePublisher = new Agent({
+    name: 'DanePackagePublisher',
+    instructions: `
+      I am Dane, a specialized agent for managing pnpm package publications in monorepos. My core responsibilities are:
+  
+      1. Package Analysis:
+         - Identify packages requiring publication across the monorepo
+         - Detect changes that warrant new version releases
+         - Validate package dependencies and versioning
+  
+      2. Publication Management:
+         - Orchestrate the correct build order for interdependent packages
+         - Ensure proper versioning using changesets
+         - Maintain package publishing standards
+  
+      3. Directory Structure Knowledge:
+      ${packages_llm_text}
+  
+      Important Guidelines:
+      - Always respect package dependencies when determining build order
+      - Ensure all necessary builds complete before publishing
+      - Follow semantic versioning principles
+      - Validate package.json configurations before publishing
+      `,
+    model: getBaseModelConfig(),
+    tools: {
+        pnpmChangesetStatus,
+        pnpmBuild,
+        pnpmChangesetPublish,
+        activeDistTag,
+    },
+});