mastra 0.1.57-alpha.90 → 0.1.57-unstable.101

package/dist/shared/lib/object.d.ts

@@ -0,0 +1,50 @@
+/**
+ * Checks if object is empty
+ * @param objectName
+ * @returns boolean
+ */
+export declare const isObjectEmpty: (objectName: Object) => boolean;
+/**
+ * Get a value from an object by a given path. This function emulates the behavior of lodash's _.get method.
+ *
+ * @param {Record<string, any>} object - The object from which to get the value.
+ * @param {string | string[]} path - The path to the value in the object. This can be a string (e.g., 'a.b.c') or an array of keys (e.g., ['a', 'b', 'c']).
+ * @returns {unknown} The value at the given path in the object, or undefined if the path does not exist.
+ */
+export declare const getPath: (object: Record<string, any>, path: string | string[]) => unknown;
+export declare function recordHasData(record: Record<any, any>): boolean;
+export declare function isLiteralObject(a: unknown): boolean;
+export declare const constructObjFromStringPath: (path: string, value: any) => Record<string, any>;
+/**
+ * Flatten a nested object, flatten from flat package works - https://www.npmjs.com/package/flat
+ * but this allows you to define where you want it to stop by passing the keys that'll exist in the object you want it to stop at
+ *
+ * @param {Record<string, any>} object - The object to flatten.
+ * @param {string[]} endKeys - The keys you want each value (which will be an object in this case) in the flattened object to possible have (e.g., ['a', 'b', 'c']).
+ * @param {boolean} flattenArrayValue - This flag indicates that any array value should be flattened to object too.
+ * @returns {Record<string, any>} Your flattened object
+ */
+export declare const flattenObject: (object: Record<string, any>, endKeys?: string[], flattenArrayValue?: boolean) => Record<string, unknown>;
+type AnyObject = {
+    [key: string]: any;
+};
+/**
+ * Merges two objects, ensuring that only defined properties from the second object
+ * override those in the first object.
+ *
+ * @template T - The type of the base object.
+ * @template U - The type of the overrides object.
+ * @param {T} base - The base object whose properties will be overridden.
+ * @param {U} overrides - The object containing properties to override in the base object.
+ *                        Only properties that are defined (not `undefined`) will override.
+ * @returns {T & U} - A new object that combines properties from both `base` and `overrides`.
+ *                    Properties in `base` will be overridden by defined properties in `overrides`.
+ *
+ * @example
+ * const worksheetData = { a: 1, b: 2, c: 3 };
+ * const payload = { b: undefined, c: 4 };
+ * const extendedData = mergeWithDefinedOnly(worksheetData, payload);
+ * // extendedData = { a: 1, b: 2, c: 4 }
+ */
+export declare function mergeWithDefinedOnly<T extends AnyObject, U extends AnyObject>(base: T, overrides: U): T & U;
+export {};

package/dist/shared/lib/object.js

