@mastra/dane 0.0.2-alpha.2 → 0.0.2-alpha.3

package/dist/mastra/tools/browser.js

@@ -0,0 +1,118 @@
+import { createTool } from '@mastra/core';
+import { MDocument } from '@mastra/rag';
+import chalk from 'chalk';
+import { chromium } from 'playwright-core';
+import { z } from 'zod';
+export const browserTool = createTool({
+    id: 'browserTool',
+    name: 'Browser Tool',
+    description: 'Browser Tool, opens a browser and navigates to a url capturing the content',
+    inputSchema: z.object({
+        url: z.string(),
+    }),
+    outputSchema: z.object({
+        message: z.string(),
+    }),
+    execute: async ({ context: { url } }) => {
+        try {
+            const browser = await chromium.launch({
+                headless: true,
+            });
+            const page = await browser.newPage();
+            await page.goto(url);
+            const docs = MDocument.fromHTML(await page.content());
+            await docs.chunk({
+                strategy: 'html',
+                options: {
+                    chunkSize: 300,
+                    sections: [
+                        ['h1', 'Header 1'],
+                        ['h2', 'Header 2'],
+                        ['h3', 'Header 3'],
+                        ['h4', 'Header 4'],
+                        ['h5', 'Header 5'],
+                        ['h6', 'Header 6'],
+                        ['p', 'Paragraph'],
+                    ],
+                },
+            });
+            await page.close();
+            await browser.close();
+            if (!docs.getText().length) {
+                return { message: 'No content' };
+            }
+            return { message: docs.getText().join('\n') };
+        }
+        catch (e) {
+            if (e instanceof Error) {
+                console.log(`\n${chalk.red(e.message)}`);
+                return { message: `Error: ${e.message}` };
+            }
+            return { message: 'Error' };
+        }
+    },
+});
+export const googleSearch = createTool({
+    id: 'googleSearch',
+    name: 'Google Search',
+    description: 'Google Search. Passes the query to Google and returns the search results.',
+    inputSchema: z.object({
+        query: z.string(),
+    }),
+    outputSchema: z.object({
+        message: z.string(),
+    }),
+    execute: async ({ context: { query } }) => {
+        let browser;
+        try {
+            browser = await chromium.launch({
+                headless: true,
+            });
+        }
+        catch (e) {
+            if (e instanceof Error) {
+                console.log(`\n${chalk.red(e.message)}`);
+                return { message: `Error: ${e.message}` };
+            }
+            return { message: 'Error' };
+        }
+        try {
+            const page = await browser.newPage();
+            await page.goto(`https://www.google.com/search?q=${encodeURIComponent(query)}`);
+            console.log(`\n`);
+            console.log(chalk.blue('Waiting for search results...'));
+            try {
+                await page.click('button:has-text("Accept all")', { timeout: 5000 });
+            }
+            catch (e) {
+                // Cookie dialog didn't appear, continue
+            }
+            // Wait for results and click first organic result
+            await page.waitForSelector('#search');
+            const text = await page.evaluate(() => {
+                const links = [];
+                const searchResults = document.querySelectorAll('div.g a');
+                searchResults.forEach(link => {
+                    const href = link.getAttribute('href');
+                    if (href && href.startsWith('http')) {
+                        links.push(href);
+                    }
+                });
+                return links;
+            });
+            await page.close();
+            await browser.close();
+            if (!text.length) {
+                return { message: 'No results' };
+            }
+            return { message: text.join('\n') };
+        }
+        catch (e) {
+            if (e instanceof Error) {
+                console.log(`\n${chalk.red(e.message)}`);
+                return { message: `Error: ${e.message}` };
+            }
+            return { message: `Error` };
+        }
+    },
+});

package/dist/mastra/tools/calendar.d.ts

@@ -0,0 +1,20 @@
+import { z } from 'zod';
+export declare const listEvents: import("@mastra/core").Tool<"listEvents", z.ZodObject<{
+    startDate: z.ZodString;
+}, "strip", z.ZodTypeAny, {
+    startDate: string;
+}, {
+    startDate: string;
+}>, z.ZodObject<{
+    content: z.ZodString;
+}, "strip", z.ZodTypeAny, {
+    content: string;
+}, {
+    content: string;
+}>, import("@mastra/core").ToolExecutionContext<z.ZodObject<{
+    startDate: z.ZodString;
+}, "strip", z.ZodTypeAny, {
+    startDate: string;
+}, {
+    startDate: string;
+}>, import("@mastra/core").WorkflowContext<any>>>;

