@cloudbase/agent-react-ui 1.0.1-alpha.32

package/src/components/ai-elements/environment-variables.tsx

@@ -0,0 +1,295 @@
+"use client";
+
+import { Badge } from "@/components/ui/badge";
+import { Button } from "@/components/ui/button";
+import { Switch } from "@/components/ui/switch";
+import { cn } from "@/lib/utils";
+import { CheckIcon, CopyIcon, EyeIcon, EyeOffIcon } from "lucide-react";
+import {
+  type ComponentProps,
+  createContext,
+  type HTMLAttributes,
+  useContext,
+  useState,
+} from "react";
+
+interface EnvironmentVariablesContextType {
+  showValues: boolean;
+  setShowValues: (show: boolean) => void;
+}
+
+const EnvironmentVariablesContext =
+  createContext<EnvironmentVariablesContextType>({
+    showValues: false,
+    setShowValues: () => undefined,
+  });
+
+export type EnvironmentVariablesProps = HTMLAttributes<HTMLDivElement> & {
+  showValues?: boolean;
+  defaultShowValues?: boolean;
+  onShowValuesChange?: (show: boolean) => void;
+};
+
+export const EnvironmentVariables = ({
+  showValues: controlledShowValues,
+  defaultShowValues = false,
+  onShowValuesChange,
+  className,
+  children,
+  ...props
+}: EnvironmentVariablesProps) => {
+  const [internalShowValues, setInternalShowValues] =
+    useState(defaultShowValues);
+  const showValues = controlledShowValues ?? internalShowValues;
+
+  const setShowValues = (show: boolean) => {
+    setInternalShowValues(show);
+    onShowValuesChange?.(show);
+  };
+
+  return (
+    <EnvironmentVariablesContext.Provider value={{ showValues, setShowValues }}>
+      <div
+        className={cn("rounded-lg border bg-background", className)}
+        {...props}
+      >
+        {children}
+      </div>
+    </EnvironmentVariablesContext.Provider>
+  );
+};
+
+export type EnvironmentVariablesHeaderProps = HTMLAttributes<HTMLDivElement>;
+
+export const EnvironmentVariablesHeader = ({
+  className,
+  children,
+  ...props
+}: EnvironmentVariablesHeaderProps) => (
+  <div
+    className={cn(
+      "flex items-center justify-between border-b px-4 py-3",
+      className
+    )}
+    {...props}
+  >
+    {children}
+  </div>
+);
+
+export type EnvironmentVariablesTitleProps = HTMLAttributes<HTMLHeadingElement>;
+
+export const EnvironmentVariablesTitle = ({
+  className,
+  children,
+  ...props
+}: EnvironmentVariablesTitleProps) => (
+  <h3 className={cn("font-medium text-sm", className)} {...props}>
+    {children ?? "Environment Variables"}
+  </h3>
+);
+
+export type EnvironmentVariablesToggleProps = ComponentProps<typeof Switch>;
+
+export const EnvironmentVariablesToggle = ({
+  className,
+  ...props
+}: EnvironmentVariablesToggleProps) => {
+  const { showValues, setShowValues } = useContext(EnvironmentVariablesContext);
+
+  return (
+    <div className={cn("flex items-center gap-2", className)}>
+      <span className="text-muted-foreground text-xs">
+        {showValues ? <EyeIcon size={14} /> : <EyeOffIcon size={14} />}
+      </span>
+      <Switch
+        aria-label="Toggle value visibility"
+        checked={showValues}
+        onCheckedChange={setShowValues}
+        {...props}
+      />
+    </div>
+  );
+};
+
+export type EnvironmentVariablesContentProps = HTMLAttributes<HTMLDivElement>;
+
+export const EnvironmentVariablesContent = ({
+  className,
+  children,
+  ...props
+}: EnvironmentVariablesContentProps) => (
+  <div className={cn("divide-y", className)} {...props}>
+    {children}
+  </div>
+);
+
+interface EnvironmentVariableContextType {
+  name: string;
+  value: string;
+}
+
+const EnvironmentVariableContext =
+  createContext<EnvironmentVariableContextType>({
+    name: "",
+    value: "",
+  });
+
+export type EnvironmentVariableProps = HTMLAttributes<HTMLDivElement> & {
+  name: string;
+  value: string;
+};
+
+export const EnvironmentVariable = ({
+  name,
+  value,
+  className,
+  children,
+  ...props
+}: EnvironmentVariableProps) => (
+  <EnvironmentVariableContext.Provider value={{ name, value }}>
+    <div
+      className={cn(
+        "flex items-center justify-between gap-4 px-4 py-3",
+        className
+      )}
+      {...props}
+    >
+      {children ?? (
+        <>
+          <div className="flex items-center gap-2">
+            <EnvironmentVariableName />
+          </div>
+          <EnvironmentVariableValue />
+        </>
+      )}
+    </div>
+  </EnvironmentVariableContext.Provider>
+);
+
+export type EnvironmentVariableGroupProps = HTMLAttributes<HTMLDivElement>;
+
+export const EnvironmentVariableGroup = ({
+  className,
+  children,
+  ...props
+}: EnvironmentVariableGroupProps) => (
+  <div className={cn("flex items-center gap-2", className)} {...props}>
+    {children}
+  </div>
+);
+
+export type EnvironmentVariableNameProps = HTMLAttributes<HTMLSpanElement>;
+
+export const EnvironmentVariableName = ({
+  className,
+  children,
+  ...props
+}: EnvironmentVariableNameProps) => {
+  const { name } = useContext(EnvironmentVariableContext);
+
+  return (
+    <span className={cn("font-mono text-sm", className)} {...props}>
+      {children ?? name}
+    </span>
+  );
+};
+
+export type EnvironmentVariableValueProps = HTMLAttributes<HTMLSpanElement>;
+
+export const EnvironmentVariableValue = ({
+  className,
+  children,
+  ...props
+}: EnvironmentVariableValueProps) => {
+  const { value } = useContext(EnvironmentVariableContext);
+  const { showValues } = useContext(EnvironmentVariablesContext);
+
+  const displayValue = showValues
+    ? value
+    : "•".repeat(Math.min(value.length, 20));
+
+  return (
+    <span
+      className={cn(
+        "font-mono text-muted-foreground text-sm",
+        !showValues && "select-none",
+        className
+      )}
+      {...props}
+    >
+      {children ?? displayValue}
+    </span>
+  );
+};
+
+export type EnvironmentVariableCopyButtonProps = ComponentProps<
+  typeof Button
+> & {
+  onCopy?: () => void;
+  onError?: (error: Error) => void;
+  timeout?: number;
+  copyFormat?: "name" | "value" | "export";
+};
+
+export const EnvironmentVariableCopyButton = ({
+  onCopy,
+  onError,
+  timeout = 2000,
+  copyFormat = "value",
+  children,
+  className,
+  ...props
+}: EnvironmentVariableCopyButtonProps) => {
+  const [isCopied, setIsCopied] = useState(false);
+  const { name, value } = useContext(EnvironmentVariableContext);
+
+  const copyToClipboard = async () => {
+    if (typeof window === "undefined" || !navigator?.clipboard?.writeText) {
+      onError?.(new Error("Clipboard API not available"));
+      return;
+    }
+
+    let textToCopy = value;
+    if (copyFormat === "name") {
+      textToCopy = name;
+    } else if (copyFormat === "export") {
+      textToCopy = `export ${name}="${value}"`;
+    }
+
+    try {
+      await navigator.clipboard.writeText(textToCopy);
+      setIsCopied(true);
+      onCopy?.();
+      setTimeout(() => setIsCopied(false), timeout);
+    } catch (error) {
+      onError?.(error as Error);
+    }
+  };
+
+  const Icon = isCopied ? CheckIcon : CopyIcon;
+
+  return (
+    <Button
+      className={cn("size-6 shrink-0", className)}
+      onClick={copyToClipboard}
+      size="icon"
+      variant="ghost"
+      {...props}
+    >
+      {children ?? <Icon size={12} />}
+    </Button>
+  );
+};
+
+export type EnvironmentVariableRequiredProps = ComponentProps<typeof Badge>;
+
+export const EnvironmentVariableRequired = ({
+  className,
+  children,
+  ...props
+}: EnvironmentVariableRequiredProps) => (
+  <Badge className={cn("text-xs", className)} variant="secondary" {...props}>
+    {children ?? "Required"}
+  </Badge>
+);