@@ -0,0 +1,105 @@
+/**
+ * Checks if object is empty
+ * @param objectName
+ * @returns boolean
+ */
+export const isObjectEmpty = (objectName) => {
+    return objectName && Object.keys(objectName).length === 0 && objectName.constructor === Object;
+};
+/**
+ * Get a value from an object by a given path. This function emulates the behavior of lodash's _.get method.
+ *
+ * @param {Record<string, any>} object - The object from which to get the value.
+ * @param {string | string[]} path - The path to the value in the object. This can be a string (e.g., 'a.b.c') or an array of keys (e.g., ['a', 'b', 'c']).
+ * @returns {unknown} The value at the given path in the object, or undefined if the path does not exist.
+ */
+export const getPath = (object, path) => {
+    if (typeof path === 'string') {
+        path = path?.split('.');
+    }
+    return path?.reduce((obj, key) => (obj && obj[key] !== undefined ? obj[key] : undefined), object);
+};
+export function recordHasData(record) {
+    return Object.keys(record).length > 0;
+}
+export function isLiteralObject(a) {
+    return !!a && a.constructor === Object;
+}
+export const constructObjFromStringPath = (path, value) => {
+    if (!path)
+        return {};
+    //key, split the key with ., and then for each item, we update object data.pipeline
+    // {data: {pipeline: 'kbdkjd'}}
+    const pathArr = path.split('.');
+    let newObject = {
+        [pathArr[pathArr.length - 1]]: value,
+    };
+    let index = pathArr.length - 2;
+    while (index >= 0) {
+        newObject = { [pathArr[index]]: newObject };
+        index = index - 1;
+    }
+    return newObject;
+};
+/**
+ * Flatten a nested object, flatten from flat package works - https://www.npmjs.com/package/flat
+ * but this allows you to define where you want it to stop by passing the keys that'll exist in the object you want it to stop at
+ *
+ * @param {Record<string, any>} object - The object to flatten.
+ * @param {string[]} endKeys - The keys you want each value (which will be an object in this case) in the flattened object to possible have (e.g., ['a', 'b', 'c']).
+ * @param {boolean} flattenArrayValue - This flag indicates that any array value should be flattened to object too.
+ * @returns {Record<string, any>} Your flattened object
+ */
+export const flattenObject = (object, endKeys = [], flattenArrayValue) => {
+    let newObj = {};
+    function recurseDip(obj, path) {
+        for (const [key, value] of Object.entries(obj)) {
+            let newPath = [...path, key];
+            if (value && value.constructor === Object) {
+                const hasOnlyEndKeys = endKeys?.length ? endKeys.every(v => Object.keys(value).includes(v)) : false;
+                if (hasOnlyEndKeys) {
+                    newObj = { ...newObj, [newPath.join('.')]: value };
+                }
+                else {
+                    recurseDip(value, newPath);
+                }
+            }
+            else if (flattenArrayValue && Array.isArray(value)) {
+                const contructValue = value.reduce((a, b) => ({ ...a, [value.indexOf(b)]: b }), {});
+                recurseDip(contructValue, newPath);
+            }
+            else {
+                newObj = { ...newObj, [newPath.join('.')]: value };
+            }
+        }
+    }
+    recurseDip(object, []);
+    return newObj;
+};
+/**
+ * Merges two objects, ensuring that only defined properties from the second object
+ * override those in the first object.
+ *
+ * @template T - The type of the base object.
+ * @template U - The type of the overrides object.
+ * @param {T} base - The base object whose properties will be overridden.
+ * @param {U} overrides - The object containing properties to override in the base object.
+ *                        Only properties that are defined (not `undefined`) will override.
+ * @returns {T & U} - A new object that combines properties from both `base` and `overrides`.
+ *                    Properties in `base` will be overridden by defined properties in `overrides`.
+ *
+ * @example
+ * const worksheetData = { a: 1, b: 2, c: 3 };
+ * const payload = { b: undefined, c: 4 };
+ * const extendedData = mergeWithDefinedOnly(worksheetData, payload);
+ * // extendedData = { a: 1, b: 2, c: 4 }
+ */
+export function mergeWithDefinedOnly(base, overrides) {
+    const result = { ...base };
+    for (const key in overrides) {
+        if (overrides[key] !== undefined) {
+            result[key] = overrides[key];
+        }
+    }
+    return result;
+}

package/dist/shared/lib/string.d.ts

