@ciridae/ui 0.2.0

package/dist/components/agentic/model-selector.js

@@ -0,0 +1,47 @@
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import { Command, CommandDialog, CommandEmpty, CommandGroup, CommandInput, CommandItem, CommandList, CommandSeparator, CommandShortcut, } from "@ciridae/ui/command";
+import { Dialog, DialogContent, DialogTitle, DialogTrigger } from "@ciridae/ui/dialog";
+import { cn } from "@ciridae/ui/utils";
+function ModelSelector(props) {
+    return _jsx(Dialog, { ...props });
+}
+function ModelSelectorTrigger(props) {
+    return _jsx(DialogTrigger, { ...props });
+}
+function ModelSelectorContent({ children, className, title = "Model selector", ...props }) {
+    return (_jsxs(DialogContent, { "aria-describedby": undefined, className: cn("overflow-hidden p-0 sm:max-w-xl", className), ...props, children: [_jsx(DialogTitle, { className: "sr-only", children: title }), _jsx(Command, { className: "**:data-[slot=command-input-wrapper]:h-auto", children: children })] }));
+}
+function ModelSelectorDialog(props) {
+    return _jsx(CommandDialog, { ...props });
+}
+function ModelSelectorInput({ className, ...props }) {
+    return _jsx(CommandInput, { className: cn("h-auto py-3", className), ...props });
+}
+function ModelSelectorList(props) {
+    return _jsx(CommandList, { ...props });
+}
+function ModelSelectorEmpty(props) {
+    return _jsx(CommandEmpty, { ...props });
+}
+function ModelSelectorGroup(props) {
+    return _jsx(CommandGroup, { ...props });
+}
+function ModelSelectorItem(props) {
+    return _jsx(CommandItem, { ...props });
+}
+function ModelSelectorShortcut(props) {
+    return _jsx(CommandShortcut, { ...props });
+}
+function ModelSelectorSeparator(props) {
+    return _jsx(CommandSeparator, { ...props });
+}
+function ModelSelectorLogo({ alt, className, provider, src, ...props }) {
+    return (_jsx("img", { alt: alt ?? `${provider} logo`, className: cn("size-4 rounded-sm object-contain p-0.5 ring-1 ring-border dark:invert", className), height: 16, src: src ?? `https://models.dev/logos/${provider}.svg`, width: 16, ...props }));
+}
+function ModelSelectorLogoGroup({ className, ...props }) {
+    return (_jsx("div", { "data-slot": "model-selector-logo-group", className: cn("flex shrink-0 items-center -space-x-1 [&>img]:rounded-full [&>img]:bg-background [&>img]:p-px [&>img]:ring-1", className), ...props }));
+}
+function ModelSelectorName({ className, ...props }) {
+    return (_jsx("span", { "data-slot": "model-selector-name", className: cn("min-w-0 flex-1 truncate text-left", className), ...props }));
+}
+export { ModelSelector, ModelSelectorContent, ModelSelectorDialog, ModelSelectorEmpty, ModelSelectorGroup, ModelSelectorInput, ModelSelectorItem, ModelSelectorList, ModelSelectorLogo, ModelSelectorLogoGroup, ModelSelectorName, ModelSelectorSeparator, ModelSelectorShortcut, ModelSelectorTrigger, };

package/dist/components/agentic/node.d.ts

@@ -0,0 +1,26 @@
+import type * as React from "react";
+import { Position } from "@xyflow/react";
+import { Card, CardAction, CardContent, CardDescription, CardFooter, CardHeader, CardTitle } from "@ciridae/ui/card";
+type NodeProps = React.ComponentProps<typeof Card> & {
+    handles?: {
+        source?: boolean;
+        target?: boolean;
+    };
+    sourcePosition?: Position;
+    targetPosition?: Position;
+};
+type NodeHeaderProps = React.ComponentProps<typeof CardHeader>;
+type NodeTitleProps = React.ComponentProps<typeof CardTitle>;
+type NodeDescriptionProps = React.ComponentProps<typeof CardDescription>;
+type NodeActionProps = React.ComponentProps<typeof CardAction>;
+type NodeContentProps = React.ComponentProps<typeof CardContent>;
+type NodeFooterProps = React.ComponentProps<typeof CardFooter>;
+declare function Node({ children, className, handles, sourcePosition, targetPosition, ...props }: NodeProps): import("react/jsx-runtime").JSX.Element;
+declare function NodeHeader({ className, ...props }: NodeHeaderProps): import("react/jsx-runtime").JSX.Element;
+declare function NodeTitle(props: NodeTitleProps): import("react/jsx-runtime").JSX.Element;
+declare function NodeDescription(props: NodeDescriptionProps): import("react/jsx-runtime").JSX.Element;
+declare function NodeAction(props: NodeActionProps): import("react/jsx-runtime").JSX.Element;
+declare function NodeContent({ className, ...props }: NodeContentProps): import("react/jsx-runtime").JSX.Element;
+declare function NodeFooter({ className, ...props }: NodeFooterProps): import("react/jsx-runtime").JSX.Element;
+export { Node, NodeAction, NodeContent, NodeDescription, NodeFooter, NodeHeader, NodeTitle };
+export type { NodeActionProps, NodeContentProps, NodeDescriptionProps, NodeFooterProps, NodeHeaderProps, NodeProps, NodeTitleProps, };

