mastra 0.1.57-unstable.38 → 0.1.57-unstable.56

package/dist/shared/components/ui/calendar.d.ts

@@ -0,0 +1,8 @@
+import * as React from 'react';
+import { DayPicker } from 'react-day-picker';
+export type CalendarProps = React.ComponentProps<typeof DayPicker>;
+declare function Calendar({ className, classNames, showOutsideDays, ...props }: CalendarProps): import("react/jsx-runtime").JSX.Element;
+declare namespace Calendar {
+    var displayName: string;
+}
+export { Calendar };

package/dist/shared/components/ui/calendar.js

@@ -0,0 +1,41 @@
+'use client';
+import { jsx as _jsx } from "react/jsx-runtime";
+import { CalendarIcon } from 'lucide-react';
+import { DayPicker } from 'react-day-picker';
+import { cn } from '../../lib/utils';
+import { buttonVariants } from './button';
+function Calendar({ className, classNames, showOutsideDays = true, ...props }) {
+    return (_jsx(DayPicker, { showOutsideDays: showOutsideDays, className: cn('p-3', className), classNames: {
+            months: 'flex flex-col space-y-4 sm:space-y-0',
+            month: 'space-y-4',
+            month_caption: 'flex justify-center pt-1 relative items-center',
+            caption_label: 'text-sm text-text font-medium',
+            nav: 'space-x-1 flex items-center',
+            button_previous: cn(buttonVariants({ variant: 'outline' }), 'h-7 w-7 bg-transparent p-0 opacity-50 hover:opacity-100', 'absolute left-1 top-[12px] z-10'),
+            button_next: cn(buttonVariants({ variant: 'outline' }), 'h-7 w-7 bg-transparent p-0 opacity-50 hover:opacity-100', 'absolute right-1 top-[12px] z-10'),
+            month_grid: 'w-full border-collapse space-y-1',
+            weekdays: 'flex',
+            weekday: 'text-muted-foreground rounded-md w-8 font-normal text-[0.8rem]',
+            week: 'flex w-full mt-2',
+            day: cn(buttonVariants({ variant: 'ghost' }), 'relative p-0 text-center text-sm focus-within:relative focus-within:z-20 [&:has([aria-selected])]:bg-accent [&:has([aria-selected].day-outside)]:bg-accent/50 [&:has([aria-selected].day-range-end)]:rounded-r-md', props.mode === 'range'
+                ? '[&:has(>.day-range-end)]:rounded-r-md [&:has(>.day-range-start)]:rounded-l-md first:[&:has([aria-selected])]:rounded-l-md last:[&:has([aria-selected])]:rounded-r-md'
+                : '[&:has([aria-selected])]:rounded-md', 'h-8 w-8 p-0 hover:bg-lightGray-7/50 font-normal aria-selected:opacity-100'),
+            range_start: 'day-range-start',
+            range_end: 'day-range-end',
+            selected: '!bg-primary !text-primary-foreground hover:bg-primary hover:text-primary-foreground focus:bg-primary focus:text-primary-foreground',
+            today: 'bg-lightGray-7/50 text-accent-foreground',
+            outside: 'day-outside text-muted-foreground opacity-50  aria-selected:bg-accent/50 aria-selected:text-muted-foreground aria-selected:opacity-30',
+            disabled: 'text-muted-foreground opacity-50',
+            range_middle: 'aria-selected:bg-accent aria-selected:text-accent-foreground',
+            hidden: 'invisible',
+            ...classNames,
+        }, components: {
+            Chevron: ({ orientation }) => (_jsx(CalendarIcon, { className: cn('h-4 w-4', {
+                    'rotate-180': orientation === 'up',
+                    'rotate-90': orientation === 'left',
+                    '-rotate-90': orientation === 'right',
+                }) })),
+        }, ...props }));
+}
+Calendar.displayName = 'Calendar';
+export { Calendar };

package/dist/shared/components/ui/checkbox.d.ts

@@ -0,0 +1,4 @@
+import * as CheckboxPrimitive from '@radix-ui/react-checkbox';
+import * as React from 'react';
+declare const Checkbox: React.ForwardRefExoticComponent<Omit<CheckboxPrimitive.CheckboxProps & React.RefAttributes<HTMLButtonElement>, "ref"> & React.RefAttributes<HTMLButtonElement>>;
+export { Checkbox };

package/dist/shared/components/ui/checkbox.js

@@ -0,0 +1,8 @@
+'use client';
+import { jsx as _jsx } from "react/jsx-runtime";
+import * as CheckboxPrimitive from '@radix-ui/react-checkbox';
+import * as React from 'react';
+import { cn } from '../../lib/utils';
+const Checkbox = React.forwardRef(({ className, ...props }, ref) => (_jsx(CheckboxPrimitive.Root, { ref: ref, className: cn('ring-offset-background peer h-4 w-4 shrink-0 rounded-sm border border-mastra-border-4', 'data-[state=checked]:text-white data-[state=checked]:bg-mastra-bg-7', 'focus-visible:ring-offset-2 focus-visible:outline-none focus-visible:ring-2 focus-visible:ring-ring', 'disabled:cursor-not-allowed disabled:opacity-50', className), ...props, children: _jsx(CheckboxPrimitive.Indicator, { className: cn('flex items-center justify-center text-current'), children: _jsx("svg", { xmlns: "http://www.w3.org/2000/svg", width: "24", height: "24", viewBox: "0 0 24 24", fill: "none", stroke: "currentColor", strokeWidth: "2", strokeLinecap: "round", strokeLinejoin: "round", className: "h-4 w-4", children: _jsx("polyline", { points: "20 6 9 17 4 12" }) }) }) })));
+Checkbox.displayName = CheckboxPrimitive.Root.displayName;
+export { Checkbox };

package/dist/shared/components/ui/code-block.d.ts

@@ -0,0 +1,6 @@
+declare function CodeBlockDemo({ code, language, filename, }: {
+    code?: string;
+    language: 'ts' | 'json';
+    filename?: string;
+}): import("react/jsx-runtime").JSX.Element;
+export { CodeBlockDemo };