@@ -0,0 +1,108 @@
+/**
+ * Truncate text
+ * @param str Text to truncate
+ * @param limit Limit of characters
+ * @returns
+ * @example
+ * truncateText('hello world', 5)
+ * // 'hello...'
+ * truncateText('hello world', 20)
+ * // 'hello world'
+ */
+export declare const truncateText: (str: string, limit?: number) => string;
+/**
+ * Removes all non-letter characters from the provided string, allowing only
+ * English alphabet characters (both uppercase and lowercase) to remain.
+ * This function utilizes a regular expression to filter out any characters
+ * that are not letters, such as numbers, punctuation marks, spaces, and symbols.
+ *
+ * @param input The string from which to remove non-letter characters.
+ * @returns The modified string containing only letters.
+ *
+ * @example
+ * keepOnlyLetters("Hello123 World!")
+ * // Returns: 'HelloWorld'
+ *
+ * @example
+ * keepOnlyLetters("2024 New Year!")
+ * // Returns: 'NewYear'
+ *
+ * @example
+ * keepOnlyLetters("Data @ 50% speed!")
+ * // Returns: 'Dataspeed'
+ */
+export declare const keepOnlyLetters: (input: string) => string;
+/**
+ * Remove HTML tags from text
+ * @param html HTML string
+ * @returns string
+ * @example
+ * removeHTMLTagsFromText('<p>hello</p>')
+ * // 'hello'
+ * removeHTMLTagsFromText('<p>hello</p> <p>world</p>')
+ * // 'hello world'
+ */
+export declare const removeHTMLTagsFromText: (html: string) => string;
+/**
+ * Capitalize the first letter of a string
+ * @param string A string
+ * @returns string
+ * @example
+ * capitalizeFirstLetter('hello')
+ * // 'Hello'
+ * capitalizeFirstLetter('hello_world')
+ * // 'Hello_World'
+ */
+export declare const capitalizeFirstLetter: (str: string) => string;
+/**
+ * Convert a string to camel case
+ * @param str
+ * @returns string
+ * @example
+ * toCamelCase('hello world')
+ * // 'helloWorld'
+ */
+export declare const toCamelCase: (str: string) => string;
+/**
+ * Convert a camelCase to space case
+ * @param str
+ * @returns string
+ * @example
+ * toSpaceCase('helloWorld')
+ * // 'Hello World'
+ */
+export declare const toSpaceCase: (str: string) => string;
+/**
+ * Get initials from a sentence
+ * @param sentence
+ * @returns string
+ * @example
+ * getInitialsFromSentence('Jude Agboola')
+ * // 'JA'
+ * getInitialsFromSentence('Howard Lee')
+ * // 'HL'
+ */
+export declare const getInitialsFromSentence: (sentence: string) => string;
+export declare const capitalizeWord: (str: string) => string;
+export declare const capitalizeWordsInSentence: (sentence: string) => string;
+export declare const lowerCaseWord: (str: string) => string;
+export declare const toTitleCase: (str: string, splitChar?: string) => string;
+export declare const simplePluralize: (word: string, length: number) => string;
+/**
+ * Formats an array of strings into a single string where items are separated by commas,
+ * with 'and' before the last item if there are multiple items.
+ *
+ * @param {string[]} items - The array of strings to format.
+ * @returns {string} The formatted string.
+ * @example
+ * // returns 'apple'
+ * formatListWithCommasAndAnd(['apple']);
+ *
+ * @example
+ * // returns 'apple and orange'
+ * formatListWithCommasAndAnd(['apple', 'orange']);
+ *
+ * @example
+ * // returns 'apple, orange, and banana'
+ * formatListWithCommasAndAnd(['apple', 'orange', 'banana']);
+ */

package/dist/shared/lib/string.js