package/dist/components/agentic/node.js

@@ -0,0 +1,29 @@
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import { Handle, Position } from "@xyflow/react";
+import { Card, CardAction, CardContent, CardDescription, CardFooter, CardHeader, CardTitle, } from "@ciridae/ui/card";
+import { cn } from "@ciridae/ui/utils";
+function Node({ children, className, handles = { source: true, target: true }, sourcePosition = Position.Right, targetPosition = Position.Left, ...props }) {
+    return (_jsxs(Card, { "data-slot": "node", className: cn("relative min-w-60 gap-3 py-4 shadow-xs", "data-[selected=true]:border-ring data-[selected=true]:ring-2 data-[selected=true]:ring-ring/20", className), ...props, children: [handles.target ? _jsx(NodeHandle, { position: targetPosition, type: "target" }) : null, children, handles.source ? _jsx(NodeHandle, { position: sourcePosition, type: "source" }) : null] }));
+}
+function NodeHandle({ position, type }) {
+    return (_jsx(Handle, { className: "size-2.5! border-2! border-background! bg-foreground!", position: position, type: type }));
+}
+function NodeHeader({ className, ...props }) {
+    return _jsx(CardHeader, { className: cn("gap-1 px-4", className), ...props });
+}
+function NodeTitle(props) {
+    return _jsx(CardTitle, { ...props });
+}
+function NodeDescription(props) {
+    return _jsx(CardDescription, { ...props });
+}
+function NodeAction(props) {
+    return _jsx(CardAction, { ...props });
+}
+function NodeContent({ className, ...props }) {
+    return _jsx(CardContent, { className: cn("px-4 text-sm", className), ...props });
+}
+function NodeFooter({ className, ...props }) {
+    return (_jsx(CardFooter, { className: cn("items-center justify-between px-4 text-xs", className), ...props }));
+}
+export { Node, NodeAction, NodeContent, NodeDescription, NodeFooter, NodeHeader, NodeTitle };

package/dist/components/agentic/open-in-chat.d.ts

@@ -0,0 +1,9 @@
+import type * as React from "react";
+import { Button } from "@ciridae/ui/button";
+type OpenInChatProps = React.ComponentProps<typeof Button> & {
+    label?: string;
+    metadataLabel?: string;
+};
+declare function OpenInChat({ children, className, label, metadataLabel, size, type, variant, ...props }: OpenInChatProps): import("react/jsx-runtime").JSX.Element;
+export { OpenInChat };
+export type { OpenInChatProps };

package/dist/components/agentic/open-in-chat.js

@@ -0,0 +1,8 @@
+import { jsx as _jsx, Fragment as _Fragment, jsxs as _jsxs } from "react/jsx-runtime";
+import { MessageSquareTextIcon } from "lucide-react";
+import { Button } from "@ciridae/ui/button";
+import { cn } from "@ciridae/ui/utils";
+function OpenInChat({ children, className, label = "Open in chat", metadataLabel, size = "sm", type = "button", variant = "outline", ...props }) {
+    return (_jsx(Button, { "data-slot": "open-in-chat", className: cn("max-w-full justify-start", className), size: size, type: type, variant: variant, ...props, children: children ?? (_jsxs(_Fragment, { children: [_jsx(MessageSquareTextIcon, { "aria-hidden": "true", className: "size-4" }), _jsx("span", { className: "truncate", children: label }), metadataLabel ? (_jsx("span", { className: "font-mono text-xs text-muted-foreground tabular-nums", children: metadataLabel })) : null] })) }));
+}
+export { OpenInChat };

package/dist/components/agentic/package-info.d.ts