package/dist/mastra/tools/calendar.js

@@ -0,0 +1,134 @@
+import { createTool } from '@mastra/core';
+import chalk from 'chalk';
+import { execSync } from 'child_process';
+import Table from 'cli-table3';
+import { z } from 'zod';
+class LocalCalendarReader {
+    async getEvents() {
+        const script = `
+          tell application "Calendar"
+            set eventList to {}
+            set startDate to (current date) - 7 * days
+            set endDate to (current date) + 365 * days
+            
+            repeat with calendarAccount in calendars
+              set eventList to eventList & (every event of calendarAccount whose start date is greater than or equal to startDate and start date is less than or equal to endDate)
+            end repeat
+            
+            set output to ""
+            repeat with anEvent in eventList
+              set theTitle to summary of anEvent
+              set theStart to start date of anEvent as string
+              set theEnd to end date of anEvent as string
+              set theLoc to location of anEvent
+              set theDesc to description of anEvent
+              
+              if theLoc is missing value then
+                set theLoc to ""
+              end if
+              if theDesc is missing value then
+                set theDesc to ""
+              end if
+              
+              set output to output & theTitle & "|" & theStart & "|" & theEnd & "|" & theLoc & "|" & theDesc & "
+    "
+            end repeat
+            
+            return output
+          end tell
+        `;
+        try {
+            const result = execSync(`osascript -e '${script}'`).toString();
+            return this.parseAppleScriptOutput(result);
+        }
+        catch (error) {
+            if (error instanceof Error) {
+                console.error('Raw AppleScript error:', error.message);
+                throw new Error(`Failed to read Mac calendar: ${error.message}`);
+            }
+            else {
+                console.error('An unknown error occurred:', error);
+                throw new Error('Failed to read Mac calendar');
+            }
+        }
+    }
+    parseAppleScriptOutput(output) {
+        const events = [];
+        const lines = output.split('\n').filter(line => line.trim());
+        for (const line of lines) {
+            try {
+                const [title, startDateStr, endDateStr, location, description] = line.split('|');
+                const startStandardized = startDateStr
+                    ?.split(',')?.[1] // Remove day name
+                    ?.replace(' at ', ' ') // Remove 'at'
+                    ?.trim(); // 'January 3, 2025 9:00:00 AM'
+                const startDate = new Date(startStandardized || '');
+                const endStandardized = endDateStr
+                    ?.split(',')?.[1] // Remove day name
+                    ?.replace(' at ', ' ') // Remove 'at'
+                    ?.trim(); // 'January 3, 2025 9:00:00 AM'
+                const endDate = new Date(endStandardized || '');
+                const event = {
+                    title: title?.trim(),
+                    startDate,
+                    endDate,
+                    location: location?.trim() || '',
+                    description: description?.trim() || '',
+                };
+                events.push(event);
+            }
+            catch (error) {
+                console.error('Failed to parse event line:', line, error);
+            }
+        }
+        return events.sort((a, b) => a.startDate.getTime() - b.startDate.getTime());
+    }
+}
+const reader = new LocalCalendarReader();
+export const listEvents = createTool({
+    id: 'listEvents',
+    name: 'List Events',
+    description: 'List calendar events',
+    inputSchema: z.object({
+        startDate: z.string(),
+    }),
+    outputSchema: z.object({
+        content: z.string(),
+    }),
+    execute: async () => {
+        try {
+            const events = await reader.getEvents();
+            const table = new Table({
+                head: [
+                    chalk.blue('Start'),
+                    chalk.blue('End'),
+                    chalk.blue('Title'),
+                    chalk.blue('Location'),
+                    chalk.blue('Description'),
+                ],
+                colWidths: [12, 15, 30, 20, 40],
+            });
+            events.forEach(event => {
+                if (event.title) {
+                    table.push([
+                        event.startDate.toISOString(),
+                        event.endDate.toISOString(),
+                        event.title || '',
+                        event.location || '',
+                        (event.description || '').substring(0, 37) + '...',
+                    ]);
+                }
+            });
+            // console.log(chalk.blue(table.toString()));
+            return {
+                content: JSON.stringify(events, null, 2),
+            };
+        }
+        catch (e) {
+            if (e instanceof Error) {
+                console.log(`\n${chalk.red(e.message)}`);
+            }
+            return { content: 'Error' };
+        }
+    },
+});

