@mastra/dane 0.0.2-alpha.22 → 0.0.2-alpha.23

package/dist/commands/commit-message.d.ts

@@ -0,0 +1,2 @@
+export declare function commitMessageCommand(): Promise<void>;
+//# sourceMappingURL=commit-message.d.ts.map

package/dist/commands/commit-message.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"commit-message.d.ts","sourceRoot":"","sources":["../../src/commands/commit-message.ts"],"names":[],"mappings":"AAKA,wBAAsB,oBAAoB,kBAgCzC"}

package/dist/commands/commit-message.js

@@ -0,0 +1,31 @@
+import chalk from 'chalk';
+import { execSync } from 'child_process';
+import { mastra } from '../mastra/index.js';
+export async function commitMessageCommand() {
+    console.log(chalk.green("Hi! I'm Dane!"));
+    console.log(chalk.green('Let me generate a commit message for you..\n'));
+    try {
+        const workflow = mastra.getWorkflow('commitMessage');
+        if (!workflow) {
+            console.error(chalk.red('Commit message workflow not found. Make sure it is properly set up.'));
+            process.exit(1);
+        }
+        // Get the current path
+        const currentPath = execSync('pwd', { encoding: 'utf-8' }).trim();
+        const result = await workflow.execute({
+            triggerData: {
+                repoPath: currentPath,
+            },
+        });
+        const errorMessage = Object.values(result.results).find(result => result.status === 'failed')?.error;
+        if (result.results?.commit?.status !== 'success') {
+            console.error(chalk.red(`\n${errorMessage}`));
+            return;
+        }
+        console.log(chalk.green('\nCommit message generated and committed successfully'));
+    }
+    catch (error) {
+        console.error(chalk.red('Error:', error?.message || 'An unknown error occurred'));
+        process.exit(1);
+    }
+}

package/dist/commands/config.d.ts

@@ -0,0 +1,3 @@
+import { Command } from 'commander';
+export declare const configCommand: Command;
+//# sourceMappingURL=config.d.ts.map

package/dist/commands/config.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"config.d.ts","sourceRoot":"","sources":["../../src/commands/config.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,OAAO,EAAE,MAAM,WAAW,CAAC;AAIpC,eAAO,MAAM,aAAa,SAiCtB,CAAC"}

package/dist/commands/config.js

@@ -0,0 +1,40 @@
+import { Command } from 'commander';
+import { ConfigManager } from '../config/index.js';
+export const configCommand = new Command('config')
+    .description('Manage Dane configuration')
+    .option('--set <key=value>', 'Set a configuration value')
+    .option('--get <key>', 'Get a configuration value')
+    .option('--list', 'List all configuration values')
+    .option('--del <key>', 'Delete a configuration value')
+    .action(options => {
+    const configManager = new ConfigManager();
+    if (options.set) {
+        const [key, value] = options.set.split('=');
+        if (!key || !value) {
+            console.error('Invalid format. Use --set KEY=VALUE');
+            process.exit(1);
+        }
+        configManager.set(key, value);
+        console.log(`Set ${key} successfully`);
+    }
+    else if (options.get) {
+        const value = configManager.get(options.get);
+        if (value === undefined) {
+            console.log(`No value set for ${options.get}`);
+        }
+        else {
+            console.log(value);
+        }
+    }
+    else if (options.del) {
+        configManager.delete(options.del);
+        console.log(`Deleted ${options.del} successfully`);
+    }
+    else if (options.list) {
+        const config = configManager.list();
+        console.log(JSON.stringify(config, null, 2));
+    }
+    else {
+        console.log('No action specified. Use --help to see available options.');
+    }
+});

package/dist/commands/issue-labeler.d.ts

@@ -0,0 +1,2 @@
+export declare function issueLabelerCommand(): Promise<void>;
+//# sourceMappingURL=issue-labeler.d.ts.map

package/dist/commands/issue-labeler.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"issue-labeler.d.ts","sourceRoot":"","sources":["../../src/commands/issue-labeler.ts"],"names":[],"mappings":"AAIA,wBAAsB,mBAAmB,kBA2BxC"}

package/dist/commands/issue-labeler.js

