@mastra/dane 0.0.2-alpha.77 → 0.0.2-alpha.79

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;AAiBH,eAAO,MAAM,oBAAoB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iDAgB/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;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"}

package/dist/mastra/agents/index.js

@@ -28,26 +28,58 @@ export const daneIssueLabeler = new Agent({
     model: getBaseModelConfig(),
 });
 const packages_llm_text = `
-  @mastra/core is located in the "packages/core" directory.
-  @mastra/deployer is located in the "packages/deployer" directory.
-  mastra is located in the "packages/cli" directory.
-  @mastra/engine is located in the "packages/engine" directory.
-  @mastra/evals is located in the "packages/evals" directory.
-  @mastra/rag is located in the "packages/rag" directory.
-  @mastra/tts is located in the "packages/tts" directory.
-  @mastra/memory is located in the "packages/memory" directory.
-  @mastra/mcp is located in the "packages/mcp" directory.
-  @mastra/deployer-{name} is located in the "deployers/{name}" directory.
-  @mastra/vector-{name} is located in the "vector-stores/{name}" directory.
-  dane or @mastra/dane is located in the "exampeles/dane" directory.
+  // 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: `
-    You are Dane, the ultimate node module publisher.
-    You help engineers publish their pnpm changesets.
+    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: {

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

@@ -1,6 +1,6 @@
 import { Step, Workflow } from '@mastra/core';
 import chalk from 'chalk';
-import { existsSync, readFileSync } from 'fs';
+import { existsSync } from 'fs';
 import path from 'path';
 import { z } from 'zod';
 export const packagePublisher = new Workflow({
@@ -11,7 +11,8 @@ const getPacakgesToPublish = new Step({
     outputSchema: z.object({
         packages: z.array(z.string()),
         integrations: z.array(z.string()),
-        danePackage: z.string(),
+        deployers: z.array(z.string()),
+        vector_stores: z.array(z.string()),
     }),
     execute: async ({ mastra }) => {
         const agent = mastra?.agents?.['danePackagePublisher'];
@@ -19,38 +20,54 @@ const getPacakgesToPublish = new Step({
             throw new Error('Agent not found');
         }
         const result = await agent.generate(`
-        Here is my project structure in my monorepo.
-        * My core modules are in the 'packages' directory.
-        * My integrations are in the 'integrations' directory.
-        * My deployers are in the 'deployers' directory.
-        * My vector stores are in the 'vector-stores' directory.
+        Please analyze the following monorepo directories and identify packages that need pnpm publishing:
 
-        Can you tell me which packages within these folders need to be published to npm?
+        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 resultObj = await agent.generate(`
-      Can you format the following text with my described format?
+      Please organize the following packages for building and publishing:
+
+      Input Text: ${result.text}
 
-      Formatting Rules:
-      * If the text I am giving you says there are no publishable packages, return empty arrays.
-      * @mastra/core must be first. 
-      * @mastra/deployer must be second.
-      * mastra must be third.
-      * @mastra/deployers-{name} and @mastra/vector-{name} must be fourth.
-      
-      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
+         - Group parallel builds by directory type
 
-      Very Important:
-      * Do not include packages if we do not need to build them.
-      * create-mastra is a package (not an integration) and should be listed in packages array.
-      * @mastra/deployers-{name} should be listed after packages.
-      * @mastra/vector-{name} should be listed after packages.
-      * @mastra/dane should be listed after packages and integrations.    
+      2. Output Format:
+         - Group into: packages[], integrations[], deployers[], vector_stores[]
+         - Place create-mastra in packages[] array
+         - Maintain correct build order within each group
+
+      3. Critical Rules:
+         - Never publish without building first
+         - Only include packages that need updates
+         - Follow dependency order strictly
     `, {
             output: z.object({
                 packages: z.array(z.string()),
                 integrations: z.array(z.string()),
                 deployers: z.array(z.string()),
-                danePackage: z.string(),
+                vector_stores: z.array(z.string()),
             }),
         });
         console.log(resultObj.object);
@@ -59,7 +76,6 @@ const getPacakgesToPublish = new Step({
             integrations: resultObj?.object?.integrations,
             deployers: resultObj?.object?.deployers,
             vector_stores: resultObj?.object?.vector_stores,
-            danePackage: resultObj?.object?.danePackage,
         };
     },
 });
@@ -99,8 +115,8 @@ const assemblePackages = new Step({
         if (payload?.vector_stores) {
             payload.vector_stores.forEach((pkg) => {
                 let pkgName = pkg.replace('@mastra/vector-', '');
-                if (pkgName === 'mastra') {
-                    pkgName = 'cli';
+                if (pkgName === 'astra') {
+                    pkgName = 'astra-db';
                 }
                 const pkgPath = path.join(process.cwd(), 'vector-stores', pkgName);
                 packagesToBuild.add(pkgPath);
@@ -114,31 +130,6 @@ const assemblePackages = new Step({
                 packagesToBuild.add(integrationPath);
             });
         }
-        if (payload?.danePackage) {
-            const danePackage = payload.danePackage;
-            let pkgName = danePackage.replace('@mastra/', '');
-            const danePackageMapped = path.join(process.cwd(), 'examples', pkgName);
-            const pkgJsonPath = readFileSync(path.join(danePackageMapped, 'package.json'), 'utf-8');
-            const pkgJson = JSON.parse(pkgJsonPath);
-            const dependencies = Object.keys(pkgJson.dependencies || {}).filter((dep) => dep.startsWith('@mastra/'));
-            dependencies.forEach((dep) => {
-                const pkgName = dep.replace('@mastra/', '');
-                const pkgPath = path.join(process.cwd(), 'packages', pkgName);
-                const integrationPath = path.join(process.cwd(), 'integrations', pkgName);
-                try {
-                    if (existsSync(pkgPath)) {
-                        packagesToBuild.add(pkgPath);
-                    }
-                    else {
-                        packagesToBuild.add(integrationPath);
-                    }
-                }
-                catch (e) {
-                    console.error(e);
-                }
-            });
-            packagesToBuild.add(path.join(process.cwd(), 'examples', 'dane'));
-        }
         const pkgSet = Array.from(packagesToBuild.keys());
         if (!packagesToBuild.size) {
             console.error(chalk.red('No packages to build.'));
@@ -172,17 +163,21 @@ const buildPackages = new Step({
         let res = await agent.generate(`
       Here are the packages that need to be built: ${pkgSet.join(',')}.
 
-      ## Follow the rules:
-      * @mastra/core must be first. 
-      * @mastra/deployer must be second.
-      * mastra must be third.
+      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
 
-      Packages found within the 'packages' directory should be built next in parallel.
-      Packages found within the 'integrations' directory should be built in parallel.
-      Packages found within the 'deployers' directory should be built in parallel.
+      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
 
-      Build @mastra/dane last.
-      `);
+      Note: Do not proceed to the next group until the current group is fully built.
+    `);
         console.log(chalk.green(res.text));
         return { packages: pkgSet };
     },

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@mastra/dane",
-  "version": "0.0.2-alpha.77",
+  "version": "0.0.2-alpha.79",
   "main": "dist/index.js",
   "type": "module",
   "files": [
@@ -41,12 +41,12 @@
     "zod": "^3.24.0",
     "@mastra/core": "0.1.27-alpha.69",
     "@mastra/engine": "0.0.5-alpha.63",
-    "@mastra/github": "1.0.3-alpha.53",
+    "@mastra/firecrawl": "1.0.4-alpha.59",
     "@mastra/memory": "0.0.2-alpha.49",
-    "@mastra/mcp": "0.0.1-alpha.10",
-    "@mastra/stabilityai": "1.0.1-alpha.44",
+    "@mastra/github": "1.0.3-alpha.53",
     "@mastra/rag": "0.0.2-alpha.57",
-    "@mastra/firecrawl": "1.0.4-alpha.59"
+    "@mastra/stabilityai": "1.0.1-alpha.44",
+    "@mastra/mcp": "0.0.1-alpha.10"
   },
   "scripts": {
     "build": "npx tsc",