@mastra/dane 0.0.2-alpha.0 → 0.0.2-alpha.100

package/dist/mastra/workflows/link-checker.d.ts.map

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

package/dist/mastra/workflows/link-checker.js

@@ -0,0 +1,102 @@
+import { Step, Workflow } from '@mastra/core';
+import chalk from 'chalk';
+import child_process from 'node:child_process';
+import util from 'node:util';
+import { z } from 'zod';
+import { slack } from '../tools/mcp.js';
+const exec = util.promisify(child_process.exec);
+export const linkCheckerWorkflow = new Workflow({
+    name: 'link-checker',
+    triggerSchema: z.object({
+        channelId: z.string(),
+        targetUrl: z.string(),
+    }),
+});
+const linkSchema = z.object({
+    url: z.string(),
+    status: z.number(),
+    state: z.enum(['OK', 'BROKEN']),
+    parent: z.string().optional(),
+});
+const getBrokenLinks = new Step({
+    id: 'get-broken-links',
+    description: 'Get broken links',
+    inputSchema: z.object({
+        targetUrl: z.string(),
+    }),
+    outputSchema: z.object({
+        brokenLinks: z.array(linkSchema),
+    }),
+    execute: async ({ context }) => {
+        const targetUrl = context.targetUrl;
+        const res = await exec(`npx linkinator ${targetUrl} --format json`, {
+            encoding: 'utf-8',
+        });
+        if (res.stderr) {
+            throw new Error(res.stderr);
+        }
+        const data = JSON.parse(res.stdout);
+        const parsedData = linkSchema.array().parse(data.links);
+        return {
+            brokenLinks: parsedData.filter(link => link.state === 'BROKEN'),
+        };
+    },
+});
+const reportBrokenLinks = new Step({
+    id: 'report-broken-links',
+    description: 'Report broken links',
+    outputSchema: z.object({
+        message: z.string(),
+    }),
+    execute: async ({ context, mastra }) => {
+        const brokenLinks = context.machineContext?.getStepPayload('get-broken-links');
+        if (!brokenLinks) {
+            return {
+                message: 'No broken links found',
+            };
+        }
+        if (brokenLinks.brokenLinks.length === 0) {
+            return {
+                message: 'No broken links found',
+            };
+        }
+        try {
+            await slack.connect();
+        }
+        catch (e) {
+            console.error(e);
+        }
+        const triggerPayload = context.machineContext?.getStepPayload('trigger');
+        if (!triggerPayload) {
+            return {
+                message: 'Trigger payload not found',
+            };
+        }
+        const agent = mastra?.agents?.daneLinkChecker;
+        if (!agent) {
+            return {
+                message: 'Agent not found',
+            };
+        }
+        const tools = await slack.tools();
+        console.log(`🤖Generating...`);
+        const res = await agent.generate(`
+      Send this ${JSON.stringify(brokenLinks, null, 2)} to this slack channel: "${triggerPayload.channelId}" with the tool slack_post_message.
+      Format it in markdown so it displays nicely in slack.
+      `, {
+            toolsets: { slack: tools },
+        });
+        console.log(chalk.green(res.text));
+        return {
+            message: res.text,
+        };
+    },
+});
+linkCheckerWorkflow
+    .step(getBrokenLinks, {
+    variables: {
+        targetUrl: { step: 'trigger', path: 'targetUrl' },
+    },
+})
+    .then(reportBrokenLinks)
+    .commit();

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

@@ -0,0 +1,3 @@
+import { Workflow } from '@mastra/core';
+export declare const packagePublisher: Workflow<any, any>;
+//# sourceMappingURL=publish-packages.d.ts.map

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

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

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