@@ -0,0 +1,30 @@
+import type * as React from "react";
+import { Badge } from "@ciridae/ui/badge";
+type PackageChangeType = "added" | "major" | "minor" | "patch" | "removed";
+type PackageInfoProps = React.ComponentProps<"div"> & {
+    changeType?: PackageChangeType;
+    name: string;
+    version?: string;
+};
+type PackageInfoHeaderProps = React.ComponentProps<"div">;
+type PackageInfoNameProps = React.ComponentProps<"div">;
+type PackageInfoChangeTypeProps = React.ComponentProps<typeof Badge>;
+type PackageInfoVersionProps = React.ComponentProps<"div">;
+type PackageInfoDescriptionProps = React.ComponentProps<"p">;
+type PackageInfoContentProps = React.ComponentProps<"div">;
+type PackageInfoDependenciesProps = React.ComponentProps<"div">;
+type PackageInfoDependencyProps = React.ComponentProps<"div"> & {
+    name: string;
+    version?: string;
+};
+declare function PackageInfo({ children, className, changeType, name, version, ...props }: PackageInfoProps): import("react/jsx-runtime").JSX.Element;
+declare function PackageInfoHeader({ className, ...props }: PackageInfoHeaderProps): import("react/jsx-runtime").JSX.Element;
+declare function PackageInfoName({ className, ...props }: PackageInfoNameProps): import("react/jsx-runtime").JSX.Element;
+declare function PackageInfoChangeType({ children, variant, ...props }: PackageInfoChangeTypeProps): import("react/jsx-runtime").JSX.Element | null;
+declare function PackageInfoVersion({ className, ...props }: PackageInfoVersionProps): import("react/jsx-runtime").JSX.Element;
+declare function PackageInfoDescription({ className, ...props }: PackageInfoDescriptionProps): import("react/jsx-runtime").JSX.Element;
+declare function PackageInfoContent({ className, ...props }: PackageInfoContentProps): import("react/jsx-runtime").JSX.Element;
+declare function PackageInfoDependencies({ className, ...props }: PackageInfoDependenciesProps): import("react/jsx-runtime").JSX.Element;
+declare function PackageInfoDependency({ children, className, name, version, ...props }: PackageInfoDependencyProps): import("react/jsx-runtime").JSX.Element;
+export { PackageInfo, PackageInfoChangeType, PackageInfoContent, PackageInfoDependencies, PackageInfoDependency, PackageInfoDescription, PackageInfoHeader, PackageInfoName, PackageInfoVersion, };
+export type { PackageChangeType, PackageInfoChangeTypeProps, PackageInfoContentProps, PackageInfoDependenciesProps, PackageInfoDependencyProps, PackageInfoDescriptionProps, PackageInfoHeaderProps, PackageInfoNameProps, PackageInfoProps, PackageInfoVersionProps, };

package/dist/components/agentic/package-info.js

@@ -0,0 +1,44 @@
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import { PackageIcon } from "lucide-react";
+import { createContext, useContext, useMemo } from "react";
+import { Badge } from "@ciridae/ui/badge";
+import { cn } from "@ciridae/ui/utils";
+const PackageInfoContext = createContext({ name: "" });
+function usePackageInfo() {
+    return useContext(PackageInfoContext);
+}
+function PackageInfo({ children, className, changeType, name, version, ...props }) {
+    const contextValue = useMemo(() => ({ changeType, name, version }), [changeType, name, version]);
+    return (_jsx(PackageInfoContext.Provider, { value: contextValue, children: _jsx("div", { "data-slot": "package-info", className: cn("grid gap-3 rounded-lg border bg-card p-4", className), ...props, children: children }) }));
+}
+function PackageInfoHeader({ className, ...props }) {
+    return (_jsx("div", { "data-slot": "package-info-header", className: cn("flex min-w-0 items-start justify-between gap-3", className), ...props }));
+}
+function PackageInfoName({ className, ...props }) {
+    const { name } = usePackageInfo();
+    return (_jsxs("div", { "data-slot": "package-info-name", className: cn("flex min-w-0 items-center gap-2 text-sm font-medium", className), ...props, children: [_jsx(PackageIcon, { "aria-hidden": "true", className: "size-4 shrink-0 text-muted-foreground" }), _jsx("span", { className: "truncate", children: props.children ?? name })] }));
+}
+function PackageInfoChangeType({ children, variant = "outline", ...props }) {
+    const { changeType } = usePackageInfo();
+    const label = children ?? changeType;
+    if (!label)
+        return null;
+    return (_jsx(Badge, { "data-slot": "package-info-change-type", variant: variant, ...props, children: label }));
+}
+function PackageInfoVersion({ className, ...props }) {
+    const { version } = usePackageInfo();
+    return (_jsx("div", { "data-slot": "package-info-version", className: cn("font-mono text-xs text-muted-foreground", className), ...props, children: props.children ?? version }));
+}
+function PackageInfoDescription({ className, ...props }) {
+    return (_jsx("p", { "data-slot": "package-info-description", className: cn("text-sm text-muted-foreground", className), ...props }));
+}
+function PackageInfoContent({ className, ...props }) {
+    return _jsx("div", { "data-slot": "package-info-content", className: cn("grid gap-3", className), ...props });
+}
+function PackageInfoDependencies({ className, ...props }) {
+    return (_jsx("div", { "data-slot": "package-info-dependencies", className: cn("grid gap-1", className), ...props }));
+}
+function PackageInfoDependency({ children, className, name, version, ...props }) {
+    return (_jsxs("div", { "data-slot": "package-info-dependency", className: cn("flex min-w-0 items-center justify-between gap-3 rounded-md bg-muted/40 px-2 py-1 text-sm", className), ...props, children: [_jsx("span", { className: "truncate font-mono text-xs", children: children ?? name }), version ? (_jsx("span", { className: "shrink-0 font-mono text-xs text-muted-foreground", children: version })) : null] }));
+}
+export { PackageInfo, PackageInfoChangeType, PackageInfoContent, PackageInfoDependencies, PackageInfoDependency, PackageInfoDescription, PackageInfoHeader, PackageInfoName, PackageInfoVersion, };

package/dist/components/agentic/panel.d.ts