@@ -0,0 +1,34 @@
+import chalk from 'chalk';
+import { mastra } from '../mastra/index.js';
+export async function issueLabelerCommand() {
+    console.log(chalk.green("Hi! I'm Dane!"));
+    console.log(chalk.green('Let me label this for you..\n'));
+    const result = await mastra.getWorkflow('githubIssueLabeler').execute({
+        triggerData: {
+            issue_number: parseInt(process.env.ISSUE_NUMBER, 10),
+            owner: process.env.OWNER,
+            repo: normalizeRepo(process.env.REPO),
+        },
+    });
+    if (result.results?.labelIssue?.status === 'failed') {
+        console.error(chalk.red(`Error applying labels for issue: ${result.triggerData?.issue_number}`));
+        console.error({ error: result.results?.labelIssue?.error });
+        return;
+    }
+    if (result.results?.labelIssue?.status !== 'success') {
+        console.error(chalk.red(`Failed to apply labels for issue: ${result.triggerData?.issue_number}`));
+        return;
+    }
+    console.log(chalk.green(`Issue: ${result.triggerData?.issue_number} has been labeled with: ${result.results?.labelIssue?.payload?.labels.join(', ')}`));
+}
+/**
+ * Extracts the repo name from owner/repo format provided by github
+ * @param repo - The repo name to normalize
+ * @returns The normalized repo name
+ */
+function normalizeRepo(repo) {
+    if (repo.includes('/')) {
+        return repo.split('/')[1] || repo;
+    }
+    return repo;
+}

package/dist/commands/message.d.ts

@@ -0,0 +1,2 @@
+export declare function message(): Promise<void>;
+//# sourceMappingURL=message.d.ts.map

package/dist/commands/message.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"message.d.ts","sourceRoot":"","sources":["../../src/commands/message.ts"],"names":[],"mappings":"AAIA,wBAAsB,OAAO,kBAW5B"}

package/dist/commands/message.js

@@ -0,0 +1,12 @@
+import chalk from 'chalk';
+import { mastra } from '../mastra/index.js';
+export async function message() {
+    console.log(chalk.green("Hi! I'm Dane!"));
+    console.log(chalk.green('What would you like to do today?\n'));
+    console.log(await mastra.getWorkflow('message').execute({
+        triggerData: {
+            resourceid: 'f8b5c3a1-d6e7-4f9c-b2a3-1d8e4c7f9b5a',
+            threadId: '2d9e8c7f-6b5a-4d3c-8f1e-9b7d5c3a2e8h',
+        },
+    }));
+}

package/dist/commands/publish-packages.d.ts

@@ -0,0 +1,2 @@
+export declare function publishPackages(): Promise<void>;
+//# sourceMappingURL=publish-packages.d.ts.map

package/dist/commands/publish-packages.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"publish-packages.d.ts","sourceRoot":"","sources":["../../src/commands/publish-packages.ts"],"names":[],"mappings":"AAOA,wBAAsB,eAAe,kBAuFpC"}

package/dist/commands/publish-packages.js

@@ -0,0 +1,73 @@
+import chalk from 'chalk';
+import { readFileSync } from 'fs';
+import path from 'path';
+import { z } from 'zod';
+import { mastra } from '../mastra/index.js';
+export async function publishPackages() {
+    console.log(chalk.green("Hi! I'm Dane!"));
+    console.log(chalk.green('Let me publish your packages..\n'));
+    const agent = mastra.getAgent('danePackagePublisher');
+    const result = await agent.generate(`
+        Can you tell me which packages within the packages and integrations directory need to be published to npm?
+        `);
+    const resultObj = await agent.generate(`
+        ONLY RETURN DATA IF WE HAVE PACKAGES TO PUBLISH. If we do not, return empty arrays.
+        Can you format this for me ${result.text}? 
+        @mastra/core must be first. @mastra/dane should be listed after packages and integrations.
+        `, {
+        schema: z.object({
+            packages: z.array(z.string()),
+            integrations: z.array(z.string()),
+            danePackage: z.string(),
+        }),
+    });
+    console.log(resultObj.object);
+    const packagesToBuild = new Set();
+    if (resultObj?.object?.packages) {
+        const packages = resultObj.object.packages;
+        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 (resultObj?.object?.integrations) {
+        const integrations = resultObj.object.integrations;
+        integrations.forEach((integration) => {
+            let pkgName = integration.replace('@mastra/', '');
+            const integrationPath = path.join(process.cwd(), 'integrations', pkgName);
+            packagesToBuild.add(integrationPath);
+        });
+    }
+    if (resultObj?.object?.danePackage) {
+        const danePackage = resultObj.object.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);
+            packagesToBuild.add(pkgPath);
+        });
+        packagesToBuild.add(danePackage);
+    }
+    const pkgSet = Array.from(packagesToBuild.keys());
+    if (!packagesToBuild.size) {
+        console.error(chalk.red('No packages to build.'));
+        process.exit(1);
+    }
+    let res = await agent.generate(`
+        Here are the packages that need to be built: ${pkgSet.join(',')}.
+        We need to build core first. And dane last. The rest can be done in parallel.
+    `);
+    console.log(chalk.green(res.text));
+    res = await agent.generate(`
+        Publish the changeset and then set the dist-tag of latest to the new version.
+    `);
+    console.log(chalk.green(result.text));
+}

