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

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/image.d.ts

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

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

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

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

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

@@ -0,0 +1,42 @@
+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/workflows/chat.d.ts

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

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

@@ -0,0 +1 @@
+{"version":3,"file":"chat.d.ts","sourceRoot":"","sources":["../../../src/mastra/workflows/chat.ts"],"names":[],"mappings":"AACA,OAAO,EAAQ,QAAQ,EAAE,MAAM,cAAc,CAAC;AAE9C,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAIxB,eAAO,MAAM,eAAe;;;;;;;;;GAM1B,CAAC"}

package/dist/mastra/workflows/chat.js

@@ -0,0 +1,89 @@
+import { input } from '@inquirer/prompts';
+import { Step, Workflow } from '@mastra/core';
+import chalk from 'chalk';
+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 input({
+            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/commit-message.d.ts

@@ -0,0 +1,10 @@
+import { Workflow } from '@mastra/core';
+import { z } from 'zod';
+export declare const commitMessageGenerator: Workflow<any, z.ZodObject<{
+    repoPath: z.ZodString;
+}, "strip", z.ZodTypeAny, {
+    repoPath: string;
+}, {
+    repoPath: string;
+}>>;
+//# sourceMappingURL=commit-message.d.ts.map

package/dist/mastra/workflows/commit-message.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"commit-message.d.ts","sourceRoot":"","sources":["../../../src/mastra/workflows/commit-message.ts"],"names":[],"mappings":"AACA,OAAO,EAAQ,QAAQ,EAAE,MAAM,cAAc,CAAC;AAG9C,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAIxB,eAAO,MAAM,sBAAsB;;;;;;GAKjC,CAAC"}

package/dist/mastra/workflows/commit-message.js

@@ -0,0 +1,137 @@
+import { confirm } from '@inquirer/prompts';
+import { Step, Workflow } from '@mastra/core';
+import chalk from 'chalk';
+import { execSync } from 'child_process';
+import { z } from 'zod';
+import { fsTool } from '../tools/fs.js';
+export const commitMessageGenerator = new Workflow({
+    name: 'commit-message',
+    triggerSchema: z.object({
+        repoPath: z.string(),
+    }),
+});
+const getDiff = new Step({
+    id: 'getDiff',
+    outputSchema: z.object({
+        diff: z.string(),
+    }),
+    execute: async ({ context }) => {
+        const repoPath = context?.machineContext?.triggerData?.repoPath;
+        // Get the git diff of staged changes
+        const diff = execSync('git diff --staged', {
+            cwd: repoPath,
+            encoding: 'utf-8',
+        });
+        return { diff };
+    },
+});
+const readConventionalCommitSpec = new Step({
+    id: 'readConventionalCommitSpec',
+    outputSchema: z.object({
+        fileData: z.any(),
+    }),
+    execute: async () => {
+        const fileData = await fsTool.execute({
+            context: { action: 'read', file: 'data/crawl/conventional-commit.json', data: '' },
+        });
+        return { fileData };
+    },
+});
+const generateMessage = new Step({
+    id: 'generateMessage',
+    outputSchema: z.object({
+        commitMessage: z.string(),
+        generated: z.boolean(),
+        guidelines: z.array(z.string()),
+    }),
+    execute: async ({ context, mastra }) => {
+        const diffStep = context?.machineContext?.stepResults?.getDiff;
+        const fileDataStep = context?.machineContext?.stepResults?.readConventionalCommitSpec;
+        if (!diffStep || diffStep.status !== 'success') {
+            return { commitMessage: '', generated: false, guidelines: [] };
+        }
+        const daneCommitGenerator = mastra?.agents?.daneCommitMessage;
+        const res = await daneCommitGenerator?.generate(`
+        Given this git diff:
+        ${diffStep.payload.diff}
+
+        IF THE DIFF IS EMPTY, RETURN "No staged changes found", AND SET GENERATED TO FALSE,
+        OTHERWISE, SET GENERATED TO TRUE
+
+        ${fileDataStep?.status === 'success' && fileDataStep?.payload?.fileData?.message
+            ? `USE THE FOLLOWING GUIDELINES: ${fileDataStep?.payload?.fileData?.message}`
+            : `USE THE FOLLOWING GUIDELINES:
+        - Start with a verb in the present tense
+        - Be specific but concise
+        - Focus on the "what" and "why" of the changes
+        IF THERE ARE MULTIPLE LOGICAL CHANGES, USE THE DESCRIPTION TO EXPLAIN THE CHANGES IN BULLET POINTS.
+
+        - Keep the first line under 50 characters
+        - If needed, add more detailed description after a blank line`}
+
+        RETURN THE GUIDELINES YOU ARE USING AS AN ARRAY OF STRINGS ON THE GUIDELINES KEY, AND THE COMMIT MESSAGE ON THE COMMIT MESSAGE KEY
+      `, {
+            schema: z.object({
+                commitMessage: z.string(),
+                generated: z.boolean(),
+                guidelines: z.array(z.string()),
+            }),
+        });
+        if (!res?.object?.generated) {
+            throw new Error(res?.object?.commitMessage);
+        }
+        return {
+            commitMessage: res?.object?.commitMessage,
+            generated: res?.object?.generated,
+            guidelines: res?.object?.guidelines,
+        };
+    },
+});
+const confirmationStep = new Step({
+    id: 'confirmation',
+    outputSchema: z.object({
+        confirm: z.boolean(),
+    }),
+    execute: async ({ context }) => {
+        const parentStep = context?.machineContext?.stepResults?.generateMessage;
+        if (!parentStep || parentStep.status !== 'success') {
+            return { confirm: false };
+        }
+        if (!parentStep.payload.generated) {
+            return { confirm: false };
+        }
+        const commitMessage = parentStep.payload.commitMessage;
+        const confirmationMessage = await confirm({
+            message: `\n Would you like to use this commit message? \n\n ${chalk.yellow(commitMessage)}\n\n`,
+        });
+        return { confirm: confirmationMessage };
+    },
+});
+const commitStep = new Step({
+    id: 'commit',
+    outputSchema: z.object({
+        commit: z.boolean(),
+    }),
+    execute: async ({ context }) => {
+        const parentStep = context?.machineContext?.stepResults?.confirmation;
+        if (!parentStep || parentStep.status !== 'success' || !parentStep.payload.confirm) {
+            throw new Error('Commit message generation cancelled');
+        }
+        if (context?.machineContext?.stepResults?.generateMessage?.status !== 'success') {
+            throw new Error('Failed to generate commit message');
+        }
+        const commitMessage = context?.machineContext?.stepResults?.generateMessage?.payload?.commitMessage;
+        execSync(`git commit -m "${commitMessage}"`, {
+            cwd: context?.machineContext?.triggerData?.repoPath,
+            encoding: 'utf-8',
+        });
+        return { commit: true };
+    },
+});
+commitMessageGenerator
+    .step(getDiff)
+    .then(readConventionalCommitSpec)
+    .then(generateMessage)
+    .then(confirmationStep)
+    .then(commitStep)
+    .commit();

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

@@ -0,0 +1,4 @@
+export * from './chat.js';
+export * from './issue-labeler.js';
+export * from './commit-message.js';
+//# sourceMappingURL=index.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/mastra/workflows/index.ts"],"names":[],"mappings":"AAAA,cAAc,WAAW,CAAC;AAC1B,cAAc,oBAAoB,CAAC;AACnC,cAAc,qBAAqB,CAAC"}

package/{src/mastra/workflows/index.ts → dist/mastra/workflows/index.js}

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

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

@@ -0,0 +1,16 @@
+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;
+}>>;
+//# sourceMappingURL=issue-labeler.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"issue-labeler.d.ts","sourceRoot":"","sources":["../../../src/mastra/workflows/issue-labeler.ts"],"names":[],"mappings":"AAAA,OAAO,EAAQ,QAAQ,EAAE,MAAM,cAAc,CAAC;AAC9C,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAIxB,eAAO,MAAM,kBAAkB;;;;;;;;;;;;GAO7B,CAAC"}