package/dist/shared/components/ui/code-block.js

@@ -0,0 +1,8 @@
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import { themes } from 'prism-react-renderer';
+import { CodeBlock } from 'react-code-block';
+import { cn } from '../../lib/utils';
+function CodeBlockDemo({ code = '', language = 'ts', filename, }) {
+    return (_jsxs(CodeBlock, { code: code, language: language, theme: themes.oneDark, children: [filename ? (_jsx("div", { className: "absolute  rounded bg-mastra-bg-2 w-full text-sm text-mastra-el-6/50 px-6 pl-4 py-2", children: filename })) : null, _jsx(CodeBlock.Code, { className: cn('bg-transparent h-full p-6 rounded-xl', filename ? 'pt-10' : ''), children: _jsx("div", { className: "table-row", children: _jsxs("div", { className: "flex items-center", children: [_jsx(CodeBlock.LineNumber, { className: "table-cell pr-4 text-sm text-gray-500/50 text-right select-none" }), _jsx(CodeBlock.LineContent, { className: "flex", children: _jsx(CodeBlock.Token, { className: "mastra-token text-sm font-mono" }) })] }) }) })] }));
+}
+export { CodeBlockDemo };

package/dist/shared/components/ui/collapsible.d.ts

@@ -0,0 +1,5 @@
+import * as CollapsiblePrimitive from '@radix-ui/react-collapsible';
+declare const Collapsible: import("react").ForwardRefExoticComponent<CollapsiblePrimitive.CollapsibleProps & import("react").RefAttributes<HTMLDivElement>>;
+declare const CollapsibleTrigger: import("react").ForwardRefExoticComponent<CollapsiblePrimitive.CollapsibleTriggerProps & import("react").RefAttributes<HTMLButtonElement>>;
+declare const CollapsibleContent: import("react").ForwardRefExoticComponent<CollapsiblePrimitive.CollapsibleContentProps & import("react").RefAttributes<HTMLDivElement>>;
+export { Collapsible, CollapsibleTrigger, CollapsibleContent };

package/dist/shared/components/ui/collapsible.js

@@ -0,0 +1,6 @@
+'use client';
+import * as CollapsiblePrimitive from '@radix-ui/react-collapsible';
+const Collapsible = CollapsiblePrimitive.Root;
+const CollapsibleTrigger = CollapsiblePrimitive.CollapsibleTrigger;
+const CollapsibleContent = CollapsiblePrimitive.CollapsibleContent;
+export { Collapsible, CollapsibleTrigger, CollapsibleContent };

package/dist/shared/components/ui/command.d.ts

@@ -0,0 +1,78 @@
+import * as React from 'react';
+declare const Command: React.ForwardRefExoticComponent<Omit<{
+    children?: React.ReactNode;
+} & Pick<Pick<React.DetailedHTMLProps<React.HTMLAttributes<HTMLDivElement>, HTMLDivElement>, "key" | keyof React.HTMLAttributes<HTMLDivElement>> & {
+    ref?: React.Ref<HTMLDivElement>;
+} & {
+    asChild?: boolean;
+}, "key" | "asChild" | keyof React.HTMLAttributes<HTMLDivElement>> & {
+    label?: string;
+    shouldFilter?: boolean;
+    filter?: (value: string, search: string, keywords?: string[]) => number;
+    defaultValue?: string;
+    value?: string;
+    onValueChange?: (value: string) => void;
+    loop?: boolean;
+    disablePointerSelection?: boolean;
+    vimBindings?: boolean;
+} & React.RefAttributes<HTMLDivElement>, "ref"> & React.RefAttributes<HTMLDivElement>>;
+declare const CommandInput: React.ForwardRefExoticComponent<Omit<Omit<Pick<Pick<React.DetailedHTMLProps<React.InputHTMLAttributes<HTMLInputElement>, HTMLInputElement>, "key" | keyof React.InputHTMLAttributes<HTMLInputElement>> & {
+    ref?: React.Ref<HTMLInputElement>;
+} & {
+    asChild?: boolean;
+}, "key" | "asChild" | keyof React.InputHTMLAttributes<HTMLInputElement>>, "value" | "type" | "onChange"> & {
+    value?: string;
+    onValueChange?: (search: string) => void;
+} & React.RefAttributes<HTMLInputElement>, "ref"> & React.RefAttributes<HTMLInputElement>>;
+declare const CommandList: React.ForwardRefExoticComponent<Omit<{
+    children?: React.ReactNode;
+} & Pick<Pick<React.DetailedHTMLProps<React.HTMLAttributes<HTMLDivElement>, HTMLDivElement>, "key" | keyof React.HTMLAttributes<HTMLDivElement>> & {
+    ref?: React.Ref<HTMLDivElement>;
+} & {
+    asChild?: boolean;
+}, "key" | "asChild" | keyof React.HTMLAttributes<HTMLDivElement>> & {
+    label?: string;
+} & React.RefAttributes<HTMLDivElement>, "ref"> & React.RefAttributes<HTMLDivElement>>;
+declare const CommandEmpty: React.ForwardRefExoticComponent<Omit<{
+    children?: React.ReactNode;
+} & Pick<Pick<React.DetailedHTMLProps<React.HTMLAttributes<HTMLDivElement>, HTMLDivElement>, "key" | keyof React.HTMLAttributes<HTMLDivElement>> & {
+    ref?: React.Ref<HTMLDivElement>;
+} & {
+    asChild?: boolean;
+}, "key" | "asChild" | keyof React.HTMLAttributes<HTMLDivElement>> & React.RefAttributes<HTMLDivElement>, "ref"> & React.RefAttributes<HTMLDivElement>>;
+declare const CommandGroup: React.ForwardRefExoticComponent<Omit<{
+    children?: React.ReactNode;
+} & Omit<Pick<Pick<React.DetailedHTMLProps<React.HTMLAttributes<HTMLDivElement>, HTMLDivElement>, "key" | keyof React.HTMLAttributes<HTMLDivElement>> & {
+    ref?: React.Ref<HTMLDivElement>;
+} & {
+    asChild?: boolean;
+}, "key" | "asChild" | keyof React.HTMLAttributes<HTMLDivElement>>, "value" | "heading"> & {
+    heading?: React.ReactNode;
+    value?: string;
+    forceMount?: boolean;
+} & React.RefAttributes<HTMLDivElement>, "ref"> & React.RefAttributes<HTMLDivElement>>;
+declare const CommandSeparator: React.ForwardRefExoticComponent<Omit<Pick<Pick<React.DetailedHTMLProps<React.HTMLAttributes<HTMLDivElement>, HTMLDivElement>, "key" | keyof React.HTMLAttributes<HTMLDivElement>> & {
+    ref?: React.Ref<HTMLDivElement>;
+} & {
+    asChild?: boolean;
+}, "key" | "asChild" | keyof React.HTMLAttributes<HTMLDivElement>> & {
+    alwaysRender?: boolean;
+} & React.RefAttributes<HTMLDivElement>, "ref"> & React.RefAttributes<HTMLDivElement>>;
+declare const CommandItem: React.ForwardRefExoticComponent<Omit<{
+    children?: React.ReactNode;
+} & Omit<Pick<Pick<React.DetailedHTMLProps<React.HTMLAttributes<HTMLDivElement>, HTMLDivElement>, "key" | keyof React.HTMLAttributes<HTMLDivElement>> & {
+    ref?: React.Ref<HTMLDivElement>;
+} & {
+    asChild?: boolean;
+}, "key" | "asChild" | keyof React.HTMLAttributes<HTMLDivElement>>, "value" | "disabled" | "onSelect"> & {
+    disabled?: boolean;
+    onSelect?: (value: string) => void;
+    value?: string;
+    keywords?: string[];
+    forceMount?: boolean;
+} & React.RefAttributes<HTMLDivElement>, "ref"> & React.RefAttributes<HTMLDivElement>>;
+declare const CommandShortcut: {
+    ({ className, ...props }: React.HTMLAttributes<HTMLSpanElement>): import("react/jsx-runtime").JSX.Element;
+    displayName: string;
+};
+export { Command, CommandInput, CommandList, CommandEmpty, CommandGroup, CommandItem, CommandShortcut, CommandSeparator, };

