@truefoundry/trueforge-ui 0.0.0 → 0.1.0-rc.0

package/dist/chunk-UHGSHDBM.js

@@ -0,0 +1,633 @@
+import {
+  ThemeContext,
+  cn
+} from "./chunk-UBOFEI77.js";
+
+// src/icons/Icon.tsx
+import { createElement, isValidElement, useContext } from "react";
+
+// src/icons/IconRegistry.tsx
+import {
+  Archive,
+  ArrowDown,
+  ArrowLeft,
+  ArrowUp,
+  Bot,
+  Box,
+  Brain,
+  Check,
+  ChevronDown,
+  ChevronLeft,
+  ChevronRight,
+  CircleAlert,
+  CircleCheck,
+  CircleX,
+  Clock,
+  Code2,
+  Copy,
+  Cpu,
+  Download,
+  Ellipsis,
+  ExternalLink,
+  File,
+  Github,
+  History,
+  Info,
+  Lightbulb,
+  ListChecks,
+  ListFilter,
+  ListOrdered,
+  Loader2,
+  Lock,
+  LogOut,
+  Maximize2,
+  Menu,
+  Minimize2,
+  Moon,
+  PanelLeftClose,
+  PanelLeftOpen,
+  Paperclip,
+  Pencil,
+  Play,
+  Plug,
+  Plus,
+  RotateCw,
+  Save,
+  Search,
+  Settings,
+  Sparkle,
+  SquarePen,
+  Sun,
+  Terminal,
+  Trash2,
+  Wrench,
+  X
+} from "lucide-react";
+import { jsx, jsxs } from "react/jsx-runtime";
+function Broom({ size = 24, ...props }) {
+  return /* @__PURE__ */ jsxs(
+    "svg",
+    {
+      xmlns: "http://www.w3.org/2000/svg",
+      width: size,
+      height: size,
+      viewBox: "0 0 24 24",
+      fill: "none",
+      stroke: "currentColor",
+      strokeWidth: "2",
+      strokeLinecap: "round",
+      strokeLinejoin: "round",
+      ...props,
+      children: [
+        /* @__PURE__ */ jsx("path", { d: "M13.5 10.5 22 2" }),
+        /* @__PURE__ */ jsx("path", { d: "M14.734 13.841a2 2 0 00-.314-2.42L12.58 9.58a2 2 0 00-2.421-.314l-7.657 4.461A1 1 0 002.3 15.3l6.403 6.403a1 1 0 001.571-.204z" }),
+        /* @__PURE__ */ jsx("path", { d: "m5 18 2-2" }),
+        /* @__PURE__ */ jsx("path", { d: "m7.699 10.7 5.602 5.601" })
+      ]
+    }
+  );
+}
+var registry = /* @__PURE__ */ new Map();
+function registerIcons(icons) {
+  for (const [name, icon] of Object.entries(icons)) {
+    registry.set(name, icon);
+  }
+}
+function resolveIconName(icon) {
+  if (typeof icon === "string") return icon;
+  return icon[icon.length - 1] ?? "";
+}
+var defaults = {
+  paperclip: Paperclip,
+  "arrow-up": ArrowUp,
+  "arrow-down": ArrowDown,
+  "arrow-left": ArrowLeft,
+  xmark: X,
+  check: Check,
+  pencil: Pencil,
+  play: Play,
+  "square-pen": SquarePen,
+  "rotate-right": RotateCw,
+  broom: Broom,
+  ellipsis: Ellipsis,
+  trash: Trash2,
+  "box-archive": Archive,
+  "clock-rotate-left": History,
+  "circle-exclamation": CircleAlert,
+  "chevron-down": ChevronDown,
+  "chevron-left": ChevronLeft,
+  "chevron-right": ChevronRight,
+  loader: Loader2,
+  file: File,
+  clone: Copy,
+  copy: Copy,
+  bars: Menu,
+  "panel-left-close": PanelLeftClose,
+  "panel-left-open": PanelLeftOpen,
+  plus: Plus,
+  sun: Sun,
+  moon: Moon,
+  settings: Settings,
+  "log-out": LogOut,
+  search: Search,
+  clock: Clock,
+  "circle-check": CircleCheck,
+  "circle-xmark": CircleX,
+  "oauth-success": CircleCheck,
+  "oauth-error": CircleX,
+  "oauth-loading": Loader2,
+  "welcome-sparkle": Sparkle,
+  robot: Bot,
+  funnel: ListFilter,
+  plug: Plug,
+  "list-check": ListChecks,
+  lock: Lock,
+  lightbulb: Lightbulb,
+  wrench: Wrench,
+  cpu: Cpu,
+  cube: Box,
+  "list-ol": ListOrdered,
+  download: Download,
+  save: Save,
+  brain: Brain,
+  terminal: Terminal,
+  code: Code2,
+  expand: Maximize2,
+  "expand-alt": Maximize2,
+  compress: Minimize2,
+  "external-link": ExternalLink,
+  github: Github,
+  info: Info
+};
+for (const [name, icon] of Object.entries(defaults)) {
+  registry.set(name, icon);
+}
+function lookupIcon(name, themeIcons) {
+  if (themeIcons && name in themeIcons) {
+    return themeIcons[name];
+  }
+  return registry.get(name);
+}
+
+// src/icons/Icon.tsx
+import { Fragment, jsx as jsx2 } from "react/jsx-runtime";
+function isComponent(entry) {
+  if (typeof entry === "function") return true;
+  return typeof entry === "object" && entry !== null && !isValidElement(entry) && !Array.isArray(entry) && "$$typeof" in entry;
+}
+function renderEntry(entry, props) {
+  if (isComponent(entry)) {
+    const { size, className, style, ...aria } = props;
+    return createElement(entry, {
+      className: cn("inline-block shrink-0", className),
+      style,
+      size,
+      width: size,
+      height: size,
+      "aria-hidden": aria["aria-label"] ? void 0 : aria["aria-hidden"] ?? true,
+      "aria-label": aria["aria-label"],
+      ...aria["data-testid"] === void 0 ? {} : { "data-testid": aria["data-testid"] },
+      role: aria["aria-label"] ? "img" : void 0
+    });
+  }
+  return entry;
+}
+function Icon({ name, className, style, size = "1em", ...aria }) {
+  const themeIcons = useContext(ThemeContext)?.icons;
+  const resolved = resolveIconName(name);
+  const entry = lookupIcon(resolved, themeIcons);
+  if (!entry) return null;
+  return /* @__PURE__ */ jsx2(Fragment, { children: renderEntry(entry, { className, style, size, ...aria }) });
+}
+
+// src/atoms/primitives/Spinner.tsx
+import "react";
+import { jsx as jsx3 } from "react/jsx-runtime";
+function Spinner({ size = 16, className, ...props }) {
+  const r = size / 2 * 0.75;
+  const cx = size / 2;
+  const circumference = 2 * Math.PI * r;
+  return /* @__PURE__ */ jsx3(
+    "svg",
+    {
+      role: "status",
+      "aria-label": "Loading",
+      width: size,
+      height: size,
+      viewBox: `0 0 ${size} ${size}`,
+      fill: "none",
+      className: cn("animate-spin", className),
+      ...props,
+      children: /* @__PURE__ */ jsx3(
+        "circle",
+        {
+          cx,
+          cy: cx,
+          r,
+          stroke: "currentColor",
+          strokeWidth: 2,
+          strokeLinecap: "round",
+          strokeDasharray: `${circumference * 0.75} ${circumference * 0.25}`,
+          opacity: 0.8
+        }
+      )
+    }
+  );
+}
+
+// src/atoms/lib/buttonClasses.ts
+var variantClasses = {
+  default: "bg-primary-button-bg text-primary-button-text shadow hover:bg-primary-button-hover",
+  secondary: "border border-input-border bg-secondary-button-bg text-secondary-button-text shadow-sm hover:bg-secondary-button-hover",
+  ghost: "bg-ghost-button-bg text-ghost-button-text hover:bg-ghost-button-hover",
+  destructive: "bg-failure-bg text-failure-text shadow-sm hover:bg-failure-bg/90",
+  outline: "border border-input-border bg-secondary-button-bg text-secondary-button-text shadow-sm hover:bg-secondary-button-hover"
+};
+var sizeClasses = {
+  default: "h-9 px-4 py-2 text-sm",
+  sm: "h-8 rounded-md px-3 text-xs",
+  lg: "h-10 rounded-md px-8 text-base",
+  icon: "h-8 w-8"
+};
+var baseClasses = "inline-flex cursor-pointer items-center justify-center gap-2 whitespace-nowrap rounded-md font-medium transition-colors focus-visible:outline-none focus-visible:ring-1 focus-visible:ring-focus-ring disabled:cursor-not-allowed disabled:opacity-50";
+function auiButtonClass({
+  variant = "default",
+  size = "default",
+  className
+} = {}) {
+  return cn(baseClasses, variantClasses[variant], sizeClasses[size], className);
+}
+
+// src/server/ServerContext.tsx
+import { createContext, useCallback, useContext as useContext2, useEffect, useMemo, useRef, useState } from "react";
+import { jsx as jsx4 } from "react/jsx-runtime";
+var ServerContext = createContext(null);
+var ServerCapabilitiesContext = createContext(null);
+function ServerProvider({ server, children }) {
+  const [capabilities, setCapabilities] = useState(null);
+  const cancelActiveRequestRef = useRef(null);
+  const refreshCapabilities = useCallback(() => {
+    cancelActiveRequestRef.current?.();
+    let cancelled = false;
+    cancelActiveRequestRef.current = () => {
+      cancelled = true;
+    };
+    void server.getCapabilities().then((response) => {
+      if (!cancelled) setCapabilities(response.data);
+    }).catch(() => {
+    });
+  }, [server]);
+  useEffect(() => {
+    setCapabilities(null);
+    refreshCapabilities();
+    return () => {
+      cancelActiveRequestRef.current?.();
+    };
+  }, [refreshCapabilities]);
+  const capabilitiesValue = useMemo(
+    () => ({ capabilities, refresh: refreshCapabilities }),
+    [capabilities, refreshCapabilities]
+  );
+  return /* @__PURE__ */ jsx4(ServerContext.Provider, { value: server, children: /* @__PURE__ */ jsx4(ServerCapabilitiesContext.Provider, { value: capabilitiesValue, children }) });
+}
+function useServer() {
+  const server = useContext2(ServerContext);
+  if (server == null) {
+    throw new Error("useServer must be used within a ServerProvider.");
+  }
+  return server;
+}
+function useOptionalServer() {
+  return useContext2(ServerContext);
+}
+function useServerCapabilities() {
+  return useContext2(ServerCapabilitiesContext)?.capabilities ?? null;
+}
+function useOptionalRefreshServerCapabilities() {
+  return useContext2(ServerCapabilitiesContext)?.refresh ?? null;
+}
+function useCatalogServer() {
+  const server = useServer();
+  if (server.catalog == null) {
+    throw new Error("useCatalogServer requires AgentUIServer.catalog. Pass catalog to createTrueFoundryServer.");
+  }
+  return server.catalog;
+}
+function useOptionalCatalogServer() {
+  return useOptionalServer()?.catalog ?? null;
+}
+
+// src/server/ShellModeContext.tsx
+import { createContext as createContext2, useCallback as useCallback2, useContext as useContext3, useEffect as useEffect2, useMemo as useMemo2, useRef as useRef2, useState as useState2 } from "react";
+import { jsx as jsx5 } from "react/jsx-runtime";
+var DEFAULT_AGENT_CONFIG = {
+  mode: "AgentLibraryWithComposer"
+};
+var ShellModeContext = createContext2(null);
+var FALLBACK_MUTABLE_SPEC = {
+  model: { name: "openai-main/gpt-4.1" }
+};
+function mutableSeedFromConfig(config) {
+  if (config.mode === "AgentComposer" || config.mode === "AgentLibraryWithComposer") {
+    return config.defaultAgentSpec ?? FALLBACK_MUTABLE_SPEC;
+  }
+  return FALLBACK_MUTABLE_SPEC;
+}
+function initialMode(config, mutableSeed) {
+  switch (config.mode) {
+    case "SingleAgent":
+      return {
+        status: "active",
+        isMutable: false,
+        agentId: config.name,
+        agentName: config.name,
+        locked: true
+      };
+    case "AgentLibrary":
+      return { status: "idle" };
+    case "AgentComposer":
+    case "AgentLibraryWithComposer":
+      return {
+        status: "active",
+        isMutable: true,
+        agentSpec: mutableSeed,
+        locked: false
+      };
+  }
+}
+function libraryAgentId(agent) {
+  return agent.agentId ?? agent.name;
+}
+function ShellModeProvider({
+  agentConfig = DEFAULT_AGENT_CONFIG,
+  initialSettingsOpen = false,
+  children
+}) {
+  const capabilities = useServerCapabilities();
+  const refreshCapabilities = useOptionalRefreshServerCapabilities();
+  const mutableSeedRef = useRef2(mutableSeedFromConfig(agentConfig));
+  if ((agentConfig.mode === "AgentComposer" || agentConfig.mode === "AgentLibraryWithComposer") && agentConfig.defaultAgentSpec != null) {
+    mutableSeedRef.current = agentConfig.defaultAgentSpec;
+  }
+  const mutableSeed = mutableSeedRef.current;
+  const isLibraryEnabled = agentConfig.mode === "AgentLibrary" || agentConfig.mode === "AgentLibraryWithComposer";
+  const isComposerEnabled = agentConfig.mode === "AgentComposer" || agentConfig.mode === "AgentLibraryWithComposer";
+  const isNewChatEnabled = agentConfig.mode !== "AgentLibrary";
+  const locked = agentConfig.mode === "SingleAgent";
+  const [mode, setMode] = useState2(() => initialMode(agentConfig, mutableSeed));
+  const [mutableEpoch, setMutableEpoch] = useState2(0);
+  const [clearEpoch, setClearEpoch] = useState2(0);
+  const [agentsListEpoch, setAgentsListEpoch] = useState2(0);
+  const [settingsOpenState, setSettingsOpenState] = useState2(initialSettingsOpen);
+  const [historyAgentFilter, setHistoryAgentFilter] = useState2(null);
+  const [pendingSessionId, setPendingSessionId] = useState2(void 0);
+  const settingsEnabled = capabilities?.settings?.enabled !== false;
+  const settingsOpen = settingsEnabled && settingsOpenState;
+  const setSettingsOpen = useCallback2(
+    (open) => {
+      setSettingsOpenState(settingsEnabled && open);
+    },
+    [settingsEnabled]
+  );
+  useEffect2(() => {
+    if (!settingsEnabled) {
+      setSettingsOpenState(false);
+    }
+  }, [settingsEnabled]);
+  const invalidateAgentsList = useCallback2(() => {
+    setAgentsListEpoch((n) => n + 1);
+  }, []);
+  const lockedAgentName = agentConfig.mode === "SingleAgent" ? agentConfig.name : "";
+  const effectiveMode = useMemo2(() => {
+    if (!locked) return mode;
+    return {
+      status: "active",
+      isMutable: false,
+      agentId: lockedAgentName,
+      agentName: lockedAgentName,
+      locked: true
+    };
+  }, [locked, lockedAgentName, mode]);
+  const listSessionsAgentId = useMemo2(() => {
+    if (locked) return lockedAgentName;
+    if (!isLibraryEnabled) return void 0;
+    return historyAgentFilter ?? void 0;
+  }, [locked, lockedAgentName, isLibraryEnabled, historyAgentFilter]);
+  const bumpEpoch = useCallback2((isMutable) => {
+    if (isMutable) setMutableEpoch((n) => n + 1);
+    else setClearEpoch((n) => n + 1);
+  }, []);
+  const selectLibraryAgent = useCallback2(
+    (req) => {
+      if (req.isMutable) {
+        if (!isComposerEnabled) return;
+        setSettingsOpen(false);
+        setPendingSessionId(void 0);
+        setMode({
+          status: "active",
+          isMutable: true,
+          agentId: req.agentId,
+          agentName: req.agentName,
+          agentSpec: req.agentSpec ?? mutableSeedRef.current,
+          locked: false
+        });
+        bumpEpoch(true);
+        return;
+      }
+      if (!isLibraryEnabled) return;
+      const agentName = req.agentName ?? req.agentId;
+      if (agentName == null) return;
+      setSettingsOpen(false);
+      setPendingSessionId(void 0);
+      setMode({
+        status: "active",
+        isMutable: false,
+        agentId: req.agentId ?? agentName,
+        agentName,
+        locked: false
+      });
+      bumpEpoch(false);
+    },
+    [isComposerEnabled, isLibraryEnabled, bumpEpoch, setSettingsOpen]
+  );
+  const bindMutableAgent = useCallback2(
+    (req) => {
+      if (!isComposerEnabled) return;
+      setMode((prev) => {
+        if (prev.status !== "active" || !prev.isMutable) return prev;
+        return {
+          status: "active",
+          isMutable: true,
+          agentId: req.agentId,
+          agentName: req.agentName,
+          agentSpec: req.agentSpec,
+          locked: false
+        };
+      });
+    },
+    [isComposerEnabled]
+  );
+  const selectAgent = useCallback2(
+    (name) => {
+      selectLibraryAgent({ isMutable: false, agentId: name, agentName: name });
+    },
+    [selectLibraryAgent]
+  );
+  const openDraft = useCallback2(() => {
+    if (!isComposerEnabled) return;
+    refreshCapabilities?.();
+    selectLibraryAgent({ isMutable: true, agentSpec: mutableSeedRef.current });
+  }, [isComposerEnabled, refreshCapabilities, selectLibraryAgent]);
+  const openHistorySession = useCallback2(
+    ({
+      sessionId,
+      agentName,
+      isMutable: isMutableOpt
+    }) => {
+      setSettingsOpen(false);
+      setPendingSessionId(sessionId);
+      const isMutable = isMutableOpt ?? agentName == null;
+      if (isMutable) {
+        if (!isComposerEnabled) return;
+        setMode({
+          status: "active",
+          isMutable: true,
+          agentSpec: mutableSeedRef.current,
+          locked: false
+        });
+        bumpEpoch(true);
+        return;
+      }
+      if (locked) {
+        if (agentName == null || lockedAgentName !== agentName) return;
+      } else if (!isLibraryEnabled) {
+        return;
+      }
+      setMode({
+        status: "active",
+        isMutable: false,
+        locked: false,
+        ...agentName != null ? { agentId: agentName, agentName } : {}
+      });
+      bumpEpoch(false);
+    },
+    [isLibraryEnabled, isComposerEnabled, locked, lockedAgentName, bumpEpoch, setSettingsOpen]
+  );
+  const clearChat = useCallback2(() => {
+    if (effectiveMode.status === "idle") return;
+    setPendingSessionId(void 0);
+    if (effectiveMode.isMutable) {
+      setMode({
+        status: "active",
+        isMutable: true,
+        agentId: effectiveMode.agentId,
+        agentName: effectiveMode.agentName,
+        agentSpec: effectiveMode.agentSpec ?? mutableSeedRef.current,
+        locked: false
+      });
+      bumpEpoch(true);
+      return;
+    }
+    bumpEpoch(false);
+  }, [effectiveMode, bumpEpoch]);
+  const runtimeKey = useMemo2(() => {
+    if (effectiveMode.status === "idle") return "idle";
+    if (effectiveMode.isMutable) {
+      return `mut:${pendingSessionId ?? ""}:${mutableEpoch}`;
+    }
+    const id = effectiveMode.agentId ?? effectiveMode.agentName ?? "";
+    return `immut:${id}:${pendingSessionId ?? ""}:${clearEpoch}`;
+  }, [effectiveMode, mutableEpoch, clearEpoch, pendingSessionId]);
+  const value = useMemo2(
+    () => ({
+      mode: effectiveMode,
+      agentConfigMode: agentConfig.mode,
+      isLibraryEnabled,
+      isComposerEnabled,
+      isNewChatEnabled,
+      settingsOpen,
+      setSettingsOpen,
+      selectLibraryAgent,
+      bindMutableAgent,
+      selectAgent,
+      openDraft,
+      openHistorySession,
+      clearChat,
+      runtimeKey,
+      historyAgentFilter,
+      setHistoryAgentFilter,
+      listSessionsAgentId,
+      pendingSessionId,
+      agentsListEpoch,
+      invalidateAgentsList
+    }),
+    [
+      effectiveMode,
+      agentConfig.mode,
+      isLibraryEnabled,
+      isComposerEnabled,
+      isNewChatEnabled,
+      settingsOpen,
+      setSettingsOpen,
+      selectLibraryAgent,
+      bindMutableAgent,
+      selectAgent,
+      openDraft,
+      openHistorySession,
+      clearChat,
+      runtimeKey,
+      historyAgentFilter,
+      listSessionsAgentId,
+      pendingSessionId,
+      agentsListEpoch,
+      invalidateAgentsList
+    ]
+  );
+  return /* @__PURE__ */ jsx5(ShellModeContext.Provider, { value, children });
+}
+function useShellMode() {
+  const ctx = useContext3(ShellModeContext);
+  if (ctx == null) {
+    throw new Error("useShellMode must be used within a ShellModeProvider.");
+  }
+  return ctx;
+}
+function useOptionalShellMode() {
+  return useContext3(ShellModeContext);
+}
+function shellIsMutable(mode) {
+  return mode.status === "active" && mode.isMutable;
+}
+
+// src/atoms/lib/CompactLayoutContext.tsx
+import { createContext as createContext3, useContext as useContext4 } from "react";
+import { jsx as jsx6 } from "react/jsx-runtime";
+var CompactLayoutContext = createContext3(false);
+function CompactLayoutProvider({ children }) {
+  return /* @__PURE__ */ jsx6(CompactLayoutContext.Provider, { value: true, children });
+}
+function useCompactLayout() {
+  return useContext4(CompactLayoutContext);
+}
+
+export {
+  registerIcons,
+  Icon,
+  Spinner,
+  auiButtonClass,
+  ServerProvider,
+  useServer,
+  useOptionalServer,
+  useServerCapabilities,
+  useCatalogServer,
+  useOptionalCatalogServer,
+  DEFAULT_AGENT_CONFIG,
+  libraryAgentId,
+  ShellModeProvider,
+  useShellMode,
+  useOptionalShellMode,
+  shellIsMutable,
+  CompactLayoutProvider,
+  useCompactLayout
+};
+//# sourceMappingURL=chunk-UHGSHDBM.js.map