package/dist/mastra/workflows/issue-labeler.js

@@ -0,0 +1,85 @@
+import { Step, Workflow } from '@mastra/core';
+import { z } from 'zod';
+import { github } from '../integrations/index.js';
+export const githubIssueLabeler = new Workflow({
+    name: 'github-issue-labeler',
+    triggerSchema: z.object({
+        repo: z.string(),
+        owner: z.string(),
+        issue_number: z.number(),
+    }),
+});
+const getIssue = new Step({
+    id: 'getIssue',
+    outputSchema: z.object({
+        title: z.string(),
+        body: z.string(),
+        labelNames: z.array(z.string()),
+    }),
+    execute: async ({ context }) => {
+        const client = await github.getApiClient();
+        const issue = await client.issuesGet({
+            path: {
+                // TODO: Type triggerData in machineContext to the triggerSchema
+                owner: context?.machineContext?.triggerData?.owner,
+                repo: context?.machineContext?.triggerData?.repo,
+                issue_number: context?.machineContext?.triggerData?.issue_number,
+            },
+        });
+        const labels = await client.issuesListLabelsForRepo({
+            path: {
+                owner: context?.machineContext?.triggerData?.owner,
+                repo: context?.machineContext?.triggerData?.repo,
+            },
+        });
+        const labelNames = labels?.data?.map(label => label.name);
+        return { title: issue?.data?.title, body: issue?.data?.body, labelNames: labelNames };
+    },
+});
+const labelIssue = new Step({
+    id: 'labelIssue',
+    outputSchema: z.object({
+        labels: z.array(z.string()),
+    }),
+    execute: async ({ context, mastra }) => {
+        const parentStep = context?.machineContext?.stepResults?.getIssue;
+        if (!parentStep || parentStep.status !== 'success') {
+            return { labels: [] };
+        }
+        const daneIssueLabeler = mastra?.agents?.daneIssueLabeler;
+        const res = await daneIssueLabeler?.generate(`
+            Hey Dane, given:
+            * this issue title: ${parentStep?.payload?.title}
+            * this issue body: ${parentStep?.payload?.body}
+            * these labels: ${parentStep?.payload?.labelNames}
+
+            What label or labels would you assign?
+        `, {
+            schema: z.object({
+                labels: z.array(z.string()),
+            }),
+        });
+        return { labels: res?.object?.labels };
+    },
+});
+const applyLabels = new Step({
+    id: 'applyLabels',
+    execute: async ({ context }) => {
+        const parentStep = context?.machineContext?.stepResults?.labelIssue;
+        if (!parentStep || parentStep.status !== 'success') {
+            return;
+        }
+        const client = await github.getApiClient();
+        await client.issuesAddLabels({
+            path: {
+                owner: context?.machineContext?.triggerData?.owner,
+                repo: context?.machineContext?.triggerData?.repo,
+                issue_number: context?.machineContext?.triggerData?.issue_number,
+            },
+            body: {
+                labels: parentStep.payload.labels,
+            },
+        });
+    },
+});
+githubIssueLabeler.step(getIssue).then(labelIssue).then(applyLabels).commit();