package/dist/mastra/tools/crawl.d.ts

@@ -0,0 +1,32 @@
+import { z } from 'zod';
+export declare const crawl: import("@mastra/core").Tool<"crawler", z.ZodObject<{
+    url: z.ZodString;
+    limit: z.ZodDefault<z.ZodNumber>;
+    pathRegex: z.ZodNullable<z.ZodString>;
+}, "strip", z.ZodTypeAny, {
+    url: string;
+    limit: number;
+    pathRegex: string | null;
+}, {
+    url: string;
+    pathRegex: string | null;
+    limit?: number | undefined;
+}>, z.ZodObject<{
+    message: z.ZodString;
+}, "strip", z.ZodTypeAny, {
+    message: string;
+}, {
+    message: string;
+}>, import("@mastra/core").ToolExecutionContext<z.ZodObject<{
+    url: z.ZodString;
+    limit: z.ZodDefault<z.ZodNumber>;
+    pathRegex: z.ZodNullable<z.ZodString>;
+}, "strip", z.ZodTypeAny, {
+    url: string;
+    limit: number;
+    pathRegex: string | null;
+}, {
+    url: string;
+    pathRegex: string | null;
+    limit?: number | undefined;
+}>, import("@mastra/core").WorkflowContext<any>>>;

package/dist/mastra/tools/crawl.js

@@ -0,0 +1,24 @@
+import { createTool } from '@mastra/core';
+import { z } from 'zod';
+export const crawl = createTool({
+    id: 'crawler',
+    name: 'Crawler Tool',
+    description: 'Crawler Tool to crawl a website and return the content',
+    inputSchema: z.object({
+        url: z.string(),
+        limit: z.number().default(3),
+        pathRegex: z.string().nullable(),
+    }),
+    outputSchema: z.object({
+        message: z.string(),
+    }),
+    execute: async ({ context, mastra }) => {
+        await mastra?.syncs?.['FIRECRAWL:CRAWL_AND_SYNC']?.execute({
+            context,
+            mastra,
+        });
+        return {
+            message: 'The website has been successfully crawled and chunks have been synced to the database. Finish.',
+        };
+    },
+});

package/dist/mastra/tools/execa.d.ts

@@ -0,0 +1,26 @@
+import { z } from 'zod';
+export declare const execaTool: import("@mastra/core").Tool<"execaTool", z.ZodObject<{
+    command: z.ZodString;
+    args: z.ZodArray<z.ZodString, "many">;
+}, "strip", z.ZodTypeAny, {
+    command: string;
+    args: string[];
+}, {
+    command: string;
+    args: string[];
+}>, z.ZodObject<{
+    message: z.ZodString;
+}, "strip", z.ZodTypeAny, {
+    message: string;
+}, {
+    message: string;
+}>, import("@mastra/core").ToolExecutionContext<z.ZodObject<{
+    command: z.ZodString;
+    args: z.ZodArray<z.ZodString, "many">;
+}, "strip", z.ZodTypeAny, {
+    command: string;
+    args: string[];
+}, {
+    command: string;
+    args: string[];
+}>, import("@mastra/core").WorkflowContext<any>>>;

package/dist/mastra/tools/execa.js

@@ -0,0 +1,39 @@
+import { createTool } from '@mastra/core';
+import chalk from 'chalk';
+import { execa } from 'execa';
+import { Transform } from 'stream';
+import { z } from 'zod';
+// Create transform stream that applies chalk
+const colorTransform = new Transform({
+    transform(chunk, _encoding, callback) {
+        // Convert chunk to string and apply chalk
+        const colored = chalk.blue(chunk.toString());
+        this.push(colored);
+        callback();
+    },
+});
+export const execaTool = createTool({
+    id: 'execaTool',
+    name: 'Execa System Tool',
+    description: 'Execa System Tool',
+    inputSchema: z.object({
+        command: z.string(),
+        args: z.array(z.string()),
+    }),
+    outputSchema: z.object({
+        message: z.string(),
+    }),
+    execute: async ({ context: { command, args } }) => {
+        try {
+            const p = execa(command, args);
+            console.log(`\n`);
+            p.stdout.pipe(colorTransform).pipe(process.stdout);
+            p.stderr.pipe(colorTransform).pipe(process.stderr);
+            const r = await p;
+            return { message: r.stdout };
+        }
+        catch (e) {
+            return { message: 'Error' };
+        }
+    },
+});

