@mastra/dane 0.0.2-alpha.99 → 0.0.3

package/dist/mastra/tools/calendar.js

@@ -1,134 +0,0 @@
-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

@@ -1,36 +0,0 @@
-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;
-    crawlData: z.ZodAny;
-}, "strip", z.ZodTypeAny, {
-    message: string;
-    crawlData?: any;
-}, {
-    message: string;
-    crawlData?: any;
-}>, 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>>>;
-//# sourceMappingURL=crawl.d.ts.map

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

@@ -1 +0,0 @@
-{"version":3,"file":"crawl.d.ts","sourceRoot":"","sources":["../../../src/mastra/tools/crawl.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAIxB,eAAO,MAAM,KAAK;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iDAyBhB,CAAC"}

package/dist/mastra/tools/crawl.js

@@ -1,27 +0,0 @@
-import { createTool } from '@mastra/core';
-import { z } from 'zod';
-import { firecrawl } from '../integrations/index.js';
-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(),
-        crawlData: z.any(),
-    }),
-    execute: async ({ context }) => {
-        const crawlData = firecrawl.getWorkflows({})?.['FIRECRAWL:CRAWL_AND_SYNC']?.createRun();
-        await crawlData?.start({
-            triggerData: context,
-        });
-        return {
-            message: 'The website has been successfully crawled and chunks have been synced to the database. Finish.',
-            crawlData,
-        };
-    },
-});

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

@@ -1,27 +0,0 @@
-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>>>;
-//# sourceMappingURL=execa.d.ts.map

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

@@ -1 +0,0 @@
-{"version":3,"file":"execa.d.ts","sourceRoot":"","sources":["../../../src/mastra/tools/execa.ts"],"names":[],"mappings":"AAIA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAYxB,eAAO,MAAM,SAAS;;;;;;;;;;;;;;;;;;;;;;;;iDA4BpB,CAAC"}

package/dist/mastra/tools/execa.js

@@ -1,43 +0,0 @@
-import { createTool } from '@mastra/core';
-import chalk from 'chalk';
-import { execa, ExecaError } 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 {
-            console.log(chalk.green(`Running command: ${command} ${args.join(' ')}`));
-            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) {
-            if (e instanceof ExecaError) {
-                return { message: e.message };
-            }
-            return { message: 'Error' };
-        }
-    },
-});

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

@@ -1,33 +0,0 @@
-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>>>;
-//# sourceMappingURL=fs.d.ts.map

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