@@ -0,0 +1,6 @@
+import type * as React from "react";
+import { Panel as PanelPrimitive } from "@xyflow/react";
+type PanelProps = React.ComponentProps<typeof PanelPrimitive>;
+declare function Panel({ className, ...props }: PanelProps): import("react/jsx-runtime").JSX.Element;
+export { Panel };
+export type { PanelProps };

package/dist/components/agentic/panel.js

@@ -0,0 +1,7 @@
+import { jsx as _jsx } from "react/jsx-runtime";
+import { Panel as PanelPrimitive } from "@xyflow/react";
+import { cn } from "@ciridae/ui/utils";
+function Panel({ className, ...props }) {
+    return (_jsx(PanelPrimitive, { "data-slot": "panel", className: cn("rounded-lg border bg-card p-2 text-card-foreground shadow-xs", className), ...props }));
+}
+export { Panel };

package/dist/components/agentic/persona.d.ts

@@ -0,0 +1,16 @@
+import type { RiveParameters } from "@rive-app/react-webgl2";
+import type * as React from "react";
+type PersonaState = "idle" | "listening" | "thinking" | "speaking" | "asleep";
+type PersonaContainerProps = Omit<React.ComponentProps<"div">, "onLoad" | "onLoadError" | "onPause" | "onPlay" | "onReady" | "onStop">;
+type PersonaProps = PersonaContainerProps & {
+    onLoad?: RiveParameters["onLoad"];
+    onLoadError?: RiveParameters["onLoadError"];
+    onPause?: RiveParameters["onPause"];
+    onPlay?: RiveParameters["onPlay"];
+    onReady?: () => void;
+    onStop?: RiveParameters["onStop"];
+    state?: PersonaState;
+};
+declare const Persona: React.MemoExoticComponent<({ className, onLoad, onLoadError, onPause, onPlay, onReady, onStop, state, ...props }: PersonaProps) => import("react/jsx-runtime").JSX.Element>;
+export { Persona };
+export type { PersonaProps, PersonaState };

package/dist/components/agentic/persona.js

@@ -0,0 +1,116 @@
+import { jsx as _jsx } from "react/jsx-runtime";
+import { useRive, useStateMachineInput, useViewModel, useViewModelInstance, useViewModelInstanceColor, } from "@rive-app/react-webgl2";
+import { memo, useEffect, useMemo, useRef, useState } from "react";
+import { useAgenticTheme } from "@ciridae/ui/theme";
+import { cn } from "@ciridae/ui/utils";
+const HALO_SOURCE = "/assets/persona/halo-2.0.riv";
+const STATE_MACHINE = "default";
+const Persona = memo(function Persona({ className, onLoad, onLoadError, onPause, onPlay, onReady, onStop, state = "idle", ...props }) {
+    const ready = useStrictModeSafeInit();
+    const callbacks = useStableRiveCallbacks({
+        onLoad,
+        onLoadError,
+        onPause,
+        onPlay,
+        onReady,
+        onStop,
+    });
+    const [loadFailed, setLoadFailed] = useState(false);
+    const riveParams = useMemo(() => ready
+        ? {
+            autoplay: true,
+            onLoad: callbacks.onLoad,
+            onLoadError: (error) => {
+                setLoadFailed(true);
+                callbacks.onLoadError?.(error);
+            },
+            onPause: callbacks.onPause,
+            onPlay: callbacks.onPlay,
+            onRiveReady: callbacks.onReady,
+            onStop: callbacks.onStop,
+            src: HALO_SOURCE,
+            stateMachines: STATE_MACHINE,
+        }
+        : null, [callbacks, ready]);
+    const { rive, RiveComponent } = useRive(riveParams);
+    usePersonaThemeColor(rive);
+    usePersonaStateMachine(rive, state);
+    return (_jsx("div", { "data-slot": "persona", "data-state": state, className: cn("relative flex aspect-square size-48 items-center justify-center overflow-hidden rounded-full", "bg-background text-foreground", className), ...props, children: loadFailed ? _jsx(PersonaFallback, { state: state }) : _jsx(RiveComponent, { className: "size-full" }) }));
+});
+function useStrictModeSafeInit() {
+    const [ready, setReady] = useState(false);
+    useEffect(() => {
+        const id = requestAnimationFrame(() => setReady(true));
+        return () => {
+            cancelAnimationFrame(id);
+            setReady(false);
+        };
+    }, []);
+    return ready;
+}
+function useStableRiveCallbacks({ onLoad, onLoadError, onPause, onPlay, onReady, onStop, }) {
+    const callbacksRef = useRef({
+        onLoad,
+        onLoadError,
+        onPause,
+        onPlay,
+        onReady,
+        onStop,
+    });
+    useEffect(() => {
+        callbacksRef.current = {
+            onLoad,
+            onLoadError,
+            onPause,
+            onPlay,
+            onReady,
+            onStop,
+        };
+    }, [onLoad, onLoadError, onPause, onPlay, onReady, onStop]);
+    return useMemo(() => ({
+        onLoad: (loadedRive) => callbacksRef.current.onLoad?.(loadedRive),
+        onLoadError: (error) => callbacksRef.current.onLoadError?.(error),
+        onPause: (event) => callbacksRef.current.onPause?.(event),
+        onPlay: (event) => callbacksRef.current.onPlay?.(event),
+        onReady: () => callbacksRef.current.onReady?.(),
+        onStop: (event) => callbacksRef.current.onStop?.(event),
+    }), []);
+}
+function usePersonaThemeColor(rive) {
+    const theme = useAgenticTheme();
+    const viewModel = useViewModel(rive, { useDefault: true });
+    const viewModelInstance = useViewModelInstance(viewModel, {
+        rive,
+        useDefault: true,
+    });
+    const color = useViewModelInstanceColor("color", viewModelInstance);
+    useEffect(() => {
+        if (!color)
+            return;
+        if (theme === "light")
+            color.setRgb(24, 24, 27);
+        else
+            color.setRgb(255, 255, 255);
+    }, [color, theme]);
+}
+function usePersonaStateMachine(rive, state) {
+    const listeningInput = useStateMachineInput(rive, STATE_MACHINE, "listening");
+    const thinkingInput = useStateMachineInput(rive, STATE_MACHINE, "thinking");
+    const speakingInput = useStateMachineInput(rive, STATE_MACHINE, "speaking");
+    const asleepInput = useStateMachineInput(rive, STATE_MACHINE, "asleep");
+    useEffect(() => {
+        setInputValue(listeningInput, state === "listening");
+        setInputValue(thinkingInput, state === "thinking");
+        setInputValue(speakingInput, state === "speaking");
+        setInputValue(asleepInput, state === "asleep");
+    }, [asleepInput, listeningInput, speakingInput, state, thinkingInput]);
+}
+function setInputValue(input, value) {
+    if (!input)
+        return;
+    input.value = value;
+}
+function PersonaFallback({ state }) {
+    return (_jsx("div", { "data-slot": "persona-fallback", "data-state": state, className: cn("size-24 rounded-full border border-foreground bg-background", state !== "asleep" && "ring-1 ring-foreground/20") }));
+}
+export { Persona };