@@ -0,0 +1,344 @@
+import { Step, Workflow } from '@mastra/core';
+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.js';
+export const packagePublisher = new Workflow({
+    name: 'pnpm-changset-publisher',
+});
+const outputSchema = z.object({
+    packages: z.array(z.string()),
+    integrations: z.array(z.string()),
+    deployers: z.array(z.string()),
+    vector_stores: z.array(z.string()),
+    speech: z.array(z.string()),
+});
+const defaultSet = {
+    packages: [],
+    deployers: [],
+    integrations: [],
+    vector_stores: [],
+    speech: [],
+};
+const getPacakgesToPublish = new Step({
+    id: 'getPacakgesToPublish',
+    outputSchema,
+    execute: async ({ mastra }) => {
+        const agent = mastra?.agents?.['danePackagePublisher'];
+        if (!agent) {
+            throw new Error('Agent not found');
+        }
+        const result = await agent.generate(PACKAGES_LIST_PROMPT);
+        console.log(chalk.green(`\n${result.text}`));
+        const resultObj = await agent.generate(`
+      Please convert this into a structured object:
+
+      Input Text: ${result.text}
+
+      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 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()),
+                vector_stores: z.array(z.string()),
+                speech: z.array(z.string()),
+            }),
+        });
+        return {
+            packages: resultObj?.object?.packages,
+            integrations: resultObj?.object?.integrations,
+            deployers: resultObj?.object?.deployers,
+            vector_stores: resultObj?.object?.vector_stores,
+            speech: resultObj?.object?.speech,
+        };
+    },
+});
+const assemblePackages = new Step({
+    id: 'assemblePackages',
+    outputSchema,
+    execute: async ({ context }) => {
+        if (context.machineContext?.stepResults.getPacakgesToPublish?.status !== 'success') {
+            return {
+                packages: [],
+                integrations: [],
+                deployers: [],
+                vector_stores: [],
+                speech: [],
+            };
+        }
+        const payload = context.machineContext.stepResults.getPacakgesToPublish.payload;
+        const packagesToBuild = new Set();
+        const deployersToBuild = new Set();
+        const integrationsToBuild = new Set();
+        const vector_storesToBuild = new Set();
+        const speechToBuild = new Set();
+        if (payload?.packages) {
+            payload.packages.forEach((pkg) => {
+                let pkgName = pkg.replace('@mastra/', '');
+                if (pkgName === 'mastra') {
+                    pkgName = 'cli';
+                }
+                const pkgPath = path.join(process.cwd(), 'packages', pkgName);
+                packagesToBuild.add(pkgPath);
+            });
+        }
+        if (payload?.deployers) {
+            payload.deployers.forEach((pkg) => {
+                let pkgName = pkg.replace('@mastra/deployer-', '');
+                if (pkgName === 'mastra') {
+                    pkgName = 'cli';
+                }
+                const pkgPath = path.join(process.cwd(), 'deployers', pkgName);
+                deployersToBuild.add(pkgPath);
+            });
+        }
+        if (payload?.vector_stores) {
+            payload.vector_stores.forEach((pkg) => {
+                let pkgName = pkg.replace('@mastra/vector-', '');
+                const pkgPath = path.join(process.cwd(), 'vector-stores', pkgName);
+                vector_storesToBuild.add(pkgPath);
+            });
+        }
+        if (payload?.integrations) {
+            const integrations = payload.integrations;
+            integrations.forEach((integration) => {
+                let pkgName = integration.replace('@mastra/', '');
+                const integrationPath = path.join(process.cwd(), 'integrations', pkgName);
+                integrationsToBuild.add(integrationPath);
+            });
+        }
+        if (payload?.speech) {
+            const speecs = payload.speech;
+            speecs.forEach((speech) => {
+                let pkgName = speech.replace('@mastra/speech-', '');
+                const speechPath = path.join(process.cwd(), 'speech', pkgName);
+                speechToBuild.add(speechPath);
+            });
+        }
+        const pkgSet = Array.from(packagesToBuild.keys());
+        const deploySet = Array.from(deployersToBuild.keys());
+        const integrationSet = Array.from(integrationsToBuild.keys());
+        const vectorStoreSet = Array.from(vector_storesToBuild.keys());
+        const speechSet = Array.from(speechToBuild.keys());
+        if (!packagesToBuild.size && !deployersToBuild.size && !integrationsToBuild.size && !vector_storesToBuild.size) {
+            console.error(chalk.red('No packages to build.'));
+            return defaultSet;
+        }
+        console.log(chalk.green(`\nBuilding packages:\n`));
+        pkgSet.forEach((pkg) => {
+            console.log(chalk.green(pkg));
+        });
+        if (deploySet.length > 0) {
+            console.log(chalk.green(`\nBuilding deployers:\n`));
+            deploySet.forEach((pkg) => {
+                console.log(chalk.green(pkg));
+            });
+        }
+        if (integrationSet.length > 0) {
+            console.log(chalk.green(`\nBuilding integrations:\n`));
+            integrationSet.forEach((pkg) => {
+                console.log(chalk.green(pkg));
+            });
+        }
+        if (vectorStoreSet.length > 0) {
+            console.log(chalk.green(`\nBuilding vector stores:\n`));
+            vectorStoreSet.forEach((pkg) => {
+                console.log(chalk.green(pkg));
+            });
+        }
+        if (speechSet.length > 0) {
+            console.log(chalk.green(`\nBuilding speech:\n`));
+            speechSet.forEach((pkg) => {
+                console.log(chalk.green(pkg));
+            });
+        }
+        return {
+            packages: pkgSet,
+            deployers: deploySet,
+            integrations: integrationSet,
+            vector_stores: vectorStoreSet,
+            speech: speechSet,
+        };
+    },
+});
+async function buildSet(agent, list) {
+    let res = await agent.generate(BUILD_PACKAGES_PROMPT(list));
+    console.log(chalk.green(res.text));
+    return res.text;
+}
+const buildPackages = new Step({
+    id: 'buildPackages',
+    outputSchema,
+    execute: async ({ context, mastra }) => {
+        if (context.machineContext?.stepResults.assemblePackages?.status !== 'success') {
+            return defaultSet;
+        }
+        const pkgSet = context.machineContext.stepResults.assemblePackages.payload.packages;
+        const deploySet = context.machineContext.stepResults.assemblePackages.payload.deployers;
+        const integrationSet = context.machineContext.stepResults.assemblePackages.payload.integrations;
+        const vectorStoreSet = context.machineContext.stepResults.assemblePackages.payload.vector_stores;
+        const speechSet = context.machineContext.stepResults.assemblePackages.payload.speech;
+        const agent = mastra?.agents?.['danePackagePublisher'];
+        if (!agent) {
+            throw new Error('Agent not found');
+        }
+        let built = false;
+        if (pkgSet.length > 0) {
+            built = true;
+            await buildSet(agent, pkgSet);
+        }
+        if (deploySet.length > 0) {
+            await buildSet(agent, deploySet);
+            built = true;
+        }
+        if (integrationSet.length > 0) {
+            await buildSet(agent, integrationSet);
+            built = true;
+        }
+        if (vectorStoreSet.length > 0) {
+            await buildSet(agent, vectorStoreSet);
+            built = true;
+        }
+        if (speechSet.length > 0) {
+            await buildSet(agent, speechSet);
+            built = true;
+        }
+        if (!built) {
+            console.error(chalk.red('Failed to build one or more packages'));
+            throw new Error('Failed to build one or more packages');
+        }
+        return {
+            packages: pkgSet,
+            deployers: deploySet,
+            integrations: integrationSet,
+            vector_stores: vectorStoreSet,
+            speech: speechSet,
+        };
+    },
+});
+const verifyBuild = new Step({
+    id: 'verifyBuild',
+    outputSchema: z.object({
+        packages: z.array(z.string()),
+    }),
+    execute: async ({ context }) => {
+        if (context.machineContext?.stepResults.buildPackages?.status !== 'success') {
+            return {
+                packages: [],
+            };
+        }
+        const pkgSet = context.machineContext.stepResults.buildPackages.payload.packages;
+        const deploySet = context.machineContext.stepResults.buildPackages.payload.deployers;
+        const integrationSet = context.machineContext.stepResults.buildPackages.payload.integrations;
+        const vectorStoreSet = context.machineContext.stepResults.buildPackages.payload.vector_stores;
+        const speechSet = context.machineContext.stepResults.buildPackages.payload.speech;
+        const allPackages = [...pkgSet, ...deploySet, ...integrationSet, ...vectorStoreSet, ...speechSet];
+        function checkMissingPackages(pkgSet) {
+            const missingPackages = [];
+            for (const pkg of pkgSet) {
+                if (!existsSync(`${pkg}/dist`)) {
+                    console.error(chalk.red(`We did not find the dist folder for ${pkg}.`));
+                    missingPackages.push(pkg);
+                }
+            }
+            return missingPackages;
+        }
+        console.log('Verifying the output for:', context.machineContext.stepResults.buildPackages.payload.allPackages);
+        const missingPackages = checkMissingPackages(allPackages);
+        if (missingPackages.length > 0) {
+            console.error(chalk.red(`Missing packages: ${missingPackages.join(', ')}`));
+            throw new Error('Failed to build one or more packages');
+        }
+        return {
+            packages: allPackages,
+        };
+    },
+});
+const publishChangeset = new Step({
+    id: 'publishChangeset',
+    outputSchema: z.object({
+        packages: z.array(z.string()),
+    }),
+    execute: async ({ context, mastra }) => {
+        if (context.machineContext?.stepResults.buildPackages?.status !== 'success') {
+            return {
+                packages: [],
+            };
+        }
+        const pkgSet = context.machineContext.stepResults.buildPackages.payload.packages;
+        const agent = mastra?.agents?.['danePackagePublisher'];
+        if (!agent) {
+            throw new Error('Agent not found');
+        }
+        const res = await agent.generate(PUBLISH_PACKAGES_PROMPT);
+        console.log(chalk.green(res.text));
+        return { packages: pkgSet };
+    },
+});
+const setLatestDistTag = new Step({
+    id: 'setLatestDistTag',
+    outputSchema: z.object({
+        packages: z.array(z.string()),
+    }),
+    execute: async ({ context, mastra }) => {
+        if (context.machineContext?.stepResults.publishChangeset?.status !== 'success') {
+            return {
+                packages: [],
+            };
+        }
+        const pkgSet = context.machineContext.stepResults.publishChangeset.payload.packages;
+        const agent = mastra?.agents?.['danePackagePublisher'];
+        if (!agent) {
+            throw new Error('Agent not found');
+        }
+        let res = await agent.generate(`
+            Set the active tag for these packages ${pkgSet.join(',')}.
+        `);
+        console.log(chalk.green(res.text));
+        return { packages: pkgSet };
+    },
+});
+packagePublisher
+    .step(getPacakgesToPublish)
+    .then(assemblePackages)
+    .then(buildPackages, {
+    when: async ({ context }) => {
+        return (context.stepResults.assemblePackages?.status === 'success' &&
+            context.stepResults.assemblePackages?.payload?.packages.length > 0);
+    },
+})
+    .then(verifyBuild, {
+    when: async ({ context }) => {
+        return (context.stepResults.buildPackages?.status === 'success' &&
+            context.stepResults.buildPackages?.payload?.packages.length > 0);
+    },
+})
+    .after(verifyBuild)
+    .step(publishChangeset, {
+    when: async ({ context }) => {
+        return (context.stepResults.buildPackages?.status === 'success' &&
+            context.stepResults.buildPackages?.payload?.packages.length > 0);
+    },
+})
+    .then(setLatestDistTag, {
+    when: async ({ context }) => {
+        return (context.stepResults.publishChangeset?.status === 'success' &&
+            context.stepResults.publishChangeset?.payload?.packages.length > 0);
+    },
+})
+    .commit();

package/dist/mastra/workflows/telephone-game.d.ts

@@ -0,0 +1,3 @@
+import { Workflow } from '@mastra/core';
+export declare const telephoneGameWorkflow: Workflow<any, any>;
+//# sourceMappingURL=telephone-game.d.ts.map

package/dist/mastra/workflows/telephone-game.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"telephone-game.d.ts","sourceRoot":"","sources":["../../../src/mastra/workflows/telephone-game.ts"],"names":[],"mappings":"AACA,OAAO,EAAQ,QAAQ,EAAiB,MAAM,cAAc,CAAC;AAG7D,eAAO,MAAM,qBAAqB,oBAEhC,CAAC"}

package/dist/mastra/workflows/telephone-game.js

@@ -0,0 +1,95 @@
+import { input } from '@inquirer/prompts';
+import { Step, Workflow, getStepResult } from '@mastra/core';
+import { z } from 'zod';
+export const telephoneGameWorkflow = new Workflow({
+    name: 'telephoneGame',
+});
+const stepA1 = new Step({
+    id: 'stepA1',
+    description: 'Starts the message',
+    outputSchema: z.object({
+        message: z.string(),
+    }),
+    execute: async () => {
+        return {
+            message: 'Test',
+        };
+    },
+});
+const stepA2 = new Step({
+    id: 'stepA2',
+    description: 'Pass the message through',
+    outputSchema: z.object({
+        message: z.string(),
+    }),
+    execute: async () => {
+        const content = await input({
+            message: 'Give me a message',
+            validate: input => input.trim().length > 0 || 'Message cannot be empty',
+        });
+        return {
+            message: content,
+        };
+    },
+});
+const stepB2 = new Step({
+    id: 'stepB2',
+    description: 'Checks if the file exists',
+    outputSchema: z.object({
+        message: z.string(),
+    }),
+    execute: async ({ context }) => {
+        if (context.machineContext?.stepResults.stepA2?.status !== 'success') {
+            throw new Error('Message not found');
+        }
+        const msg = context.machineContext.stepResults.stepA2.payload.message;
+        return {
+            message: msg,
+        };
+    },
+});
+const stepC2 = new Step({
+    id: 'stepC2',
+    description: 'Ask if you should modify the message',
+    outputSchema: z.object({
+        message: z.string(),
+    }),
+    execute: async ({ suspend, context, mastra }) => {
+        const oMsg = getStepResult(context?.machineContext?.stepResults.stepA2);
+        if (context?.machineContext?.stepResults.stepC2?.status === 'success') {
+            const msg = getStepResult(context?.machineContext?.stepResults.stepC2);
+            if (msg.confirm) {
+                if (mastra?.llm) {
+                    const llm = mastra?.llm({
+                        provider: 'ANTHROPIC',
+                        name: 'claude-3-5-haiku-20241022',
+                    });
+                    const result = await llm.generate(`
+            You are playing a game of telephone.
+            Here is the message the previous person sent ${oMsg.message}. 
+            But you want to change the message. 
+            Only return the message
+            `);
+                    return {
+                        message: result.text,
+                    };
+                }
+            }
+            return oMsg;
+        }
+        await suspend();
+        return { message: 'Suspended' };
+    },
+});
+const stepD2 = new Step({
+    id: 'stepD2',
+    description: 'Pass the message',
+    outputSchema: z.object({
+        message: z.string(),
+    }),
+    execute: async ({ context }) => {
+        const msg = getStepResult(context?.machineContext?.stepResults.stepC2);
+        return msg;
+    },
+});
+telephoneGameWorkflow.step(stepA1).step(stepA2).then(stepB2).then(stepC2).then(stepD2).commit();

package/package.json

@@ -1,8 +1,14 @@
 {
   "name": "@mastra/dane",
-  "version": "0.0.2-alpha.0",
+  "version": "0.0.2-alpha.100",
   "main": "dist/index.js",
   "type": "module",
+  "files": [
+    "dist",
+    "data",
+    "test",
+    "test-files"
+  ],
   "bin": {
     "dane": "./dist/index.js"
   },
@@ -16,12 +22,14 @@
     "tsx": "^4.19.2"
   },
   "dependencies": {
+    "@inquirer/prompts": "^7.2.1",
     "boxen": "^8.0.1",
     "chalk": "^5.3.0",
     "cli-table3": "^0.6.5",
     "commander": "^12.1.0",
+    "dotenv": "^16.4.7",
+    "drizzle-kit": "^0.30.1",
     "execa": "^9.3.1",
-    "inquirer": "^12.2.0",
     "luxon": "^3.5.0",
     "node-ical": "^0.20.1",
     "node-screenshots": "^0.2.1",
@@ -29,18 +37,19 @@
     "playwright": "^1.49.1",
     "playwright-core": "^1.49.1",
     "sqlite3": "^5.1.7",
-    "typescript": "^5.5.4",
+    "typescript": "^5.7.3",
     "zod": "^3.24.0",
-    "@mastra/firecrawl": "1.0.4-alpha.21",
-    "@mastra/core": "0.1.27-alpha.37",
-    "@mastra/engine": "0.0.5-alpha.31",
-    "@mastra/memory": "0.0.2-alpha.16",
-    "@mastra/github": "1.0.3-alpha.20",
-    "@mastra/rag": "0.0.2-alpha.21"
+    "@mastra/engine": "0.0.5-alpha.75",
+    "@mastra/github": "1.0.3-alpha.64",
+    "@mastra/memory": "0.0.2-alpha.62",
+    "@mastra/rag": "0.0.2-alpha.71",
+    "@mastra/mcp": "0.0.1-alpha.22",
+    "@mastra/firecrawl": "1.0.4-alpha.73",
+    "@mastra/stabilityai": "1.0.1-alpha.55",
+    "@mastra/core": "0.1.27-alpha.80"
   },
   "scripts": {
     "build": "npx tsc",
-    "issue-labeler": "npx bun src/issue-labeler.ts",
     "start": "npx bun src/index.ts",
     "test": "echo \"Error: no test specified\" && exit 1"
   }

package/CHANGELOG.md

@@ -1,19 +0,0 @@
-# @mastra/dane
-
-## 0.0.2-alpha.0
-
-### Patch Changes
-
-- b5393f1: New example: Dane and many fixes to make it work
-- 697fbbe: Setup Dane, a cli assistant using the mastra framework.
-- Updated dependencies [45fd5b8]
-- Updated dependencies [c872875]
-- Updated dependencies [f6da688]
-- Updated dependencies [1cc6cc0]
-- Updated dependencies [b5393f1]
-  - @mastra/rag@0.0.2-alpha.21
-  - @mastra/core@0.1.27-alpha.37
-  - @mastra/engine@0.0.5-alpha.31
-  - @mastra/firecrawl@1.0.4-alpha.21
-  - @mastra/memory@0.0.2-alpha.16
-  - @mastra/github@1.0.3-alpha.20

package/docker-compose.yaml

@@ -1,22 +0,0 @@
-services:
-  db:
-    image: pgvector/pgvector:pg16
-    container_name: 'dane-db'
-    ports:
-      - '5433:5432'
-    environment:
-      POSTGRES_USER: ${POSTGRES_USER:-postgres}
-      POSTGRES_PASSWORD: ${POSTGRES_PASSWORD:-postgres}
-      POSTGRES_DB: ${POSTGRES_DB:-mastra}
-  redis:
-    image: redis
-    ports:
-      - 6379:6379
-  serverless-redis-http:
-      ports:
-        - "8079:80"
-      image: hiett/serverless-redis-http:latest
-      environment:
-        SRH_MODE: env
-        SRH_TOKEN: example_token
-        SRH_CONNECTION_STRING: "redis://redis:6379" # Using `redis` hostname since they're in the same Docker network.