package/dist/config/index.d.ts

@@ -0,0 +1,12 @@
+export declare class ConfigManager {
+    private configPath;
+    constructor();
+    private ensureConfigExists;
+    get(key: string): string | undefined;
+    set(key: string, value: string): void;
+    delete(key: string): void;
+    list(): Record<string, string>;
+    getAnthropicApiKey(): string;
+}
+export declare const config: ConfigManager;
+//# sourceMappingURL=index.d.ts.map

package/dist/config/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/config/index.ts"],"names":[],"mappings":"AAIA,qBAAa,aAAa;IACxB,OAAO,CAAC,UAAU,CAAS;;IAS3B,OAAO,CAAC,kBAAkB;IAUnB,GAAG,CAAC,GAAG,EAAE,MAAM,GAAG,MAAM,GAAG,SAAS;IASpC,GAAG,CAAC,GAAG,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM,GAAG,IAAI;IAUrC,MAAM,CAAC,GAAG,EAAE,MAAM,GAAG,IAAI;IAYzB,IAAI,IAAI,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC;IAQ9B,kBAAkB,IAAI,MAAM;CAiBpC;AAGD,eAAO,MAAM,MAAM,eAAsB,CAAC"}

package/dist/config/index.js

@@ -0,0 +1,75 @@
+import * as fs from 'fs';
+import * as os from 'os';
+import * as path from 'path';
+export class ConfigManager {
+    constructor() {
+        const homeDir = os.homedir();
+        const configDir = path.join(homeDir, '.dane');
+        this.configPath = path.join(configDir, 'config.json');
+        this.ensureConfigExists();
+    }
+    ensureConfigExists() {
+        const configDir = path.dirname(this.configPath);
+        if (!fs.existsSync(configDir)) {
+            fs.mkdirSync(configDir, { recursive: true });
+        }
+        if (!fs.existsSync(this.configPath)) {
+            fs.writeFileSync(this.configPath, JSON.stringify({}, null, 2));
+        }
+    }
+    get(key) {
+        try {
+            const config = JSON.parse(fs.readFileSync(this.configPath, 'utf-8'));
+            return config[key];
+        }
+        catch (error) {
+            return undefined;
+        }
+    }
+    set(key, value) {
+        try {
+            const config = fs.existsSync(this.configPath) ? JSON.parse(fs.readFileSync(this.configPath, 'utf-8')) : {};
+            config[key] = value;
+            fs.writeFileSync(this.configPath, JSON.stringify(config, null, 2));
+        }
+        catch (error) {
+            throw new Error(`Failed to set config value: ${error}`);
+        }
+    }
+    delete(key) {
+        try {
+            const config = fs.existsSync(this.configPath) ? JSON.parse(fs.readFileSync(this.configPath, 'utf-8')) : {};
+            if (key in config) {
+                delete config[key];
+                fs.writeFileSync(this.configPath, JSON.stringify(config, null, 2));
+            }
+        }
+        catch (error) {
+            throw new Error(`Failed to delete config value: ${error}`);
+        }
+    }
+    list() {
+        try {
+            return JSON.parse(fs.readFileSync(this.configPath, 'utf-8'));
+        }
+        catch (error) {
+            return {};
+        }
+    }
+    getAnthropicApiKey() {
+        const key = this.get('ANTHROPIC_API_KEY') || process.env.ANTHROPIC_API_KEY;
+        if (!key) {
+            // Check if we're in a command that requires the API key
+            const command = process.argv[2] || '';
+            const configCommands = ['config', '--help', '-h'];
+            // Only throw if we're not in a config-related command
+            if (!configCommands.includes(command)) {
+                throw new Error('ANTHROPIC_API_KEY not found in config. Please set it using: dane config --set ANTHROPIC_API_KEY=your_key_here');
+            }
+            return '';
+        }
+        return key;
+    }
+}
+// Create a singleton instance for easy access
+export const config = new ConfigManager();