package/package.json

@@ -1,8 +1,14 @@
 {
   "name": "@mastra/dane",
-  "version": "0.0.2-alpha.2",
+  "version": "0.0.2-alpha.21",
   "main": "dist/index.js",
   "type": "module",
+  "files": [
+    "dist",
+    "data",
+    "test",
+    "test-files"
+  ],
   "bin": {
     "dane": "./dist/index.js"
   },
@@ -16,12 +22,13 @@
     "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",
     "execa": "^9.3.1",
-    "inquirer": "^12.2.0",
     "luxon": "^3.5.0",
     "node-ical": "^0.20.1",
     "node-screenshots": "^0.2.1",
@@ -31,17 +38,18 @@
     "sqlite3": "^5.1.7",
     "typescript": "^5.5.4",
     "zod": "^3.24.0",
-    "@mastra/engine": "0.0.5-alpha.32",
-    "@mastra/core": "0.1.27-alpha.38",
-    "@mastra/github": "1.0.3-alpha.21",
-    "@mastra/memory": "0.0.2-alpha.17",
-    "@mastra/firecrawl": "1.0.4-alpha.22",
-    "@mastra/rag": "0.0.2-alpha.22"
+    "@mastra/core": "0.1.27-alpha.46",
+    "@mastra/engine": "0.0.5-alpha.40",
+    "@mastra/firecrawl": "1.0.4-alpha.32",
+    "@mastra/github": "1.0.3-alpha.30",
+    "@mastra/memory": "0.0.2-alpha.26",
+    "@mastra/rag": "0.0.2-alpha.30",
+    "@mastra/stabilityai": "1.0.1-alpha.21"
   },
   "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"
+    "test": "echo \"Error: no test specified\" && exit 1",
+    "prepublish": "pnpm build"
   }
 }

package/CHANGELOG.md

@@ -1,37 +0,0 @@
-# @mastra/dane
-
-## 0.0.2-alpha.2
-
-### Patch Changes
-
-- ad58c35: Adds a shebang to the dane entry file
-
-## 0.0.2-alpha.1
-
-### Patch Changes
-
-- Updated dependencies [f031a1f]
-  - @mastra/core@0.1.27-alpha.38
-  - @mastra/rag@0.0.2-alpha.22
-  - @mastra/firecrawl@1.0.4-alpha.22
-  - @mastra/github@1.0.3-alpha.21
-  - @mastra/engine@0.0.5-alpha.32
-  - @mastra/memory@0.0.2-alpha.17
-
-## 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