package/dist/components/agentic/prompt-input-action-menu.d.ts

@@ -0,0 +1,16 @@
+import type * as React from "react";
+import { DropdownMenu, DropdownMenuContent, DropdownMenuItem } from "@ciridae/ui/dropdown-menu";
+import { InputGroupButton } from "@ciridae/ui/input-group";
+type PromptInputActionMenuProps = React.ComponentProps<typeof DropdownMenu>;
+type PromptInputActionMenuTriggerProps = React.ComponentProps<typeof InputGroupButton> & {
+    label?: string;
+    tooltip?: string;
+};
+type PromptInputActionMenuContentProps = React.ComponentProps<typeof DropdownMenuContent>;
+type PromptInputActionMenuItemProps = React.ComponentProps<typeof DropdownMenuItem>;
+declare function PromptInputActionMenu(props: PromptInputActionMenuProps): import("react/jsx-runtime").JSX.Element;
+declare function PromptInputActionMenuTrigger({ children, className, label, size, tooltip, variant, ...props }: PromptInputActionMenuTriggerProps): import("react/jsx-runtime").JSX.Element;
+declare function PromptInputActionMenuContent({ className, sideOffset, ...props }: PromptInputActionMenuContentProps): import("react/jsx-runtime").JSX.Element;
+declare function PromptInputActionMenuItem({ className, ...props }: PromptInputActionMenuItemProps): import("react/jsx-runtime").JSX.Element;
+export { PromptInputActionMenu, PromptInputActionMenuContent, PromptInputActionMenuItem, PromptInputActionMenuTrigger, };
+export type { PromptInputActionMenuContentProps, PromptInputActionMenuItemProps, PromptInputActionMenuProps, PromptInputActionMenuTriggerProps, };

package/dist/components/agentic/prompt-input-action-menu.js

@@ -0,0 +1,22 @@
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import { MoreHorizontalIcon } from "lucide-react";
+import { DropdownMenu, DropdownMenuContent, DropdownMenuItem, DropdownMenuTrigger, } from "@ciridae/ui/dropdown-menu";
+import { InputGroupButton } from "@ciridae/ui/input-group";
+import { Tooltip, TooltipContent, TooltipProvider, TooltipTrigger } from "@ciridae/ui/tooltip";
+import { cn } from "@ciridae/ui/utils";
+function PromptInputActionMenu(props) {
+    return _jsx(DropdownMenu, { ...props });
+}
+function PromptInputActionMenuTrigger({ children, className, label = "Open prompt actions", size = "icon-sm", tooltip = "Prompt actions", variant = "ghost", ...props }) {
+    const trigger = (_jsx(DropdownMenuTrigger, { asChild: true, children: _jsx(InputGroupButton, { "aria-label": label, "data-slot": "prompt-input-action-menu-trigger", size: size, variant: variant, className: cn("shrink-0 text-muted-foreground", className), ...props, children: children ?? _jsx(MoreHorizontalIcon, {}) }) }));
+    if (!tooltip)
+        return trigger;
+    return (_jsx(TooltipProvider, { children: _jsxs(Tooltip, { children: [_jsx(TooltipTrigger, { asChild: true, children: trigger }), _jsx(TooltipContent, { children: tooltip })] }) }));
+}
+function PromptInputActionMenuContent({ className, sideOffset = 6, ...props }) {
+    return (_jsx(DropdownMenuContent, { "data-slot": "prompt-input-action-menu-content", sideOffset: sideOffset, className: cn("min-w-52", className), ...props }));
+}
+function PromptInputActionMenuItem({ className, ...props }) {
+    return (_jsx(DropdownMenuItem, { "data-slot": "prompt-input-action-menu-item", className: cn("gap-2", className), ...props }));
+}
+export { PromptInputActionMenu, PromptInputActionMenuContent, PromptInputActionMenuItem, PromptInputActionMenuTrigger, };