@@ -0,0 +1,179 @@
+/**
+ * Truncate text
+ * @param str Text to truncate
+ * @param limit Limit of characters
+ * @returns
+ * @example
+ * truncateText('hello world', 5)
+ * // 'hello...'
+ * truncateText('hello world', 20)
+ * // 'hello world'
+ */
+export const truncateText = (str, limit = 20) => {
+    if (!str)
+        return '';
+    if (str.length > limit) {
+        return str.slice(0, limit) + '...';
+    }
+    return str;
+};
+/**
+ * Removes all non-letter characters from the provided string, allowing only
+ * English alphabet characters (both uppercase and lowercase) to remain.
+ * This function utilizes a regular expression to filter out any characters
+ * that are not letters, such as numbers, punctuation marks, spaces, and symbols.
+ *
+ * @param input The string from which to remove non-letter characters.
+ * @returns The modified string containing only letters.
+ *
+ * @example
+ * keepOnlyLetters("Hello123 World!")
+ * // Returns: 'HelloWorld'
+ *
+ * @example
+ * keepOnlyLetters("2024 New Year!")
+ * // Returns: 'NewYear'
+ *
+ * @example
+ * keepOnlyLetters("Data @ 50% speed!")
+ * // Returns: 'Dataspeed'
+ */
+export const keepOnlyLetters = (input) => {
+    // Regular expression to match anything that is not a letter
+    const regex = /[^a-zA-Z]/g;
+    // Replace all non-letter characters with an empty string
+    return input.replace(regex, '');
+};
+/**
+ * Remove HTML tags from text
+ * @param html HTML string
+ * @returns string
+ * @example
+ * removeHTMLTagsFromText('<p>hello</p>')
+ * // 'hello'
+ * removeHTMLTagsFromText('<p>hello</p> <p>world</p>')
+ * // 'hello world'
+ */
+export const removeHTMLTagsFromText = (html) => {
+    const regex = /<\/?[a-z]+(?=[\s>])(?:[^>=]|=(?:'[^']*'|"[^"]*"|[^'"\s]*))*\s?\/?>/;
+    const htmlText = html.replace(regex, '').replace(/<[^>]*>?/gm, '');
+    let text = htmlText.split('&nbsp;'); // remove nbsp
+    return text.join(' ');
+};
+/**
+ * Capitalize the first letter of a string
+ * @param string A string
+ * @returns string
+ * @example
+ * capitalizeFirstLetter('hello')
+ * // 'Hello'
+ * capitalizeFirstLetter('hello_world')
+ * // 'Hello_World'
+ */
+export const capitalizeFirstLetter = (str) => {
+    if (!str)
+        return '';
+    return str
+        .split(/[-_]/)
+        .map(word => word.charAt(0).toUpperCase() + word.slice(1).toLowerCase())
+        .join('_');
+};
+/**
+ * Convert a string to camel case
+ * @param str
+ * @returns string
+ * @example
+ * toCamelCase('hello world')
+ * // 'helloWorld'
+ */
+export const toCamelCase = (str) => {
+    return str
+        .split(' ')
+        .map((word, index) => {
+        // Convert first word to lower case
+        if (index === 0) {
+            return word.toLowerCase();
+        }
+        // Capitalize the first letter of other words
+        return word.charAt(0).toUpperCase() + word.slice(1).toLowerCase();
+    })
+        .join('');
+};
+/**
+ * Convert a camelCase to space case
+ * @param str
+ * @returns string
+ * @example
+ * toSpaceCase('helloWorld')
+ * // 'Hello World'
+ */
+export const toSpaceCase = (str) => {
+    if (!str)
+        return '';
+    return str
+        .replace(/([A-Z])/g, ' $1') // insert a space before all capital letters
+        .replace(/^./, str[0].toUpperCase()); // capitalize the first letter
+};
+/**
+ * Get initials from a sentence
+ * @param sentence
+ * @returns string
+ * @example
+ * getInitialsFromSentence('Jude Agboola')
+ * // 'JA'
+ * getInitialsFromSentence('Howard Lee')
+ * // 'HL'
+ */
+export const getInitialsFromSentence = (sentence) => {
+    const words = sentence?.split(' ');
+    let initials = '';
+    for (let i = 0; i < words.length; i++) {
+        // if char is not a letter, skip
+        if (!words[i].match(/[a-zA-Z]/))
+            continue;
+        // Get the first character of each word and convert it to uppercase
+        initials += words[i].charAt(0).toUpperCase();
+    }
+    return initials;
+};
+export const capitalizeWord = (str) => {
+    if (!str)
+        return '';
+    return str.charAt(0).toLocaleUpperCase() + str.slice(1);
+};
+export const capitalizeWordsInSentence = (sentence) => {
+    if (!sentence)
+        return '';
+    return sentence
+        .split(' ')
+        .map(word => capitalizeWord(word))
+        .join(' ');
+};
+export const lowerCaseWord = (str) => {
+    return str.toLocaleLowerCase();
+};
+export const toTitleCase = (str, splitChar = ' ') => {
+    return str
+        .split(splitChar)
+        .map(word => word.charAt(0).toUpperCase() + word.slice(1).toLowerCase())
+        .join(' ');
+};
+export const simplePluralize = (word, length) => `${word}${length === 1 ? '' : 's'}`;
+/**
+ * Formats an array of strings into a single string where items are separated by commas,
+ * with 'and' before the last item if there are multiple items.
+ *
+ * @param {string[]} items - The array of strings to format.
+ * @returns {string} The formatted string.
+ * @example
+ * // returns 'apple'
+ * formatListWithCommasAndAnd(['apple']);
+ *
+ * @example
+ * // returns 'apple and orange'
+ * formatListWithCommasAndAnd(['apple', 'orange']);
+ *
+ * @example
+ * // returns 'apple, orange, and banana'
+ * formatListWithCommasAndAnd(['apple', 'orange', 'banana']);
+ */

package/dist/shared/lib/utils.d.ts

@@ -0,0 +1,2 @@
+import { type ClassValue } from 'clsx';
+export declare function cn(...inputs: ClassValue[]): string;

package/dist/shared/lib/utils.js

@@ -0,0 +1,5 @@
+import { clsx } from 'clsx';
+import { twMerge } from 'tailwind-merge';
+export function cn(...inputs) {
+    return twMerge(clsx(inputs));
+}

package/dist/shared/services/agent/index.d.ts

@@ -0,0 +1,4 @@
+declare const agentService: {
+    getAgents: () => Promise<any>;
+};
+export default agentService;

package/dist/shared/services/agent/index.js

@@ -0,0 +1,13 @@
+const getAgents = async () => {
+    const agents = await fetch('/api/agents', {
+        method: 'GET',
+        headers: {
+            'Content-Type': 'application/json',
+        },
+    });
+    return agents;
+};
+const agentService = {
+    getAgents,
+};
+export default agentService;

package/dist/shared/services/tools/index.d.ts

@@ -0,0 +1,4 @@
+declare const toolsService: {
+    getTools: () => Promise<any>;
+};
+export default toolsService;

package/dist/shared/services/tools/index.js

@@ -0,0 +1,10 @@
+import agentService from "../agent";
+const getTools = async () => {
+    const agents = await agentService.getAgents();
+    const tools = agents.map((agent) => agent.tools);
+    return tools;
+};
+const toolsService = {
+    getTools,
+};
+export default toolsService;

package/dist/shared/types.d.ts

@@ -0,0 +1,11 @@
+export interface Message {
+    id: string;
+    role: 'user' | 'assistant';
+    content: any;
+    isError?: boolean;
+}
+export interface ChatProps {
+    agentId: string;
+    agentName?: string;
+    initialMessages?: Message[];
+}

package/dist/shared/types.js

@@ -0,0 +1 @@
+export {};

package/dist/src/analytics/index.d.ts

@@ -0,0 +1,30 @@
+export declare class PosthogAnalytics {
+    private sessionId;
+    private client?;
+    private distinctId;
+    private version;
+    constructor({ version, apiKey, host, }: {
+        version: string;
+        apiKey: string;
+        host: string;
+    });
+    private writeCliConfig;
+    private initializePostHog;
+    private isTelemetryEnabled;
+    private getDistinctId;
+    private getSystemProperties;
+    private captureSessionStart;
+    trackCommand(options: {
+        command: string;
+        args?: Record<string, unknown>;
+        durationMs?: number;
+        status?: 'success' | 'error';
+        error?: string;
+    }): void;
+    trackCommandExecution<T>({ command, args, execution, }: {
+        command: string;
+        args: Record<string, unknown>;
+        execution: () => Promise<T>;
+    }): Promise<T>;
+    shutdown(): Promise<void>;
+}