package/dist/index.d.ts

@@ -0,0 +1,3 @@
+#! /usr/bin/env node
+export {};
+//# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":""}

package/dist/index.js

@@ -0,0 +1,23 @@
+#! /usr/bin/env node
+import { Command } from 'commander';
+import dotenv from 'dotenv';
+import { commitMessageCommand } from './commands/commit-message.js';
+import { configCommand } from './commands/config.js';
+import { issueLabelerCommand } from './commands/issue-labeler.js';
+import { message } from './commands/message.js';
+import { publishPackages } from './commands/publish-packages.js';
+dotenv.config();
+process.env.NODE_NO_WARNINGS = '1';
+const program = new Command();
+program.command('chat').action(message);
+program
+    .command('issue-labeler')
+    .description('Automatically label GitHub issues based on their content and context')
+    .action(issueLabelerCommand);
+program
+    .command('commit')
+    .description('Create a sensible commit message based on the changes made')
+    .action(commitMessageCommand);
+program.addCommand(configCommand);
+program.command('publish').description('Publish packages to the registry').action(publishPackages);
+program.parse(process.argv);

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

@@ -0,0 +1,263 @@
+import { Agent } from '@mastra/core';
+export declare const daneCommitMessage: Agent<Record<string, import("@mastra/core").ToolAction<any, any, any, any>>>;
+export declare const daneIssueLabeler: Agent<Record<string, import("@mastra/core").ToolAction<any, any, any, any>>>;
+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>>>;
+}>;
+export declare const dane: Agent<{
+    fsTool: import("@mastra/core").Tool<"fsTool", import("zod").ZodObject<{
+        action: import("zod").ZodString;
+        file: import("zod").ZodString;
+        data: import("zod").ZodString;
+    }, "strip", import("zod").ZodTypeAny, {
+        data: string;
+        action: string;
+        file: string;
+    }, {
+        data: string;
+        action: string;
+        file: string;
+    }>, import("zod").ZodObject<{
+        message: import("zod").ZodString;
+    }, "strip", import("zod").ZodTypeAny, {
+        message: string;
+    }, {
+        message: string;
+    }>, import("@mastra/core").ToolExecutionContext<import("zod").ZodObject<{
+        action: import("zod").ZodString;
+        file: import("zod").ZodString;
+        data: import("zod").ZodString;
+    }, "strip", import("zod").ZodTypeAny, {
+        data: string;
+        action: string;
+        file: string;
+    }, {
+        data: string;
+        action: string;
+        file: string;
+    }>, import("@mastra/core").WorkflowContext<any>>>;
+    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>>>;
+    browserTool: import("@mastra/core").Tool<"browserTool", import("zod").ZodObject<{
+        url: import("zod").ZodString;
+    }, "strip", import("zod").ZodTypeAny, {
+        url: string;
+    }, {
+        url: string;
+    }>, import("zod").ZodObject<{
+        message: import("zod").ZodString;
+    }, "strip", import("zod").ZodTypeAny, {
+        message: string;
+    }, {
+        message: string;
+    }>, import("@mastra/core").ToolExecutionContext<import("zod").ZodObject<{
+        url: import("zod").ZodString;
+    }, "strip", import("zod").ZodTypeAny, {
+        url: string;
+    }, {
+        url: string;
+    }>, import("@mastra/core").WorkflowContext<any>>>;
+    googleSearch: import("@mastra/core").Tool<"googleSearch", import("zod").ZodObject<{
+        query: import("zod").ZodString;
+    }, "strip", import("zod").ZodTypeAny, {
+        query: string;
+    }, {
+        query: string;
+    }>, import("zod").ZodObject<{
+        message: import("zod").ZodString;
+    }, "strip", import("zod").ZodTypeAny, {
+        message: string;
+    }, {
+        message: string;
+    }>, import("@mastra/core").ToolExecutionContext<import("zod").ZodObject<{
+        query: import("zod").ZodString;
+    }, "strip", import("zod").ZodTypeAny, {
+        query: string;
+    }, {
+        query: string;
+    }>, import("@mastra/core").WorkflowContext<any>>>;
+    readPDF: import("@mastra/core").Tool<"readPDF", import("zod").ZodObject<{
+        pdfPath: import("zod").ZodString;
+    }, "strip", import("zod").ZodTypeAny, {
+        pdfPath: string;
+    }, {
+        pdfPath: string;
+    }>, import("zod").ZodObject<{
+        content: import("zod").ZodString;
+    }, "strip", import("zod").ZodTypeAny, {
+        content: string;
+    }, {
+        content: string;
+    }>, import("@mastra/core").ToolExecutionContext<import("zod").ZodObject<{
+        pdfPath: import("zod").ZodString;
+    }, "strip", import("zod").ZodTypeAny, {
+        pdfPath: string;
+    }, {
+        pdfPath: string;
+    }>, import("@mastra/core").WorkflowContext<any>>>;
+    listEvents: import("@mastra/core").Tool<"listEvents", import("zod").ZodObject<{
+        startDate: import("zod").ZodString;
+    }, "strip", import("zod").ZodTypeAny, {
+        startDate: string;
+    }, {
+        startDate: string;
+    }>, import("zod").ZodObject<{
+        content: import("zod").ZodString;
+    }, "strip", import("zod").ZodTypeAny, {
+        content: string;
+    }, {
+        content: string;
+    }>, import("@mastra/core").ToolExecutionContext<import("zod").ZodObject<{
+        startDate: import("zod").ZodString;
+    }, "strip", import("zod").ZodTypeAny, {
+        startDate: string;
+    }, {
+        startDate: string;
+    }>, import("@mastra/core").WorkflowContext<any>>>;
+    crawl: import("@mastra/core").Tool<"crawler", import("zod").ZodObject<{
+        url: import("zod").ZodString;
+        limit: import("zod").ZodDefault<import("zod").ZodNumber>;
+        pathRegex: import("zod").ZodNullable<import("zod").ZodString>;
+    }, "strip", import("zod").ZodTypeAny, {
+        url: string;
+        limit: number;
+        pathRegex: string | null;
+    }, {
+        url: string;
+        pathRegex: string | null;
+        limit?: number | undefined;
+    }>, import("zod").ZodObject<{
+        message: import("zod").ZodString;
+        crawlData: import("zod").ZodAny;
+    }, "strip", import("zod").ZodTypeAny, {
+        message: string;
+        crawlData?: any;
+    }, {
+        message: string;
+        crawlData?: any;
+    }>, import("@mastra/core").ToolExecutionContext<import("zod").ZodObject<{
+        url: import("zod").ZodString;
+        limit: import("zod").ZodDefault<import("zod").ZodNumber>;
+        pathRegex: import("zod").ZodNullable<import("zod").ZodString>;
+    }, "strip", import("zod").ZodTypeAny, {
+        url: string;
+        limit: number;
+        pathRegex: string | null;
+    }, {
+        url: string;
+        pathRegex: string | null;
+        limit?: number | undefined;
+    }>, import("@mastra/core").WorkflowContext<any>>>;
+    imageTool: import("@mastra/core").Tool<"imageTool", import("zod").ZodObject<{
+        directory: import("zod").ZodString;
+        prompt: import("zod").ZodString;
+    }, "strip", import("zod").ZodTypeAny, {
+        directory: string;
+        prompt: string;
+    }, {
+        directory: string;
+        prompt: string;
+    }>, import("zod").ZodObject<{
+        message: import("zod").ZodString;
+    }, "strip", import("zod").ZodTypeAny, {
+        message: string;
+    }, {
+        message: string;
+    }>, import("@mastra/core").ToolExecutionContext<import("zod").ZodObject<{
+        directory: import("zod").ZodString;
+        prompt: import("zod").ZodString;
+    }, "strip", import("zod").ZodTypeAny, {
+        directory: string;
+        prompt: string;
+    }, {
+        directory: string;
+        prompt: string;
+    }>, import("@mastra/core").WorkflowContext<any>>>;
+}>;
+//# sourceMappingURL=index.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/mastra/agents/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,KAAK,EAAE,MAAM,cAAc,CAAC;AAkBrC,eAAO,MAAM,iBAAiB,8EAU5B,CAAC;AAEH,eAAO,MAAM,gBAAgB,8EAO3B,CAAC;AAEH,eAAO,MAAM,oBAAoB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAa/B,CAAC;AAEH,eAAO,MAAM,IAAI;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAuDf,CAAC"}