package/dist/shared/components/ui/command.js

@@ -0,0 +1,25 @@
+'use client';
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import { Command as CommandPrimitive } from 'cmdk';
+import { Search } from 'lucide-react';
+import * as React from 'react';
+import { cn } from '../../lib/utils';
+const Command = React.forwardRef(({ className, ...props }, ref) => (_jsx(CommandPrimitive, { ref: ref, className: cn('flex h-full w-full flex-col overflow-hidden rounded-md bg-popover text-popover-foreground', className), ...props })));
+Command.displayName = CommandPrimitive.displayName;
+const CommandInput = React.forwardRef(({ className, ...props }, ref) => (_jsxs("div", { className: "flex items-center border-b px-3", "cmdk-input-wrapper": "", children: [_jsx(Search, { className: "mr-2 h-4 w-4 shrink-0 opacity-50" }), _jsx(CommandPrimitive.Input, { ref: ref, className: cn('flex h-11 w-full rounded-md bg-transparent py-3 text-sm outline-none placeholder:text-muted-foreground disabled:cursor-not-allowed disabled:opacity-50', className), ...props })] })));
+CommandInput.displayName = CommandPrimitive.Input.displayName;
+const CommandList = React.forwardRef(({ className, ...props }, ref) => (_jsx(CommandPrimitive.List, { ref: ref, className: cn('max-h-[300px] overflow-y-auto overflow-x-hidden', className), ...props })));
+CommandList.displayName = CommandPrimitive.List.displayName;
+const CommandEmpty = React.forwardRef((props, ref) => _jsx(CommandPrimitive.Empty, { ref: ref, className: "py-6 text-center text-sm", ...props }));
+CommandEmpty.displayName = CommandPrimitive.Empty.displayName;
+const CommandGroup = React.forwardRef(({ className, ...props }, ref) => (_jsx(CommandPrimitive.Group, { ref: ref, className: cn('overflow-hidden p-1 text-foreground [&_[cmdk-group-heading]]:px-2 [&_[cmdk-group-heading]]:py-1.5 [&_[cmdk-group-heading]]:text-xs [&_[cmdk-group-heading]]:font-medium [&_[cmdk-group-heading]]:text-muted-foreground', className), ...props })));
+CommandGroup.displayName = CommandPrimitive.Group.displayName;
+const CommandSeparator = React.forwardRef(({ className, ...props }, ref) => (_jsx(CommandPrimitive.Separator, { ref: ref, className: cn('-mx-1 h-px bg-border', className), ...props })));
+CommandSeparator.displayName = CommandPrimitive.Separator.displayName;
+const CommandItem = React.forwardRef(({ className, ...props }, ref) => (_jsx(CommandPrimitive.Item, { ref: ref, className: cn('relative flex cursor-default select-none items-center rounded-sm px-2 py-1.5 text-sm outline-none aria-selected:bg-accent aria-selected:text-accent-foreground data-[disabled]:pointer-events-none data-[disabled]:opacity-50', className), ...props })));
+CommandItem.displayName = CommandPrimitive.Item.displayName;
+const CommandShortcut = ({ className, ...props }) => {
+    return _jsx("span", { className: cn('ml-auto text-xs tracking-widest text-muted-foreground', className), ...props });
+};
+CommandShortcut.displayName = 'CommandShortcut';
+export { Command, CommandInput, CommandList, CommandEmpty, CommandGroup, CommandItem, CommandShortcut, CommandSeparator, };

package/dist/shared/components/ui/copy-button.d.ts

@@ -1,6 +1,7 @@
 type CopyButtonProps = {
     content: string;
     copyMessage?: string;
+    classname?: string;
 };
-export declare function CopyButton({ content, copyMessage }: CopyButtonProps): import("react/jsx-runtime").JSX.Element;
+export declare function CopyButton({ content, copyMessage, classname }: CopyButtonProps): import("react/jsx-runtime").JSX.Element;
 export {};

package/dist/shared/components/ui/copy-button.js

