@mastra/dane 0.0.2-alpha.80 → 0.0.2-alpha.81

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

@@ -1,91 +1,6 @@
 import { Agent } from '@mastra/core';
 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 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>>>;
-}, 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<{

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;AAarC,eAAO,MAAM,iBAAiB,6HAU5B,CAAC;AAEH,eAAO,MAAM,gBAAgB,6HAO3B,CAAC;AAiCH,eAAO,MAAM,oBAAoB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iDAgC/B,CAAC;AAEH,eAAO,MAAM,eAAe,6HAa1B,CAAC;AAEH,eAAO,MAAM,aAAa,6HAcxB,CAAC;AAEH,eAAO,MAAM,IAAI;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iDAuDf,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

@@ -6,7 +6,6 @@ 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';
 import { getBaseModelConfig } from './model.js';
 export const daneCommitMessage = new Agent({
     name: 'DaneCommitMessage',
@@ -27,69 +26,6 @@ export const daneIssueLabeler = new Agent({
     `,
     model: getBaseModelConfig(),
 });
-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
-
-  // 2. Deployer packages - STRICT RULES:
-  // - ALL deployer packages must be directly under deployers/
-  // - Format: @mastra/deployer-{name} -> deployers/{name}
-  // - Example: @mastra/deployer-cloudflare -> deployers/cloudflare
-  // - 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
-
-  // 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 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: {
-        execaTool,
-        pnpmBuild,
-        pnpmChangesetPublish,
-        pnpmChangesetStatus,
-        activeDistTag,
-    },
-});
 export const daneLinkChecker = new Agent({
     name: 'DaneLinkChecker',
     instructions: `

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;AAqCrC,eAAO,MAAM,oBAAoB,iwBAa5B,CAAC;AAEN,eAAO,MAAM,qBAAqB,aAAc,MAAM,EAAE,WAiDvD,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,154 @@
+import { Agent } from '@mastra/core';
+import { pnpmChangesetStatus, pnpmBuild, pnpmChangesetPublish, activeDistTag } from '../tools/pnpm';
+import { getBaseModelConfig } from './model';
+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
+
+  ## 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
+
+  ##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 @mastra/* package</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,
+    },
+});

package/dist/mastra/index.d.ts

@@ -196,31 +196,13 @@ export declare const mastra: Mastra<{
         }>, import("@mastra/core").WorkflowContext<any>>>;
     }, Record<string, import("@mastra/core").Metric>>;
     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">;
+        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, {
-            command: string;
-            args: string[];
+            message: string[];
         }, {
-            command: string;
-            args: string[];
-        }>, import("@mastra/core").WorkflowContext<any>>>;
+            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;
@@ -253,13 +235,6 @@ export declare const mastra: Mastra<{
         }, {
             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, {

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

package/dist/mastra/index.js

@@ -1,8 +1,9 @@
 import { Mastra } from '@mastra/core';
 import { PostgresEngine } from '@mastra/engine';
 import { UpstashKVMemory } from '@mastra/memory';
-import { dane, daneChangeLog, daneCommitMessage, daneIssueLabeler, daneLinkChecker, danePackagePublisher, } from './agents/index.js';
+import { dane, daneChangeLog, daneCommitMessage, daneIssueLabeler, daneLinkChecker } from './agents/index.js';
 import { daneNewContributor } from './agents/new-contributor.js';
+import { danePackagePublisher } from './agents/package-publisher.js';
 import { firecrawl } from './integrations/index.js';
 import { changelogWorkflow } from './workflows/changelog.js';
 import { githubFirstContributorMessage } from './workflows/first-contributor.js';

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

@@ -1 +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"}
+{"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;;;;;;6IA6B9B,CAAC;AAEH,eAAO,MAAM,oBAAoB;;;;;;6IA0B/B,CAAC;AAEH,eAAO,MAAM,aAAa;;;;;;;;;;;;;;;;;;iDA8BxB,CAAC"}

package/dist/mastra/tools/pnpm.js

@@ -46,11 +46,10 @@ export const pnpmChangesetStatus = createTool({
     }),
     execute: async () => {
         try {
-            console.log('Checking');
+            console.log(chalk.green(`\nRunning command: pnpm publish -r --dry-run --no-git-checks`));
             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('+'));
@@ -96,8 +95,8 @@ export const pnpmChangesetPublish = createTool({
 });
 export const activeDistTag = createTool({
     id: 'activeDistTag',
-    name: 'PNPM Changeset set active tag',
-    description: 'Used to set active tag on the pnpm module',
+    name: 'PNPM Active Dist Tag Tool',
+    description: 'Set active dist tag on pnpm module',
     inputSchema: z.object({
         packagePath: z.string(),
     }),

package/dist/mastra/workflows/publish-packages.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"publish-packages.d.ts","sourceRoot":"","sources":["../../../src/mastra/workflows/publish-packages.ts"],"names":[],"mappings":"AAAA,OAAO,EAAQ,QAAQ,EAAE,MAAM,cAAc,CAAC;AAM9C,eAAO,MAAM,gBAAgB,oBAE3B,CAAC"}
+{"version":3,"file":"publish-packages.d.ts","sourceRoot":"","sources":["../../../src/mastra/workflows/publish-packages.ts"],"names":[],"mappings":"AAAA,OAAO,EAAQ,QAAQ,EAAE,MAAM,cAAc,CAAC;AAQ9C,eAAO,MAAM,gBAAgB,oBAE3B,CAAC"}

package/dist/mastra/workflows/publish-packages.js

@@ -3,6 +3,7 @@ import chalk from 'chalk';
 import { existsSync } from 'fs';
 import path from 'path';
 import { z } from 'zod';
+import { BUILD_PACKAGES_PROMPT, PACKAGES_LIST_PROMPT, PUBLISH_PACKAGES_PROMPT } from '../agents/package-publisher';
 export const packagePublisher = new Workflow({
     name: 'pnpm-changset-publisher',
 });
@@ -19,44 +20,22 @@ const getPacakgesToPublish = new Step({
         if (!agent) {
             throw new Error('Agent not found');
         }
-        const result = await agent.generate(`
-        Please analyze the following monorepo directories and identify packages that need pnpm publishing:
-
-        CRITICAL: All packages MUST be built before publishing, in the correct order.
-
-        1. Directory Structure:
-           - packages/      : Contains core modules (format: @mastra/{name})
-           - integrations/ : Contains integration packages (format: @mastra/{name})
-           - deployers/    : Contains deployer packages (format: @mastra/deployer-{name})
-           - vector-stores/: Contains vector store packages with following mapping:
-             * @mastra/vector-astra -> vector-stores/astra-db/
-             * @mastra/vector-{name} -> vector-stores/{name}/ (for all other vector stores)
-
-        2. Publish Requirements:
-           - Build @mastra/core first, MUST be built before any other package
-           - Build all packages in correct dependency order before publishing
-           - 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.
-    `);
+        const result = await agent.generate(PACKAGES_LIST_PROMPT);
+        console.log(chalk.green(`\n${result.text}`));
         const resultObj = await agent.generate(`
-      Please organize the following packages for building and publishing:
+      Please convert this into a structured object:
 
       Input Text: ${result.text}
 
-      1. Build Order Requirements:
-         - ALL packages MUST be built before publishing
-         - @mastra/core MUST be built first
-         - @mastra/deployer MUST be built second
-         - Dependencies must be built before dependents
+      1. Order Requirements:
+         - @mastra/core MUST be first within packages
+         - @mastra/deployer MUST be second within packages
          - Group parallel builds by directory type
 
       2. Output Format:
          - Group into: packages[], integrations[], deployers[], vector_stores[]
          - Place create-mastra in packages[] array
-         - Maintain correct build order within each group
+         - Maintain correct order within each group
 
       3. Critical Rules:
          - Never publish without building first
@@ -70,7 +49,6 @@ const getPacakgesToPublish = new Step({
                 vector_stores: z.array(z.string()),
             }),
         });
-        console.log(resultObj.object);
         return {
             packages: resultObj?.object?.packages,
             integrations: resultObj?.object?.integrations,
@@ -137,6 +115,10 @@ const assemblePackages = new Step({
                 packages: [],
             };
         }
+        console.log(chalk.green(`\nBuilding packages:\n`));
+        pkgSet.forEach((pkg) => {
+            console.log(chalk.green(pkg));
+        });
         return { packages: pkgSet };
     },
 });
@@ -156,28 +138,7 @@ const buildPackages = new Step({
         if (!agent) {
             throw new Error('Agent not found');
         }
-        console.log(chalk.green(`Building packages:`));
-        pkgSet.forEach((pkg) => {
-            console.log(chalk.green(pkg));
-        });
-        let res = await agent.generate(`
-      Here are the packages that need to be built: ${pkgSet.join(',')}.
-
-      Please organize the build order following these strict requirements:
-
-      1. Core Dependencies (Must be built in this exact order):
-         - @mastra/core MUST be built first
-         - @mastra/deployer MUST be built second
-         - mastra MUST be built third
-
-      2. Parallel Builds (After core dependencies):
-         - Build all remaining packages in 'packages' directory in parallel
-         - Build all packages in 'integrations' directory in parallel
-         - Build all packages in 'deployers' directory in parallel
-         - Build all packages in 'vector-stores' directory in parallel
-
-      Note: Do not proceed to the next group until the current group is fully built.
-    `);
+        let res = await agent.generate(BUILD_PACKAGES_PROMPT(pkgSet));
         console.log(chalk.green(res.text));
         return { packages: pkgSet };
     },
@@ -193,6 +154,7 @@ const verifyBuild = new Step({
                 packages: [],
             };
         }
+        console.log('Verifying the output for:', context.machineContext.stepResults.buildPackages.payload.packages);
         const pkgSet = context.machineContext.stepResults.buildPackages.payload.packages;
         for (const pkg of pkgSet) {
             if (!existsSync(`${pkg}/dist`)) {
@@ -200,7 +162,6 @@ const verifyBuild = new Step({
                 throw new Error(`Failed to build ${pkg}.`);
             }
         }
-        console.log(pkgSet);
         return {
             packages: pkgSet,
         };
@@ -222,9 +183,7 @@ const publishChangeset = new Step({
         if (!agent) {
             throw new Error('Agent not found');
         }
-        let res = await agent.generate(`
-            Publish the changeset.
-        `);
+        const res = await agent.generate(PUBLISH_PACKAGES_PROMPT);
         console.log(chalk.green(res.text));
         return { packages: pkgSet };
     },
@@ -267,7 +226,8 @@ packagePublisher
             context.stepResults.buildPackages?.payload?.packages.length > 0);
     },
 })
-    .then(publishChangeset, {
+    .after(verifyBuild)
+    .step(publishChangeset, {
     when: async ({ context }) => {
         return (context.stepResults.buildPackages?.status === 'success' &&
             context.stepResults.buildPackages?.payload?.packages.length > 0);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@mastra/dane",
-  "version": "0.0.2-alpha.80",
+  "version": "0.0.2-alpha.81",
   "main": "dist/index.js",
   "type": "module",
   "files": [
@@ -41,11 +41,11 @@
     "zod": "^3.24.0",
     "@mastra/core": "0.1.27-alpha.70",
     "@mastra/firecrawl": "1.0.4-alpha.61",
-    "@mastra/engine": "0.0.5-alpha.65",
+    "@mastra/memory": "0.0.2-alpha.51",
     "@mastra/github": "1.0.3-alpha.54",
+    "@mastra/engine": "0.0.5-alpha.65",
     "@mastra/rag": "0.0.2-alpha.59",
     "@mastra/stabilityai": "1.0.1-alpha.45",
-    "@mastra/memory": "0.0.2-alpha.51",
     "@mastra/mcp": "0.0.1-alpha.12"
   },
   "scripts": {