package/dist/components/agentic/prompt-input-command.d.ts

@@ -0,0 +1,18 @@
+import type * as React from "react";
+import { Command, CommandEmpty, CommandGroup, CommandInput, CommandItem, CommandList, CommandSeparator } from "@ciridae/ui/command";
+type PromptInputCommandProps = React.ComponentProps<typeof Command>;
+type PromptInputCommandInputProps = React.ComponentProps<typeof CommandInput>;
+type PromptInputCommandListProps = React.ComponentProps<typeof CommandList>;
+type PromptInputCommandEmptyProps = React.ComponentProps<typeof CommandEmpty>;
+type PromptInputCommandGroupProps = React.ComponentProps<typeof CommandGroup>;
+type PromptInputCommandItemProps = React.ComponentProps<typeof CommandItem>;
+type PromptInputCommandSeparatorProps = React.ComponentProps<typeof CommandSeparator>;
+declare function PromptInputCommand({ className, ...props }: PromptInputCommandProps): import("react/jsx-runtime").JSX.Element;
+declare function PromptInputCommandInput(props: PromptInputCommandInputProps): import("react/jsx-runtime").JSX.Element;
+declare function PromptInputCommandList({ className, ...props }: PromptInputCommandListProps): import("react/jsx-runtime").JSX.Element;
+declare function PromptInputCommandEmpty(props: PromptInputCommandEmptyProps): import("react/jsx-runtime").JSX.Element;
+declare function PromptInputCommandGroup(props: PromptInputCommandGroupProps): import("react/jsx-runtime").JSX.Element;
+declare function PromptInputCommandItem({ className, ...props }: PromptInputCommandItemProps): import("react/jsx-runtime").JSX.Element;
+declare function PromptInputCommandSeparator(props: PromptInputCommandSeparatorProps): import("react/jsx-runtime").JSX.Element;
+export { PromptInputCommand, PromptInputCommandEmpty, PromptInputCommandGroup, PromptInputCommandInput, PromptInputCommandItem, PromptInputCommandList, PromptInputCommandSeparator, };
+export type { PromptInputCommandEmptyProps, PromptInputCommandGroupProps, PromptInputCommandInputProps, PromptInputCommandItemProps, PromptInputCommandListProps, PromptInputCommandProps, PromptInputCommandSeparatorProps, };

package/dist/components/agentic/prompt-input-command.js

@@ -0,0 +1,25 @@
+import { jsx as _jsx } from "react/jsx-runtime";
+import { Command, CommandEmpty, CommandGroup, CommandInput, CommandItem, CommandList, CommandSeparator, } from "@ciridae/ui/command";
+import { cn } from "@ciridae/ui/utils";
+function PromptInputCommand({ className, ...props }) {
+    return (_jsx(Command, { "data-slot": "prompt-input-command", className: cn("rounded-md border bg-popover shadow-xs", className), ...props }));
+}
+function PromptInputCommandInput(props) {
+    return _jsx(CommandInput, { "data-slot": "prompt-input-command-input", ...props });
+}
+function PromptInputCommandList({ className, ...props }) {
+    return (_jsx(CommandList, { "data-slot": "prompt-input-command-list", className: cn("max-h-56", className), ...props }));
+}
+function PromptInputCommandEmpty(props) {
+    return _jsx(CommandEmpty, { "data-slot": "prompt-input-command-empty", ...props });
+}
+function PromptInputCommandGroup(props) {
+    return _jsx(CommandGroup, { "data-slot": "prompt-input-command-group", ...props });
+}
+function PromptInputCommandItem({ className, ...props }) {
+    return (_jsx(CommandItem, { "data-slot": "prompt-input-command-item", className: cn("gap-2", className), ...props }));
+}
+function PromptInputCommandSeparator(props) {
+    return _jsx(CommandSeparator, { "data-slot": "prompt-input-command-separator", ...props });
+}
+export { PromptInputCommand, PromptInputCommandEmpty, PromptInputCommandGroup, PromptInputCommandInput, PromptInputCommandItem, PromptInputCommandList, PromptInputCommandSeparator, };

package/dist/components/agentic/prompt-input-hover-card.d.ts