package/dist/mastra/tools/fs.d.ts

@@ -0,0 +1,32 @@
+import { z } from 'zod';
+export declare const fsTool: import("@mastra/core").Tool<"fsTool", z.ZodObject<{
+    action: z.ZodString;
+    file: z.ZodString;
+    data: z.ZodString;
+}, "strip", z.ZodTypeAny, {
+    data: string;
+    action: string;
+    file: string;
+}, {
+    data: string;
+    action: string;
+    file: string;
+}>, z.ZodObject<{
+    message: z.ZodString;
+}, "strip", z.ZodTypeAny, {
+    message: string;
+}, {
+    message: string;
+}>, import("@mastra/core").ToolExecutionContext<z.ZodObject<{
+    action: z.ZodString;
+    file: z.ZodString;
+    data: z.ZodString;
+}, "strip", z.ZodTypeAny, {
+    data: string;
+    action: string;
+    file: string;
+}, {
+    data: string;
+    action: string;
+    file: string;
+}>, import("@mastra/core").WorkflowContext<any>>>;

package/dist/mastra/tools/fs.js

@@ -0,0 +1,36 @@
+import { createTool } from '@mastra/core';
+import { readFileSync, writeFileSync } from 'fs';
+import { z } from 'zod';
+export const fsTool = createTool({
+    id: 'fsTool',
+    name: 'File System Tool',
+    description: 'File System Tool',
+    inputSchema: z.object({
+        action: z.string(),
+        file: z.string(),
+        data: z.string(),
+    }),
+    outputSchema: z.object({
+        message: z.string(),
+    }),
+    execute: async ({ context: { action, file, data } }) => {
+        try {
+            switch (action) {
+                case 'write':
+                    writeFileSync(file, data);
+                    break;
+                case 'read':
+                    return { message: readFileSync(file, 'utf8') };
+                case 'append':
+                    writeFileSync(file, data, { flag: 'a' });
+                    break;
+                default:
+                    return { message: 'Invalid action' };
+            }
+            return { message: 'Success' };
+        }
+        catch (e) {
+            return { message: 'Error' };
+        }
+    },
+});

package/dist/mastra/tools/pdf.d.ts

@@ -0,0 +1,20 @@
+import { z } from 'zod';
+export declare const readPDF: import("@mastra/core").Tool<"readPDF", z.ZodObject<{
+    pdfPath: z.ZodString;
+}, "strip", z.ZodTypeAny, {
+    pdfPath: string;
+}, {
+    pdfPath: string;
+}>, z.ZodObject<{
+    content: z.ZodString;
+}, "strip", z.ZodTypeAny, {
+    content: string;
+}, {
+    content: string;
+}>, import("@mastra/core").ToolExecutionContext<z.ZodObject<{
+    pdfPath: z.ZodString;
+}, "strip", z.ZodTypeAny, {
+    pdfPath: string;
+}, {
+    pdfPath: string;
+}>, import("@mastra/core").WorkflowContext<any>>>;

package/dist/mastra/tools/pdf.js

@@ -0,0 +1,41 @@
+import { createTool } from '@mastra/core';
+import chalk from 'chalk';
+import { existsSync, readFileSync } from 'fs';
+import path from 'path';
+import pdf from 'pdf-parse';
+import { z } from 'zod';
+export const readPDF = createTool({
+    id: 'readPDF',
+    name: 'Read PDF',
+    description: 'Read PDF file and extract information',
+    inputSchema: z.object({
+        pdfPath: z.string(),
+    }),
+    outputSchema: z.object({
+        content: z.string(),
+    }),
+    execute: async ({ context: { pdfPath } }) => {
+        try {
+            // Check if file exists
+            if (!existsSync(pdfPath)) {
+                throw new Error('PDF file not found');
+            }
+            // Check if file is a PDF
+            if (path.extname(pdfPath).toLowerCase() !== '.pdf') {
+                throw new Error('File is not a PDF');
+            }
+            // Read the PDF file
+            const dataBuffer = readFileSync(pdfPath);
+            // Parse PDF content
+            const data = await pdf(dataBuffer);
+            console.log(chalk.blue('\n'));
+            console.log(chalk.blue('PDF Information:'));
+            console.log(chalk.blue('-----------------'));
+            console.log(chalk.blue(`Number of pages: ${data.numpages}`));
+            return { content: data.text };
+        }
+        catch (e) {
+            return { content: 'Error scanning PDF' };
+        }
+    },
+});