@@ -4,10 +4,10 @@ import { Check, Copy } from 'lucide-react';
 import { Button } from '../../components/ui/button';
 import { useCopyToClipboard } from '../../hooks/use-copy-to-clipboard';
 import { cn } from '../../lib/utils';
-export function CopyButton({ content, copyMessage }) {
+export function CopyButton({ content, copyMessage, classname }) {
     const { isCopied, handleCopy } = useCopyToClipboard({
         text: content,
         copyMessage,
     });
-    return (_jsxs(Button, { variant: "ghost", size: "icon", className: "relative h-6 w-6", "aria-label": "Copy to clipboard", onClick: handleCopy, children: [_jsx("div", { className: "absolute inset-0 flex items-center justify-center", children: _jsx(Check, { className: cn('h-4 w-4 transition-transform ease-in-out', isCopied ? 'scale-100' : 'scale-0') }) }), _jsx(Copy, { className: cn('h-4 w-4 transition-transform ease-in-out', isCopied ? 'scale-0' : 'scale-100') })] }));
+    return (_jsxs(Button, { variant: "ghost", size: "icon", className: cn('relative h-6 w-6', classname), "aria-label": "Copy to clipboard", onClick: handleCopy, children: [_jsx("div", { className: "absolute inset-0 flex items-center justify-center", children: _jsx(Check, { className: cn('h-4 w-4 transition-transform ease-in-out', isCopied ? 'scale-100' : 'scale-0') }) }), _jsx(Copy, { className: cn('h-4 w-4 transition-transform ease-in-out', isCopied ? 'scale-0' : 'scale-100') })] }));
 }

package/dist/shared/components/ui/date-picker.d.ts

@@ -0,0 +1,23 @@
+import * as React from 'react';
+import { type PropsSingle } from 'react-day-picker';
+type CommonProps = Omit<PropsSingle, 'mode' | 'selected' | 'onSelect'> & {
+    value: Date | undefined | null;
+    setValue: (date: Date | undefined | null) => void;
+    clearable?: boolean;
+};
+export type DatePickerProps = (CommonProps & {
+    children?: never;
+    className?: string;
+    placeholder?: string;
+}) | (CommonProps & {
+    children: React.ReactNode;
+    className?: never;
+    placeholder?: string;
+});
+export declare const DatePicker: React.FC<DatePickerProps>;
+export declare const DatePickerOnly: ({ value, setValue, setOpenPopover, clearable, placeholder, className, ...props }: CommonProps & {
+    setOpenPopover?: (open: boolean) => void;
+    placeholder?: string;
+    className?: string;
+}) => import("react/jsx-runtime").JSX.Element;
+export {};

package/dist/shared/components/ui/date-picker.js

@@ -0,0 +1,66 @@
+'use client';
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import { format, isValid } from 'date-fns';
+import { CalendarIcon } from 'lucide-react';
+import * as React from 'react';
+import { useDebouncedCallback } from 'use-debounce';
+import { cn } from '../../lib/utils';
+import { Button } from './button';
+import { Calendar } from './calendar';
+import { Input } from './input';
+import { Popover, PopoverContent, PopoverTrigger } from './popover';
+export const DatePicker = ({ value, setValue, children, className, placeholder, ...props }) => {
+    const [openPopover, setOpenPopover] = React.useState(false);
+    return (_jsxs(Popover, { open: openPopover, onOpenChange: setOpenPopover, children: [_jsx(PopoverTrigger, { asChild: true, children: children ? (children) : (_jsx(DefaultButton, { value: value, placeholder: placeholder, className: className, "data-testid": "datepicker-button" })) }), _jsx(PopoverContent, { className: "backdrop-blur-4xl w-auto p-0", align: "start", "data-testid": "datepicker-calendar", children: _jsx(DatePickerOnly, { value: value, setValue: v => setValue(v ? new Date(`${v}z`) : null), clearable: props.clearable, setOpenPopover: setOpenPopover, ...props }) })] }));
+};
+export const DatePickerOnly = ({ value, setValue, setOpenPopover, clearable, placeholder, className, ...props }) => {
+    const [inputValue, setInputValue] = React.useState(value ? format(value, 'PP') : '');
+    const [selected, setSelected] = React.useState(value ? new Date(value) : undefined);
+    const debouncedDateUpdate = useDebouncedCallback((date) => {
+        if (isValid(date)) {
+            setSelected(date);
+            setValue?.(date);
+            setOpenPopover?.(false);
+        }
+    }, 2000);
+    const handleInputChange = e => {
+        setInputValue(e.currentTarget.value);
+        const date = new Date(e.target.value);
+        debouncedDateUpdate(date);
+    };
+    const handleDaySelect = (date) => {
+        setSelected(date);
+        setValue?.(date);
+        setOpenPopover?.(false);
+        if (date) {
+            setInputValue(format(date, 'PP'));
+        }
+        else {
+            setInputValue('');
+        }
+    };
+    const handleMonthSelect = (date) => {
+        setSelected(date);
+        if (date) {
+            setInputValue(format(date, 'PP'));
+        }
+        else {
+            setInputValue('');
+        }
+    };
+    return (_jsxs("div", { "aria-label": "Choose date", className: "relative mt-2 flex flex-col gap-2", onKeyDown: e => {
+            e.stopPropagation();
+            if (e.key === 'Escape') {
+                setOpenPopover?.(false);
+            }
+        }, children: [_jsx("div", { className: "w-full px-3", children: _jsx(Input, { type: "date", value: inputValue, onChange: handleInputChange, placeholder: placeholder, className: className }) }), _jsx(Calendar, { mode: "single", month: selected, selected: selected, onMonthChange: handleMonthSelect, onSelect: handleDaySelect, ...props }), _jsx("div", { className: "px-3 pb-2", children: clearable && (_jsx(Button, { variant: "outline", tabIndex: 0, className: "w-full !opacity-50 duration-200 hover:!opacity-100", onClick: () => {
+                        setValue(null);
+                        setSelected(undefined);
+                        setInputValue('');
+                        setOpenPopover?.(false);
+                    }, children: "Clear" })) })] }));
+};
+const DefaultButton = React.forwardRef(({ value, placeholder, className, ...props }, ref) => {
+    return (_jsxs(Button, { ref: ref, variant: 'outline', className: cn('bg-neutral-825 border-neutral-775 w-full justify-start whitespace-nowrap rounded-md border px-2 py-0 text-left flex items-center gap-1', className), ...props, children: [_jsx(CalendarIcon, { className: "h-4 w-4" }), value ? (_jsx("span", { className: "text-white", children: format(value, 'PPP') })) : (_jsx("span", { className: "text-gray", children: placeholder ?? 'Pick a date' }))] }));
+});
+DefaultButton.displayName = 'DefaultButton';

package/dist/shared/components/ui/dropdown-menu.d.ts

@@ -0,0 +1,51 @@
+import * as DropdownMenuPrimitive from '@radix-ui/react-dropdown-menu';
+import * as React from 'react';
+/**
+ *
+ * Right now, these are the props mostly used for the menu
+ * if we find out, consumers need more props, we can just extend it
+ * with componentProps
+ */
+declare function Dropdown({ open, onOpenChange, children, modal, }: {
+    open?: boolean;
+    onOpenChange?: (open: boolean) => void;
+    children: React.ReactNode;
+    modal?: boolean;
+}): import("react/jsx-runtime").JSX.Element;
+declare namespace Dropdown {
+    var Trigger: React.ForwardRefExoticComponent<Omit<DropdownMenuPrimitive.DropdownMenuTriggerProps & React.RefAttributes<HTMLButtonElement>, "ref"> & {
+        inset?: boolean;
+    } & React.RefAttributes<HTMLButtonElement>>;
+    var Content: React.ForwardRefExoticComponent<Omit<DropdownMenuPrimitive.DropdownMenuContentProps & React.RefAttributes<HTMLDivElement>, "ref"> & {
+        container?: HTMLElement;
+    } & React.RefAttributes<HTMLDivElement>>;
+    var Group: React.ForwardRefExoticComponent<DropdownMenuPrimitive.DropdownMenuGroupProps & React.RefAttributes<HTMLDivElement>>;
+    var Portal: React.FC<DropdownMenuPrimitive.DropdownMenuPortalProps>;
+    var Item: React.ForwardRefExoticComponent<Omit<DropdownMenuPrimitive.DropdownMenuItemProps & React.RefAttributes<HTMLDivElement>, "ref"> & {
+        inset?: boolean;
+    } & React.RefAttributes<HTMLDivElement>>;
+    var CheckboxItem: React.ForwardRefExoticComponent<Omit<DropdownMenuPrimitive.DropdownMenuCheckboxItemProps & React.RefAttributes<HTMLDivElement>, "ref"> & React.RefAttributes<HTMLDivElement>>;
+    var RadioItem: React.ForwardRefExoticComponent<Omit<DropdownMenuPrimitive.DropdownMenuRadioItemProps & React.RefAttributes<HTMLDivElement>, "ref"> & React.RefAttributes<HTMLDivElement>>;
+    var Label: React.ForwardRefExoticComponent<Omit<DropdownMenuPrimitive.DropdownMenuLabelProps & React.RefAttributes<HTMLDivElement>, "ref"> & {
+        inset?: boolean;
+    } & React.RefAttributes<HTMLDivElement>>;
+    var Separator: React.ForwardRefExoticComponent<Omit<DropdownMenuPrimitive.DropdownMenuSeparatorProps & React.RefAttributes<HTMLDivElement>, "ref"> & React.RefAttributes<HTMLDivElement>>;
+    var Shortcut: {
+        ({ className, ...props }: React.HTMLAttributes<HTMLSpanElement>): import("react/jsx-runtime").JSX.Element;
+        displayName: string;
+    };
+    var Sub: React.FC<DropdownMenuPrimitive.DropdownMenuSubProps>;
+    var SubContent: React.ForwardRefExoticComponent<Omit<DropdownMenuPrimitive.DropdownMenuSubContentProps & React.RefAttributes<HTMLDivElement>, "ref"> & React.RefAttributes<HTMLDivElement>>;
+    var SubTrigger: React.ForwardRefExoticComponent<Omit<DropdownMenuPrimitive.DropdownMenuSubTriggerProps & React.RefAttributes<HTMLDivElement>, "ref"> & {
+        inset?: boolean;
+    } & React.RefAttributes<HTMLDivElement>>;
+    var RadioGroup: React.ForwardRefExoticComponent<DropdownMenuPrimitive.DropdownMenuRadioGroupProps & React.RefAttributes<HTMLDivElement>>;
+    var VirtualizedItems: typeof VirtualizedDropdownItems;
+}
+type VirtualizedDropdownItemsProps<T> = React.HTMLAttributes<HTMLButtonElement> & {
+    itemsCount: number;
+    items: T[];
+    renderItem: (item: T) => React.ReactNode;
+};
+declare function VirtualizedDropdownItems<T>({ itemsCount, items, renderItem, ...props }: VirtualizedDropdownItemsProps<T>): import("react/jsx-runtime").JSX.Element;
+export { Dropdown };

package/dist/shared/components/ui/dropdown-menu.js

@@ -0,0 +1,81 @@
+'use client';
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import * as DropdownMenuPrimitive from '@radix-ui/react-dropdown-menu';
+import { useVirtualizer } from '@tanstack/react-virtual';
+import { Check, ChevronDown, Circle } from 'lucide-react';
+import * as React from 'react';
+import { cn } from '../../lib/utils';
+const DropdownMenu = DropdownMenuPrimitive.Root;
+const DropdownMenuGroup = DropdownMenuPrimitive.Group;
+const DropdownMenuPortal = DropdownMenuPrimitive.Portal;
+const DropdownMenuSub = DropdownMenuPrimitive.Sub;
+const DropdownMenuRadioGroup = DropdownMenuPrimitive.RadioGroup;
+const DropdownMenuTrigger = React.forwardRef(({ className, inset, children, ...props }, ref) => (_jsx(DropdownMenuPrimitive.Trigger, { ref: ref, className: cn('focus-visible:ring-ring focus:outline-none focus-visible:rounded focus-visible:outline-none focus-visible:ring-1', className), ...props, children: children })));
+DropdownMenuTrigger.displayName = DropdownMenuPrimitive.Trigger.displayName;
+const DropdownMenuSubTrigger = React.forwardRef(({ className, inset, children, ...props }, ref) => (_jsxs(DropdownMenuPrimitive.SubTrigger, { ref: ref, className: cn('focus:bg-accent data-[state=open]:bg-accent flex cursor-default select-none items-center rounded-sm px-2 py-1.5 text-sm outline-none', inset && 'pl-8', className), ...props, children: [children, _jsx(ChevronDown, { className: "ml-auto -rotate-90" })] })));
+DropdownMenuSubTrigger.displayName = DropdownMenuPrimitive.SubTrigger.displayName;
+const DropdownMenuSubContent = React.forwardRef(({ className, ...props }, ref) => (_jsx(DropdownMenuPrimitive.SubContent, { ref: ref, className: cn('popover-backdrop-filter popover-background popover-border popover-shadow popover-foreground data-[state=open]:fade-in-0 data-[state=closed]:fade-out-0 data-[state=open]:animate-in data-[state=closed]:animate-out data-[state=closed]:zoom-out-95 data-[state=open]:zoom-in-95 z-50 min-w-[8rem] overflow-auto overflow-x-hidden rounded-md p-1', className), ...props })));
+DropdownMenuSubContent.displayName = DropdownMenuPrimitive.SubContent.displayName;
+const DropdownMenuContent = React.forwardRef(({ className, container, sideOffset = 4, ...props }, ref) => {
+    return (_jsx(DropdownMenuPrimitive.Portal, { container: container, children: _jsx(DropdownMenuPrimitive.Content, { ref: ref, sideOffset: sideOffset, className: cn(
+            //not sure where these classes are coming from
+            'popover-backdrop-filter bg-mastra-bg-2 popover-border popover-shadow popover-foreground data-[state=open]:fade-in-0 data-[state=closed]:fade-out-0 data-[state=open]:animate-in data-[state=closed]:animate-out data-[state=closed]:zoom-out-95 data-[state=open]:zoom-in-95 z-50 min-w-[8rem] overflow-auto overflow-x-hidden rounded-md p-1', className), ...props }) }));
+});
+DropdownMenuContent.displayName = DropdownMenuPrimitive.Content.displayName;
+const DropdownMenuItem = React.forwardRef(({ className, inset, ...props }, ref) => (_jsx(DropdownMenuPrimitive.Item, { ref: ref, className: cn('focus:text-accent-foreground relative flex cursor-default select-none items-center gap-2 rounded-sm px-2 py-1.5 text-[0.8125rem] outline-none transition-colors focus:bg-[#66686A]/20 data-[disabled]:pointer-events-none data-[disabled]:opacity-50 [&>span]:truncate', inset && 'pl-8', className), ...props })));
+DropdownMenuItem.displayName = DropdownMenuPrimitive.Item.displayName;
+const DropdownMenuCheckboxItem = React.forwardRef(({ className, children, checked, ...props }, ref) => (_jsxs(DropdownMenuPrimitive.CheckboxItem, { ref: ref, className: cn('focus:bg-accent focus:text-accent-foreground relative flex cursor-default select-none items-center rounded-sm py-1.5 pl-8 pr-2 text-sm outline-none transition-colors data-[disabled]:pointer-events-none data-[disabled]:opacity-50', className), checked: checked, ...props, children: [_jsx("span", { className: "absolute left-2 flex h-3.5 w-3.5 items-center justify-center", children: _jsx(DropdownMenuPrimitive.ItemIndicator, { children: _jsx(Check, { className: "h-2 w-2 fill-current" }) }) }), children] })));
+DropdownMenuCheckboxItem.displayName = DropdownMenuPrimitive.CheckboxItem.displayName;
+const DropdownMenuRadioItem = React.forwardRef(({ className, children, ...props }, ref) => (_jsxs(DropdownMenuPrimitive.RadioItem, { ref: ref, className: cn('focus:bg-accent focus:text-accent-foreground relative flex cursor-default select-none items-center rounded-sm py-1.5 pl-8 pr-2 text-sm outline-none transition-colors data-[disabled]:pointer-events-none data-[disabled]:opacity-50', className), ...props, children: [_jsx("span", { className: "absolute left-2 flex h-3.5 w-3.5 items-center justify-center", children: _jsx(DropdownMenuPrimitive.ItemIndicator, { children: _jsx(Circle, { className: "h-2 w-2 fill-current" }) }) }), children] })));
+DropdownMenuRadioItem.displayName = DropdownMenuPrimitive.RadioItem.displayName;
+const DropdownMenuLabel = React.forwardRef(({ className, inset, ...props }, ref) => (_jsx(DropdownMenuPrimitive.Label, { ref: ref, className: cn('px-2 py-1.5 text-sm font-semibold', inset && 'pl-8', className), ...props })));
+DropdownMenuLabel.displayName = DropdownMenuPrimitive.Label.displayName;
+const DropdownMenuSeparator = React.forwardRef(({ className, ...props }, ref) => (_jsx(DropdownMenuPrimitive.Separator, { ref: ref, className: cn('popover-dividers-bg -mx-1 my-1 h-px', className), ...props })));
+DropdownMenuSeparator.displayName = DropdownMenuPrimitive.Separator.displayName;
+const DropdownMenuShortcut = ({ className, ...props }) => {
+    return _jsx("span", { className: cn('ml-auto text-xs tracking-widest opacity-60', className), ...props });
+};
+DropdownMenuShortcut.displayName = 'DropdownMenuShortcut';
+/**
+ *
+ * Right now, these are the props mostly used for the menu
+ * if we find out, consumers need more props, we can just extend it
+ * with componentProps
+ */
+function Dropdown({ open, onOpenChange, children, modal, }) {
+    return (_jsx(DropdownMenu, { modal: modal, open: open, onOpenChange: onOpenChange, children: children }));
+}
+function VirtualizedDropdownItems({ itemsCount, items, renderItem, ...props }) {
+    const parentRef = React.useRef(null);
+    const dropdownVirtualizer = useVirtualizer({
+        count: itemsCount,
+        estimateSize: () => 35,
+        getScrollElement: () => parentRef.current,
+        overscan: 5,
+        measureElement: typeof window !== 'undefined' && navigator.userAgent.indexOf('Firefox') === -1
+            ? element => element?.getBoundingClientRect().height
+            : undefined,
+    });
+    return (_jsx("div", { ref: parentRef, className: "h-64 overflow-auto", children: _jsx("div", { className: "relative w-full overflow-auto", style: {
+                height: `${dropdownVirtualizer.getTotalSize()}px`,
+            }, children: dropdownVirtualizer?.getVirtualItems().map((item, idx) => (_jsx("button", { className: "text-accent-foreground absolute left-0 top-0 flex w-full cursor-default select-none items-center gap-2 rounded-sm px-2 py-1.5 text-[0.8125rem] outline-none transition-colors hover:bg-[#66686A]/20 data-[disabled]:pointer-events-none data-[disabled]:opacity-50 [&>span]:truncate", style: {
+                    height: `${item.size}px`,
+                    transform: `translateY(${item.start}px)`,
+                }, ...props, children: renderItem(items[idx]) }, item.index))) }) }));
+}
+Dropdown.Trigger = DropdownMenuTrigger;
+Dropdown.Content = DropdownMenuContent;
+Dropdown.Group = DropdownMenuGroup;
+Dropdown.Portal = DropdownMenuPortal;
+Dropdown.Item = DropdownMenuItem;
+Dropdown.CheckboxItem = DropdownMenuCheckboxItem;
+Dropdown.RadioItem = DropdownMenuRadioItem;
+Dropdown.Label = DropdownMenuLabel;
+Dropdown.Separator = DropdownMenuSeparator;
+Dropdown.Shortcut = DropdownMenuShortcut;
+Dropdown.Sub = DropdownMenuSub;
+Dropdown.SubContent = DropdownMenuSubContent;
+Dropdown.SubTrigger = DropdownMenuSubTrigger;
+Dropdown.RadioGroup = DropdownMenuRadioGroup;
+Dropdown.VirtualizedItems = VirtualizedDropdownItems;
+export { Dropdown };

package/dist/shared/components/ui/form.d.ts

@@ -0,0 +1,23 @@
+import * as LabelPrimitive from '@radix-ui/react-label';
+import * as React from 'react';
+import { ControllerProps, FieldPath, FieldValues } from 'react-hook-form';
+declare const Form: <TFieldValues extends FieldValues, TContext = any, TTransformedValues extends FieldValues | undefined = undefined>(props: import("react-hook-form").FormProviderProps<TFieldValues, TContext, TTransformedValues>) => React.JSX.Element;
+declare const FormField: <TFieldValues extends FieldValues = FieldValues, TName extends FieldPath<TFieldValues> = FieldPath<TFieldValues>>({ ...props }: ControllerProps<TFieldValues, TName>) => import("react/jsx-runtime").JSX.Element;
+declare const useFormField: () => {
+    invalid: boolean;
+    isDirty: boolean;
+    isTouched: boolean;
+    isValidating: boolean;
+    error?: import("react-hook-form").FieldError;
+    id: string;
+    name: string;
+    formItemId: string;
+    formDescriptionId: string;
+    formMessageId: string;
+};
+declare const FormItem: React.ForwardRefExoticComponent<React.HTMLAttributes<HTMLDivElement> & React.RefAttributes<HTMLDivElement>>;
+declare const FormLabel: React.ForwardRefExoticComponent<Omit<LabelPrimitive.LabelProps & React.RefAttributes<HTMLLabelElement>, "ref"> & React.RefAttributes<HTMLLabelElement>>;
+declare const FormControl: React.ForwardRefExoticComponent<Omit<import("@radix-ui/react-slot").SlotProps & React.RefAttributes<HTMLElement>, "ref"> & React.RefAttributes<HTMLElement>>;
+declare const FormDescription: React.ForwardRefExoticComponent<React.HTMLAttributes<HTMLParagraphElement> & React.RefAttributes<HTMLParagraphElement>>;
+declare const FormMessage: React.ForwardRefExoticComponent<React.HTMLAttributes<HTMLParagraphElement> & React.RefAttributes<HTMLParagraphElement>>;
+export { useFormField, Form, FormItem, FormLabel, FormControl, FormDescription, FormMessage, FormField };

package/dist/shared/components/ui/form.js

@@ -0,0 +1,61 @@
+'use client';
+import { jsx as _jsx } from "react/jsx-runtime";
+import { Slot } from '@radix-ui/react-slot';
+import * as React from 'react';
+import { Controller, FormProvider, useFormContext } from 'react-hook-form';
+import { cn } from '../../lib/utils';
+import { Label } from './label';
+const Form = FormProvider;
+const FormFieldContext = React.createContext({});
+const FormField = ({ ...props }) => {
+    return (_jsx(FormFieldContext.Provider, { value: { name: props.name }, children: _jsx(Controller, { ...props }) }));
+};
+const useFormField = () => {
+    const fieldContext = React.useContext(FormFieldContext);
+    const itemContext = React.useContext(FormItemContext);
+    const { getFieldState, formState } = useFormContext();
+    const fieldState = getFieldState(fieldContext.name, formState);
+    if (!fieldContext) {
+        throw new Error('useFormField should be used within <FormField>');
+    }
+    const { id } = itemContext;
+    return {
+        id,
+        name: fieldContext.name,
+        formItemId: `${id}-form-item`,
+        formDescriptionId: `${id}-form-item-description`,
+        formMessageId: `${id}-form-item-message`,
+        ...fieldState,
+    };
+};
+const FormItemContext = React.createContext({});
+const FormItem = React.forwardRef(({ className, ...props }, ref) => {
+    const id = React.useId();
+    return (_jsx(FormItemContext.Provider, { value: { id }, children: _jsx("div", { ref: ref, className: cn('space-y-1', className), ...props }) }));
+});
+FormItem.displayName = 'FormItem';
+const FormLabel = React.forwardRef(({ className, ...props }, ref) => {
+    const { error, formItemId } = useFormField();
+    return _jsx(Label, { ref: ref, className: cn(error && 'text-destructive', className), htmlFor: formItemId, ...props });
+});
+FormLabel.displayName = 'FormLabel';
+const FormControl = React.forwardRef(({ ...props }, ref) => {
+    const { error, formItemId, formDescriptionId, formMessageId } = useFormField();
+    return (_jsx(Slot, { ref: ref, id: formItemId, "aria-describedby": !error ? `${formDescriptionId}` : `${formDescriptionId} ${formMessageId}`, "aria-invalid": !!error, ...props }));
+});
+FormControl.displayName = 'FormControl';
+const FormDescription = React.forwardRef(({ className, ...props }, ref) => {
+    const { formDescriptionId } = useFormField();
+    return _jsx("p", { ref: ref, id: formDescriptionId, className: cn('text-sm text-muted-foreground', className), ...props });
+});
+FormDescription.displayName = 'FormDescription';
+const FormMessage = React.forwardRef(({ className, children, ...props }, ref) => {
+    const { error, formMessageId } = useFormField();
+    const body = error ? String(error?.message) : children;
+    if (!body) {
+        return null;
+    }
+    return (_jsx("p", { ref: ref, id: formMessageId, className: cn('text-[13px] text-red-400', className), ...props, children: body }));
+});
+FormMessage.displayName = 'FormMessage';
+export { useFormField, Form, FormItem, FormLabel, FormControl, FormDescription, FormMessage, FormField };

package/dist/shared/components/ui/header.d.ts

@@ -0,0 +1,3 @@
+export declare const Header: ({ title }: {
+    title: string | React.ReactNode;
+}) => import("react/jsx-runtime").JSX.Element;

package/dist/shared/components/ui/header.js

@@ -0,0 +1,4 @@
+import { jsx as _jsx } from "react/jsx-runtime";
+export const Header = ({ title }) => {
+    return (_jsx("header", { className: "sticky top-0 z-50", children: _jsx("div", { className: "flex h-[var(--top-bar-height)] w-full content-center items-center justify-between border-b-[0.1px] border-mastra-border-1 px-[1.31rem]", children: _jsx("div", { className: "flex items-center gap-2", children: _jsx("h1", { className: "font-medium text-sm font-mono", children: title }) }) }) }));
+};

package/dist/shared/components/ui/input.d.ts

@@ -0,0 +1,11 @@
+import { type VariantProps } from 'class-variance-authority';
+import * as React from 'react';
+declare const inputVariants: (props?: {
+    variant?: "default" | "filled" | "unstyled";
+    customSize?: "default" | "sm" | "lg";
+} & import("class-variance-authority/types").ClassProp) => string;
+export interface InputProps extends React.InputHTMLAttributes<HTMLInputElement>, VariantProps<typeof inputVariants> {
+    testId?: string;
+}
+declare const Input: React.ForwardRefExoticComponent<InputProps & React.RefAttributes<HTMLInputElement>>;
+export { Input, inputVariants };

package/dist/shared/components/ui/input.js

@@ -0,0 +1,27 @@
+import { jsx as _jsx } from "react/jsx-runtime";
+import { cva } from 'class-variance-authority';
+import * as React from 'react';
+import { cn } from '../../lib/utils';
+const inputVariants = cva('flex w-full text-mastra-el-6 rounded-sm border bg-transparent shadow-sm focus-visible:ring-ring transition-colors focus-visible:outline-none focus-visible:ring-1 disabled:cursor-not-allowed disabled:opacity-50', {
+    variants: {
+        variant: {
+            default: 'border-mastra-border-1 border-border-1 placeholder:text-muted-foreground',
+            filled: 'bg-inputFill border-border-1 placeholder:text-muted-foreground',
+            unstyled: 'border-0 bg-transparent placeholder:text-muted-foreground focus-visible:ring-transparent focus-visible:outline-none',
+        },
+        customSize: {
+            default: 'px-[13px] text-[calc(13_/_16_*_1rem)] h-[34px]',
+            sm: 'h-[30px] px-[13px] text-xs',
+            lg: 'h-10 px-[17px] rounded-md text-[calc(13_/_16_*_1rem)]',
+        },
+    },
+    defaultVariants: {
+        variant: 'default',
+        customSize: 'default',
+    },
+});
+const Input = React.forwardRef(({ className, customSize, testId, variant, type, ...props }, ref) => {
+    return (_jsx("input", { type: type, className: cn(className, inputVariants({ variant, customSize, className })), "data-testid": testId, ref: ref, ...props }));
+});
+Input.displayName = 'Input';
+export { Input, inputVariants };

package/dist/shared/components/ui/label.d.ts

@@ -0,0 +1,5 @@
+import * as LabelPrimitive from '@radix-ui/react-label';
+import { type VariantProps } from 'class-variance-authority';
+import * as React from 'react';
+declare const Label: React.ForwardRefExoticComponent<Omit<LabelPrimitive.LabelProps & React.RefAttributes<HTMLLabelElement>, "ref"> & VariantProps<(props?: import("class-variance-authority/types").ClassProp) => string> & React.RefAttributes<HTMLLabelElement>>;
+export { Label };

package/dist/shared/components/ui/label.js

@@ -0,0 +1,10 @@
+'use client';
+import { jsx as _jsx } from "react/jsx-runtime";
+import * as LabelPrimitive from '@radix-ui/react-label';
+import { cva } from 'class-variance-authority';
+import * as React from 'react';
+import { cn } from '../../lib/utils';
+const labelVariants = cva('text-sm font-medium leading-none peer-disabled:cursor-not-allowed peer-disabled:opacity-70');
+const Label = React.forwardRef(({ className, ...props }, ref) => (_jsx(LabelPrimitive.Root, { ref: ref, className: cn(labelVariants(), className), ...props })));
+Label.displayName = LabelPrimitive.Root.displayName;
+export { Label };