@@ -0,0 +1,10 @@
+import type * as React from "react";
+import { HoverCard, HoverCardContent, HoverCardTrigger } from "@ciridae/ui/hover-card";
+type PromptInputHoverCardProps = React.ComponentProps<typeof HoverCard>;
+type PromptInputHoverCardTriggerProps = React.ComponentProps<typeof HoverCardTrigger>;
+type PromptInputHoverCardContentProps = React.ComponentProps<typeof HoverCardContent>;
+declare function PromptInputHoverCard(props: PromptInputHoverCardProps): import("react/jsx-runtime").JSX.Element;
+declare function PromptInputHoverCardTrigger(props: PromptInputHoverCardTriggerProps): import("react/jsx-runtime").JSX.Element;
+declare function PromptInputHoverCardContent({ align, className, sideOffset, ...props }: PromptInputHoverCardContentProps): import("react/jsx-runtime").JSX.Element;
+export { PromptInputHoverCard, PromptInputHoverCardContent, PromptInputHoverCardTrigger };
+export type { PromptInputHoverCardContentProps, PromptInputHoverCardProps, PromptInputHoverCardTriggerProps, };

package/dist/components/agentic/prompt-input-hover-card.js

@@ -0,0 +1,13 @@
+import { jsx as _jsx } from "react/jsx-runtime";
+import { HoverCard, HoverCardContent, HoverCardTrigger } from "@ciridae/ui/hover-card";
+import { cn } from "@ciridae/ui/utils";
+function PromptInputHoverCard(props) {
+    return _jsx(HoverCard, { ...props });
+}
+function PromptInputHoverCardTrigger(props) {
+    return _jsx(HoverCardTrigger, { "data-slot": "prompt-input-hover-card-trigger", ...props });
+}
+function PromptInputHoverCardContent({ align = "start", className, sideOffset = 6, ...props }) {
+    return (_jsx(HoverCardContent, { "data-slot": "prompt-input-hover-card-content", align: align, sideOffset: sideOffset, className: cn("w-72 p-3", className), ...props }));
+}
+export { PromptInputHoverCard, PromptInputHoverCardContent, PromptInputHoverCardTrigger };

package/dist/components/agentic/prompt-input-select.d.ts

@@ -0,0 +1,14 @@
+import type * as React from "react";
+import { Select, SelectContent, SelectItem, SelectTrigger, SelectValue } from "@ciridae/ui/select";
+type PromptInputSelectProps = React.ComponentProps<typeof Select>;
+type PromptInputSelectTriggerProps = React.ComponentProps<typeof SelectTrigger>;
+type PromptInputSelectContentProps = React.ComponentProps<typeof SelectContent>;
+type PromptInputSelectItemProps = React.ComponentProps<typeof SelectItem>;
+type PromptInputSelectValueProps = React.ComponentProps<typeof SelectValue>;
+declare function PromptInputSelect(props: PromptInputSelectProps): import("react/jsx-runtime").JSX.Element;
+declare function PromptInputSelectTrigger({ className, size, ...props }: PromptInputSelectTriggerProps): import("react/jsx-runtime").JSX.Element;
+declare function PromptInputSelectContent({ align, className, ...props }: PromptInputSelectContentProps): import("react/jsx-runtime").JSX.Element;
+declare function PromptInputSelectItem({ className, ...props }: PromptInputSelectItemProps): import("react/jsx-runtime").JSX.Element;
+declare function PromptInputSelectValue(props: PromptInputSelectValueProps): import("react/jsx-runtime").JSX.Element;
+export { PromptInputSelect, PromptInputSelectContent, PromptInputSelectItem, PromptInputSelectTrigger, PromptInputSelectValue, };
+export type { PromptInputSelectContentProps, PromptInputSelectItemProps, PromptInputSelectProps, PromptInputSelectTriggerProps, PromptInputSelectValueProps, };

package/dist/components/agentic/prompt-input-select.js

@@ -0,0 +1,19 @@
+import { jsx as _jsx } from "react/jsx-runtime";
+import { Select, SelectContent, SelectItem, SelectTrigger, SelectValue, } from "@ciridae/ui/select";
+import { cn } from "@ciridae/ui/utils";
+function PromptInputSelect(props) {
+    return _jsx(Select, { ...props });
+}
+function PromptInputSelectTrigger({ className, size = "sm", ...props }) {
+    return (_jsx(SelectTrigger, { "data-slot": "prompt-input-select-trigger", size: size, className: cn("h-(--control-height-sm) min-w-0 border-transparent bg-transparent px-2 shadow-none hover:bg-accent hover:text-accent-foreground dark:bg-transparent dark:hover:bg-accent/50 [&_[data-slot=select-value]>svg:not([class*='size-'])]:size-3.5", className), ...props }));
+}
+function PromptInputSelectContent({ align = "start", className, ...props }) {
+    return (_jsx(SelectContent, { "data-slot": "prompt-input-select-content", align: align, className: cn("min-w-52", className), ...props }));
+}
+function PromptInputSelectItem({ className, ...props }) {
+    return (_jsx(SelectItem, { "data-slot": "prompt-input-select-item", className: cn("gap-2", className), ...props }));
+}
+function PromptInputSelectValue(props) {
+    return _jsx(SelectValue, { "data-prompt-input-slot": "prompt-input-select-value", ...props });
+}
+export { PromptInputSelect, PromptInputSelectContent, PromptInputSelectItem, PromptInputSelectTrigger, PromptInputSelectValue, };