package/src/components/ai-elements/file-tree.tsx

@@ -0,0 +1,258 @@
+"use client";
+
+import {
+  Collapsible,
+  CollapsibleContent,
+  CollapsibleTrigger,
+} from "@/components/ui/collapsible";
+import { cn } from "@/lib/utils";
+import {
+  ChevronRightIcon,
+  FileIcon,
+  FolderIcon,
+  FolderOpenIcon,
+} from "lucide-react";
+import {
+  createContext,
+  type HTMLAttributes,
+  type ReactNode,
+  useContext,
+  useState,
+} from "react";
+
+interface FileTreeContextType {
+  expandedPaths: Set<string>;
+  togglePath: (path: string) => void;
+  selectedPath?: string;
+  onSelect?: (path: string) => void;
+}
+
+const FileTreeContext = createContext<FileTreeContextType>({
+  expandedPaths: new Set(),
+  togglePath: () => undefined,
+});
+
+export type FileTreeProps = HTMLAttributes<HTMLDivElement> & {
+  expanded?: Set<string>;
+  defaultExpanded?: Set<string>;
+  selectedPath?: string;
+  onSelect?: (path: string) => void;
+  onExpandedChange?: (expanded: Set<string>) => void;
+};
+
+export const FileTree = ({
+  expanded: controlledExpanded,
+  defaultExpanded = new Set(),
+  selectedPath,
+  onSelect,
+  onExpandedChange,
+  className,
+  children,
+  ...props
+}: FileTreeProps) => {
+  const [internalExpanded, setInternalExpanded] = useState(defaultExpanded);
+  const expandedPaths = controlledExpanded ?? internalExpanded;
+
+  const togglePath = (path: string) => {
+    const newExpanded = new Set(expandedPaths);
+    if (newExpanded.has(path)) {
+      newExpanded.delete(path);
+    } else {
+      newExpanded.add(path);
+    }
+    setInternalExpanded(newExpanded);
+    onExpandedChange?.(newExpanded);
+  };
+
+  return (
+    <FileTreeContext.Provider
+      value={{ expandedPaths, togglePath, selectedPath, onSelect }}
+    >
+      <div
+        className={cn(
+          "rounded-lg border bg-background font-mono text-sm",
+          className
+        )}
+        role="tree"
+        {...props}
+      >
+        <div className="p-2">{children}</div>
+      </div>
+    </FileTreeContext.Provider>
+  );
+};
+
+interface FileTreeFolderContextType {
+  path: string;
+  name: string;
+  isExpanded: boolean;
+}
+
+const FileTreeFolderContext = createContext<FileTreeFolderContextType>({
+  path: "",
+  name: "",
+  isExpanded: false,
+});
+
+export type FileTreeFolderProps = HTMLAttributes<HTMLDivElement> & {
+  path: string;
+  name: string;
+};
+
+export const FileTreeFolder = ({
+  path,
+  name,
+  className,
+  children,
+  ...props
+}: FileTreeFolderProps) => {
+  const { expandedPaths, togglePath, selectedPath, onSelect } =
+    useContext(FileTreeContext);
+  const isExpanded = expandedPaths.has(path);
+  const isSelected = selectedPath === path;
+
+  return (
+    <FileTreeFolderContext.Provider value={{ path, name, isExpanded }}>
+      <Collapsible onOpenChange={() => togglePath(path)} open={isExpanded}>
+        <div
+          className={cn("", className)}
+          role="treeitem"
+          tabIndex={0}
+          {...props}
+        >
+          <CollapsibleTrigger asChild>
+            <button
+              className={cn(
+                "flex w-full items-center gap-1 rounded px-2 py-1 text-left transition-colors hover:bg-muted/50",
+                isSelected && "bg-muted"
+              )}
+              onClick={() => onSelect?.(path)}
+              type="button"
+            >
+              <ChevronRightIcon
+                className={cn(
+                  "size-4 shrink-0 text-muted-foreground transition-transform",
+                  isExpanded && "rotate-90"
+                )}
+              />
+              <FileTreeIcon>
+                {isExpanded ? (
+                  <FolderOpenIcon className="size-4 text-blue-500" />
+                ) : (
+                  <FolderIcon className="size-4 text-blue-500" />
+                )}
+              </FileTreeIcon>
+              <FileTreeName>{name}</FileTreeName>
+            </button>
+          </CollapsibleTrigger>
+          <CollapsibleContent>
+            <div className="ml-4 border-l pl-2">{children}</div>
+          </CollapsibleContent>
+        </div>
+      </Collapsible>
+    </FileTreeFolderContext.Provider>
+  );
+};
+
+interface FileTreeFileContextType {
+  path: string;
+  name: string;
+}
+
+const FileTreeFileContext = createContext<FileTreeFileContextType>({
+  path: "",
+  name: "",
+});
+
+export type FileTreeFileProps = HTMLAttributes<HTMLDivElement> & {
+  path: string;
+  name: string;
+  icon?: ReactNode;
+};
+
+export const FileTreeFile = ({
+  path,
+  name,
+  icon,
+  className,
+  children,
+  ...props
+}: FileTreeFileProps) => {
+  const { selectedPath, onSelect } = useContext(FileTreeContext);
+  const isSelected = selectedPath === path;
+
+  return (
+    <FileTreeFileContext.Provider value={{ path, name }}>
+      <div
+        className={cn(
+          "flex cursor-pointer items-center gap-1 rounded px-2 py-1 transition-colors hover:bg-muted/50",
+          isSelected && "bg-muted",
+          className
+        )}
+        onClick={() => onSelect?.(path)}
+        onKeyDown={(e) => {
+          if (e.key === "Enter" || e.key === " ") {
+            onSelect?.(path);
+          }
+        }}
+        role="treeitem"
+        tabIndex={0}
+        {...props}
+      >
+        {children ?? (
+          <>
+            <span className="size-4" /> {/* Spacer for alignment */}
+            <FileTreeIcon>
+              {icon ?? <FileIcon className="size-4 text-muted-foreground" />}
+            </FileTreeIcon>
+            <FileTreeName>{name}</FileTreeName>
+          </>
+        )}
+      </div>
+    </FileTreeFileContext.Provider>
+  );
+};
+
+export type FileTreeIconProps = HTMLAttributes<HTMLSpanElement>;
+
+export const FileTreeIcon = ({
+  className,
+  children,
+  ...props
+}: FileTreeIconProps) => (
+  <span className={cn("shrink-0", className)} {...props}>
+    {children}
+  </span>
+);
+
+export type FileTreeNameProps = HTMLAttributes<HTMLSpanElement>;
+
+export const FileTreeName = ({
+  className,
+  children,
+  ...props
+}: FileTreeNameProps) => (
+  <span className={cn("truncate", className)} {...props}>
+    {children}
+  </span>
+);
+
+export type FileTreeActionsProps = HTMLAttributes<HTMLDivElement>;
+
+export const FileTreeActions = ({
+  className,
+  children,
+  ...props
+}: FileTreeActionsProps) => (
+  // biome-ignore lint/a11y/noNoninteractiveElementInteractions: stopPropagation required for nested interactions
+  // biome-ignore lint/a11y/useSemanticElements: fieldset doesn't fit this UI pattern
+  <div
+    className={cn("ml-auto flex items-center gap-1", className)}
+    onClick={(e) => e.stopPropagation()}
+    onKeyDown={(e) => e.stopPropagation()}
+    role="group"
+    {...props}
+  >
+    {children}
+  </div>
+);

package/src/components/ai-elements/image.tsx

@@ -0,0 +1,24 @@
+import { cn } from "@/lib/utils";
+import type { Experimental_GeneratedImage } from "ai";
+
+export type ImageProps = Experimental_GeneratedImage & {
+  className?: string;
+  alt?: string;
+};
+
+export const Image = ({
+  base64,
+  uint8Array,
+  mediaType,
+  ...props
+}: ImageProps) => (
+  <img
+    {...props}
+    alt={props.alt}
+    className={cn(
+      "h-auto max-w-full overflow-hidden rounded-md",
+      props.className
+    )}
+    src={`data:${mediaType};base64,${base64}`}
+  />
+);