@@ -1 +0,0 @@
-{"version":3,"file":"fs.d.ts","sourceRoot":"","sources":["../../../src/mastra/tools/fs.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAExB,eAAO,MAAM,MAAM;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iDA+BjB,CAAC"}

package/dist/mastra/tools/fs.js

@@ -1,36 +0,0 @@
-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/image.d.ts

@@ -1,27 +0,0 @@
-import { z } from 'zod';
-export declare const imageTool: import("@mastra/core").Tool<"imageTool", z.ZodObject<{
-    directory: z.ZodString;
-    prompt: z.ZodString;
-}, "strip", z.ZodTypeAny, {
-    directory: string;
-    prompt: string;
-}, {
-    directory: string;
-    prompt: string;
-}>, z.ZodObject<{
-    message: z.ZodString;
-}, "strip", z.ZodTypeAny, {
-    message: string;
-}, {
-    message: string;
-}>, import("@mastra/core").ToolExecutionContext<z.ZodObject<{
-    directory: z.ZodString;
-    prompt: z.ZodString;
-}, "strip", z.ZodTypeAny, {
-    directory: string;
-    prompt: string;
-}, {
-    directory: string;
-    prompt: string;
-}>, import("@mastra/core").WorkflowContext<any>>>;
-//# sourceMappingURL=image.d.ts.map

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

@@ -1 +0,0 @@
-{"version":3,"file":"image.d.ts","sourceRoot":"","sources":["../../../src/mastra/tools/image.ts"],"names":[],"mappings":"AAIA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAIxB,eAAO,MAAM,SAAS;;;;;;;;;;;;;;;;;;;;;;;;iDAgCpB,CAAC"}

package/dist/mastra/tools/image.js

@@ -1,37 +0,0 @@
-import { createTool } from '@mastra/core';
-import chalk from 'chalk';
-import { writeFileSync } from 'fs';
-import { resolve } from 'path';
-import { z } from 'zod';
-import { stabilityai } from '../integrations/index.js';
-export const imageTool = createTool({
-    id: 'imageTool',
-    name: 'imageTool',
-    description: 'Generate an image based on a text prompt',
-    inputSchema: z.object({
-        directory: z.string(),
-        prompt: z.string(),
-    }),
-    outputSchema: z.object({
-        message: z.string(),
-    }),
-    execute: async ({ context: { directory, prompt } }) => {
-        try {
-            console.log('\n' + chalk.blue(`Generating image...`));
-            const generateImageResult = await stabilityai.generateImage(prompt);
-            const file = resolve(directory, generateImageResult.filename);
-            writeFileSync(file, generateImageResult.buffer);
-            console.log(chalk.blue(`Successfully generated: ${file}`));
-            return {
-                message: `Successfully created ${file}`,
-            };
-        }
-        catch (e) {
-            if (e instanceof Error) {
-                console.log(`\n${chalk.red(e.message)}`);
-                return { message: e.message };
-            }
-            return { message: 'Error' };
-        }
-    },
-});

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

@@ -1,3 +0,0 @@
-import { MastraMCPClient } from '@mastra/mcp';
-export declare const slack: MastraMCPClient;
-//# sourceMappingURL=mcp.d.ts.map

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

@@ -1 +0,0 @@
-{"version":3,"file":"mcp.d.ts","sourceRoot":"","sources":["../../../src/mastra/tools/mcp.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,eAAe,EAAE,MAAM,aAAa,CAAC;AAE9C,eAAO,MAAM,KAAK,iBAUhB,CAAC"}

package/dist/mastra/tools/mcp.js

@@ -1,12 +0,0 @@
-import { MastraMCPClient } from '@mastra/mcp';
-export const slack = new MastraMCPClient({
-    name: 'Slack',
-    server: {
-        command: '/usr/local/bin/docker',
-        args: ['run', '-i', '--rm', '-e', 'SLACK_BOT_TOKEN', '-e', 'SLACK_TEAM_ID', 'mcp/slack'],
-        env: {
-            SLACK_BOT_TOKEN: process.env.SLACK_BOT_TOKEN,
-            SLACK_TEAM_ID: process.env.SLACK_TEAM_ID,
-        },
-    },
-});

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

@@ -1,21 +0,0 @@
-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>>>;
-//# sourceMappingURL=pdf.d.ts.map

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

@@ -1 +0,0 @@
-{"version":3,"file":"pdf.d.ts","sourceRoot":"","sources":["../../../src/mastra/tools/pdf.ts"],"names":[],"mappings":"AAIA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAKxB,eAAO,MAAM,OAAO;;;;;;;;;;;;;;;;;;iDAsClB,CAAC"}

package/dist/mastra/tools/pdf.js

@@ -1,42 +0,0 @@
-import { createTool } from '@mastra/core';
-import chalk from 'chalk';
-import { existsSync, readFileSync } from 'fs';
-import path from 'path';
-import { z } from 'zod';
-// @ts-ignore
-import pdfParse from 'pdf-parse/lib/pdf-parse.js';
-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 pdfParse(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/tools/pnpm.d.ts

@@ -1,60 +0,0 @@
-import { z } from 'zod';
-export declare const pnpmBuild: import("@mastra/core").Tool<"pnpmBuild", z.ZodObject<{
-    name: z.ZodString;
-    packagePath: z.ZodString;
-}, "strip", z.ZodTypeAny, {
-    name: string;
-    packagePath: string;
-}, {
-    name: string;
-    packagePath: string;
-}>, z.ZodObject<{
-    message: z.ZodString;
-}, "strip", z.ZodTypeAny, {
-    message: string;
-}, {
-    message: string;
-}>, import("@mastra/core").ToolExecutionContext<z.ZodObject<{
-    name: z.ZodString;
-    packagePath: z.ZodString;
-}, "strip", z.ZodTypeAny, {
-    name: string;
-    packagePath: string;
-}, {
-    name: string;
-    packagePath: string;
-}>, import("@mastra/core").WorkflowContext<any>>>;
-export declare const pnpmChangesetStatus: import("@mastra/core").Tool<"pnpmChangesetStatus", z.ZodObject<{}, "strip", z.ZodTypeAny, {}, {}>, z.ZodObject<{
-    message: z.ZodArray<z.ZodString, "many">;
-}, "strip", z.ZodTypeAny, {
-    message: string[];
-}, {
-    message: string[];
-}>, import("@mastra/core").ToolExecutionContext<z.ZodObject<{}, "strip", z.ZodTypeAny, {}, {}>, import("@mastra/core").WorkflowContext<any>>>;
-export declare const pnpmChangesetPublish: import("@mastra/core").Tool<"pnpmChangesetPublish", z.ZodObject<{}, "strip", z.ZodTypeAny, {}, {}>, z.ZodObject<{
-    message: z.ZodString;
-}, "strip", z.ZodTypeAny, {
-    message: string;
-}, {
-    message: string;
-}>, import("@mastra/core").ToolExecutionContext<z.ZodObject<{}, "strip", z.ZodTypeAny, {}, {}>, import("@mastra/core").WorkflowContext<any>>>;
-export declare const activeDistTag: import("@mastra/core").Tool<"activeDistTag", z.ZodObject<{
-    packagePath: z.ZodString;
-}, "strip", z.ZodTypeAny, {
-    packagePath: string;
-}, {
-    packagePath: string;
-}>, z.ZodObject<{
-    message: z.ZodString;
-}, "strip", z.ZodTypeAny, {
-    message: string;
-}, {
-    message: string;
-}>, import("@mastra/core").ToolExecutionContext<z.ZodObject<{
-    packagePath: z.ZodString;
-}, "strip", z.ZodTypeAny, {
-    packagePath: string;
-}, {
-    packagePath: string;
-}>, import("@mastra/core").WorkflowContext<any>>>;
-//# sourceMappingURL=pnpm.d.ts.map

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

@@ -1 +0,0 @@
-{"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"}