package/dist/components/agentic/prompt-input-tabs.d.ts

@@ -0,0 +1,17 @@
+import * as React from "react";
+import { Tabs, TabsContent, TabsTrigger } from "@ciridae/ui/tabs";
+type PromptInputTabsListProps = React.ComponentProps<typeof Tabs>;
+type PromptInputTabProps = React.ComponentProps<typeof TabsTrigger>;
+type PromptInputTabLabelProps = React.ComponentProps<"span">;
+type PromptInputTabBodyProps = React.ComponentProps<typeof TabsContent>;
+type PromptInputTabItemProps = React.ComponentProps<"div">;
+declare function PromptInputTabsList({ children, className, orientation, ...props }: PromptInputTabsListProps): import("react/jsx-runtime").JSX.Element;
+declare function PromptInputTab({ className, ...props }: PromptInputTabProps): import("react/jsx-runtime").JSX.Element;
+declare namespace PromptInputTab {
+    var displayName: string;
+}
+declare function PromptInputTabLabel({ className, ...props }: PromptInputTabLabelProps): import("react/jsx-runtime").JSX.Element;
+declare function PromptInputTabBody({ className, ...props }: PromptInputTabBodyProps): import("react/jsx-runtime").JSX.Element;
+declare function PromptInputTabItem({ className, ...props }: PromptInputTabItemProps): import("react/jsx-runtime").JSX.Element;
+export { PromptInputTab, PromptInputTabBody, PromptInputTabItem, PromptInputTabLabel, PromptInputTabsList, };
+export type { PromptInputTabBodyProps, PromptInputTabItemProps, PromptInputTabLabelProps, PromptInputTabProps, PromptInputTabsListProps, };

package/dist/components/agentic/prompt-input-tabs.js

@@ -0,0 +1,45 @@
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import * as React from "react";
+import { Tabs, TabsContent, TabsList, TabsTrigger } from "@ciridae/ui/tabs";
+import { cn } from "@ciridae/ui/utils";
+function PromptInputTabsList({ children, className, orientation = "horizontal", ...props }) {
+    const childrenArray = React.Children.toArray(children);
+    const tabs = childrenArray.filter(isPromptInputTabElement);
+    const bodies = childrenArray.filter((child) => !isPromptInputTabElement(child));
+    return (_jsxs(Tabs, { "data-slot": "prompt-input-tabs-list", orientation: orientation, className: cn("gap-2 rounded-md border bg-background p-1", "data-[orientation=horizontal]:flex-col data-[orientation=vertical]:flex-row", className), ...props, children: [_jsx(TabsList, { variant: "default", className: "h-auto min-w-0 justify-start gap-1 bg-transparent p-0", children: tabs }), bodies] }));
+}
+function PromptInputTab({ className, ...props }) {
+    return (_jsx(TabsTrigger, { "data-slot": "prompt-input-tab", className: cn("h-(--control-height-sm) flex-none gap-1.5 rounded-sm px-2 text-xs", className), ...props }));
+}
+function PromptInputTabLabel({ className, ...props }) {
+    return (_jsx("span", { "data-slot": "prompt-input-tab-label", className: cn("min-w-0 truncate", className), ...props }));
+}
+function PromptInputTabBody({ className, ...props }) {
+    return (_jsx(TabsContent, { "data-slot": "prompt-input-tab-body", className: cn("mt-0 rounded-sm p-2 text-sm", className), ...props }));
+}
+function PromptInputTabItem({ className, ...props }) {
+    return (_jsx("div", { "data-slot": "prompt-input-tab-item", className: cn("flex min-w-0 items-start gap-2 rounded-sm px-2 py-1.5 text-sm text-foreground", "[&_svg]:mt-0.5 [&_svg]:size-4 [&_svg]:shrink-0 [&_svg]:text-muted-foreground", className), ...props }));
+}
+function isPromptInputTabElement(child) {
+    if (!React.isValidElement(child))
+        return false;
+    return getPromptInputTabTypeName(child.type) === "PromptInputTab";
+}
+function getPromptInputTabTypeName(type) {
+    if (typeof type === "function") {
+        if ("displayName" in type && typeof type.displayName === "string")
+            return type.displayName;
+        return type.name;
+    }
+    if (typeof type !== "object" || type === null)
+        return undefined;
+    if ("displayName" in type && typeof type.displayName === "string")
+        return type.displayName;
+    if ("type" in type)
+        return getPromptInputTabTypeName(type.type);
+    if ("render" in type)
+        return getPromptInputTabTypeName(type.render);
+    return undefined;
+}
+PromptInputTab.displayName = "PromptInputTab";
+export { PromptInputTab, PromptInputTabBody, PromptInputTabItem, PromptInputTabLabel, PromptInputTabsList, };