package/dist/mastra/workflows/chat.d.ts

@@ -0,0 +1,12 @@
+import { Workflow } from '@mastra/core';
+import { z } from 'zod';
+export declare const messageWorkflow: Workflow<any, z.ZodObject<{
+    resourceid: z.ZodString;
+    threadId: z.ZodString;
+}, "strip", z.ZodTypeAny, {
+    resourceid: string;
+    threadId: string;
+}, {
+    resourceid: string;
+    threadId: string;
+}>>;

package/dist/mastra/workflows/chat.js

@@ -0,0 +1,93 @@
+import { Step, Workflow } from '@mastra/core';
+import chalk from 'chalk';
+import inquirer from 'inquirer';
+import { z } from 'zod';
+import { dane } from '../agents/index.js';
+export const messageWorkflow = new Workflow({
+    name: 'entry',
+    triggerSchema: z.object({
+        resourceid: z.string(),
+        threadId: z.string(),
+    }),
+});
+const messageStep = new Step({
+    id: 'message-input',
+    outputSchema: z.object({
+        message: z.string(),
+    }),
+    execute: async () => {
+        const { content } = await inquirer.prompt([
+            {
+                type: 'input',
+                name: 'content',
+                message: '\n You:',
+                validate: input => input.trim().length > 0 || 'Message cannot be empty',
+            },
+        ]);
+        return { message: content };
+    },
+});
+const messageOutputStep = new Step({
+    id: 'message-output',
+    outputSchema: z.object({
+        message: z.string(),
+    }),
+    // SHOULD BE ABLE TO ACCESS ALL MASTRA PRIMS FROM EXECTUE
+    execute: async ({ context, mastra }) => {
+        // WISH THIS WAS TYPED
+        const threadId = context?.machineContext?.triggerData?.threadId;
+        const resourceid = context?.machineContext?.triggerData?.resourceid;
+        const messageInputStatus = context?.machineContext?.stepResults?.['message-input']?.status;
+        if (messageInputStatus !== 'success') {
+            return { message: 'Failure in workflow' };
+        }
+        // is there someway to know what steps are flowing into this one and type their props
+        const message = context?.machineContext?.stepResults?.['message-input']?.payload?.message;
+        try {
+            let messages = await mastra?.memory?.getContextWindow({
+                threadId,
+                format: 'core_message',
+            });
+            if (!messages || messages.length === 0) {
+                messages = [];
+            }
+            const res = await mastra?.agents?.['dane']?.generate(message, {
+                stream: true,
+                maxSteps: 5,
+                resourceid,
+                threadId,
+                context: [],
+            });
+            if (res) {
+                console.log(chalk.green(`\nDane: \n`));
+                for await (const chunk of res.textStream) {
+                    process.stdout.write(chalk.green(chunk));
+                }
+                console.log(chalk.green(`\n`));
+                return { message: 'success' };
+            }
+        }
+        catch (e) {
+            console.log(chalk.red(`\n`));
+            console.log(chalk.red(`\n`));
+            console.log(chalk.red(`Error streaming results. Let's try again.`));
+            if (e instanceof Error) {
+                console.log(chalk.red(e.message));
+            }
+        }
+        const res = await dane.generate(message, {
+            maxSteps: 5,
+            threadId,
+            resourceid,
+        });
+        console.log(chalk.green(res?.text));
+        return { message: res?.text };
+    },
+});
+messageWorkflow
+    .step(messageStep)
+    .after(messageStep)
+    .step(messageOutputStep)
+    .after(messageOutputStep)
+    .step(messageStep)
+    .commit();

package/dist/mastra/workflows/index.js

@@ -0,0 +1,2 @@
+export * from './chat.js';
+export * from './issue-labeler.js';

package/dist/mastra/workflows/issue-labeler.d.ts

@@ -0,0 +1,15 @@
+import { Workflow } from '@mastra/core';
+import { z } from 'zod';
+export declare const githubIssueLabeler: Workflow<any, z.ZodObject<{
+    repo: z.ZodString;
+    owner: z.ZodString;
+    issue_number: z.ZodNumber;
+}, "strip", z.ZodTypeAny, {
+    repo: string;
+    owner: string;
+    issue_number: number;
+}, {
+    repo: string;
+    owner: string;
+    issue_number: number;
+}>>;