@27works/chat-core 0.1.0

package/dist/contexts/index.js

@@ -0,0 +1,175 @@
+// src/contexts/ChatContext.js
+import { createContext, useCallback, useContext, useRef, useState } from "react";
+import { jsx } from "react/jsx-runtime";
+var ChatContext = createContext({
+  triggerMessage: () => {
+  },
+  registerTriggerMessage: () => {
+  },
+  shareConversation: () => {
+  },
+  shareAnswer: () => {
+  },
+  canShare: false,
+  registerShareHandlers: () => {
+  },
+  chatControls: null,
+  registerChatControls: () => {
+  },
+  hasTransitioned: false,
+  setHasTransitioned: () => {
+  },
+  shareModalOpen: false,
+  openShareModal: () => {
+  },
+  closeShareModal: () => {
+  }
+});
+var useChatContext = () => {
+  const context = useContext(ChatContext);
+  if (!context) {
+    return {
+      triggerMessage: () => {
+      },
+      registerTriggerMessage: () => {
+      },
+      shareConversation: () => {
+      },
+      shareAnswer: () => {
+      },
+      canShare: false,
+      registerShareHandlers: () => {
+      },
+      chatControls: null,
+      registerChatControls: () => {
+      },
+      hasTransitioned: false,
+      setHasTransitioned: () => {
+      },
+      shareModalOpen: false,
+      openShareModal: () => {
+      },
+      closeShareModal: () => {
+      }
+    };
+  }
+  return context;
+};
+var ChatProvider = ({ children }) => {
+  const triggerMessageRef = useRef(() => {
+  });
+  const shareHandlersRef = useRef({
+    shareConversation: () => {
+    },
+    shareAnswer: () => {
+    }
+  });
+  const [canShare, setCanShare] = useState(false);
+  const [messageCount, setMessageCount] = useState(0);
+  const [chatControls, setChatControls] = useState(null);
+  const [hasTransitioned, setHasTransitioned] = useState(false);
+  const [shareModalOpen, setShareModalOpen] = useState(false);
+  const registerTriggerMessage = (fn) => {
+    triggerMessageRef.current = fn;
+  };
+  const registerShareHandlers = useCallback((handlers) => {
+    shareHandlersRef.current = {
+      shareConversation: handlers.shareConversation,
+      shareAnswer: handlers.shareAnswer
+    };
+    setCanShare((prev) => {
+      const next = handlers.canShare || false;
+      return prev === next ? prev : next;
+    });
+    setMessageCount((prev) => {
+      const next = handlers.messageCount || 0;
+      return prev === next ? prev : next;
+    });
+  }, []);
+  const registerChatControls = useCallback((controls) => {
+    setChatControls((prev) => {
+      if (prev === controls) {
+        return prev;
+      }
+      if (prev === null && controls === null) {
+        return prev;
+      }
+      if (prev && controls && prev.firstQuestionId === controls.firstQuestionId && prev.onMakePublic === controls.onMakePublic) {
+        return prev;
+      }
+      return controls;
+    });
+  }, []);
+  const triggerMessage = (message) => triggerMessageRef.current(message);
+  const shareConversation = () => shareHandlersRef.current.shareConversation();
+  const shareAnswer = () => shareHandlersRef.current.shareAnswer();
+  const openShareModal = useCallback(() => setShareModalOpen(true), []);
+  const closeShareModal = useCallback(() => setShareModalOpen(false), []);
+  const value = {
+    triggerMessage,
+    registerTriggerMessage,
+    shareConversation,
+    shareAnswer,
+    canShare,
+    messageCount,
+    registerShareHandlers,
+    chatControls,
+    registerChatControls,
+    hasTransitioned,
+    setHasTransitioned,
+    shareModalOpen,
+    openShareModal,
+    closeShareModal
+  };
+  return /* @__PURE__ */ jsx(ChatContext.Provider, { value, children });
+};
+
+// src/contexts/ToastContext.js
+import {
+  createContext as createContext2,
+  useContext as useContext2,
+  useState as useState2,
+  useCallback as useCallback2,
+  useRef as useRef2,
+  useEffect
+} from "react";
+import { jsx as jsx2 } from "react/jsx-runtime";
+var ToastContext = createContext2({
+  showToast: () => {
+  },
+  toast: null,
+  hideToast: () => {
+  }
+});
+var useToast = () => useContext2(ToastContext);
+var ToastProvider = ({ children }) => {
+  const [toast, setToast] = useState2(null);
+  const timeoutRef = useRef2(null);
+  useEffect(() => {
+    return () => {
+      if (timeoutRef.current) {
+        clearTimeout(timeoutRef.current);
+      }
+    };
+  }, []);
+  const showToast = useCallback2((message, type = "success") => {
+    if (timeoutRef.current) {
+      clearTimeout(timeoutRef.current);
+    }
+    setToast({ message, type, id: Date.now() });
+    timeoutRef.current = setTimeout(() => {
+      setToast(null);
+      timeoutRef.current = null;
+    }, 3e3);
+  }, []);
+  const hideToast = useCallback2(() => {
+    setToast(null);
+  }, []);
+  return /* @__PURE__ */ jsx2(ToastContext.Provider, { value: { showToast, toast, hideToast }, children });
+};
+export {
+  ChatProvider,
+  ToastProvider,
+  useChatContext,
+  useToast
+};

package/dist/hooks/index.d.ts

@@ -0,0 +1,76 @@
+/**
+ * Hook for managing countdown timers.
+ * Counts down from initial seconds to 0, calling onComplete when finished.
+ */
+declare function useCountdown(initialSeconds: number, onComplete: any): {
+    seconds: any;
+    setSeconds: any;
+};
+
+/**
+ * Hook for managing chat visibility state (public/private).
+ */
+declare function useChatVisibility(chatId: any, pathname: any): {
+    visibility: any;
+    setVisibility: any;
+    toggle: any;
+};
+
+/**
+ * Hook for loading conversation messages from the API with ownership validation.
+ * Handles 403 and 404 HTTP errors with redirects.
+ */
+declare function useConversationLoad(chatId: any, options?: {}): {
+    loading: any;
+};
+
+/**
+ * Hook for managing email capture form state.
+ * Handles field state, validation, auto-population from tool input, and form reset.
+ */
+declare function useEmailForm(messages: any, options?: {}): {
+    email: any;
+    name: any;
+    phone: any;
+    message: any;
+    error: any;
+    setEmail: any;
+    setName: any;
+    setPhone: any;
+    setMessage: any;
+    setError: any;
+    isEmailValid: any;
+    isValid: any;
+    validateEmail: any;
+    reset: any;
+};
+
+/**
+ * Hook for forking conversations — waits for DB confirmation before navigating.
+ */
+declare function useForkConversation(): {
+    forkConversation: ({ questionId, sourceChatId }: {
+        questionId: any;
+        sourceChatId: any;
+    }) => Promise<void>;
+    isForking: any;
+};
+
+/**
+ * Hook for navigating to a new chat with a pending question.
+ * Pattern matches useForkConversation — waits for DB before navigating.
+ */
+declare function useNavigateWithQuestion(): {
+    navigate: (question: any) => Promise<void>;
+    isNavigating: any;
+};
+
+/**
+ * When the app is embedded in an iframe, notify the parent window whenever
+ * the internal route changes so it can keep its URL bar in sync.
+ *
+ * Parent window listens for: { type: 'route', path: '/conversation/abc123' }
+ */
+declare function useParentRouteSync(pathname: any): void;
+
+export { useChatVisibility, useConversationLoad, useCountdown, useEmailForm, useForkConversation, useNavigateWithQuestion, useParentRouteSync };

package/dist/hooks/index.js

@@ -0,0 +1,406 @@
+// src/hooks/useCountdown.js
+import { useState, useEffect, useRef } from "react";
+function useCountdown(initialSeconds = 0, onComplete) {
+  const [seconds, setSeconds] = useState(initialSeconds);
+  const onCompleteRef = useRef(onComplete);
+  useEffect(() => {
+    onCompleteRef.current = onComplete;
+  }, [onComplete]);
+  const isActive = seconds > 0;
+  useEffect(() => {
+    if (!isActive) {
+      return;
+    }
+    const timer = setInterval(() => {
+      setSeconds((prev) => {
+        const next = prev - 1;
+        if (next <= 0) {
+          onCompleteRef.current?.();
+          return 0;
+        }
+        return next;
+      });
+    }, 1e3);
+    return () => clearInterval(timer);
+  }, [isActive]);
+  return { seconds, setSeconds };
+}
+
+// src/hooks/useChatVisibility.js
+import { useState as useState3, useCallback as useCallback2, useEffect as useEffect3, useRef as useRef3 } from "react";
+
+// src/contexts/ToastContext.js
+import {
+  createContext,
+  useContext,
+  useState as useState2,
+  useCallback,
+  useRef as useRef2,
+  useEffect as useEffect2
+} from "react";
+import { jsx } from "react/jsx-runtime";
+var ToastContext = createContext({
+  showToast: () => {
+  },
+  toast: null,
+  hideToast: () => {
+  }
+});
+var useToast = () => useContext(ToastContext);
+
+// src/hooks/useChatVisibility.js
+function useChatVisibility(chatId, pathname) {
+  const [visibility, setVisibility] = useState3("private");
+  const { showToast } = useToast();
+  const hasLoadedRef = useRef3(false);
+  const isLoadingRef = useRef3(false);
+  const lastChatIdRef = useRef3(null);
+  useEffect3(() => {
+    if (chatId !== lastChatIdRef.current) {
+      hasLoadedRef.current = false;
+      isLoadingRef.current = false;
+      lastChatIdRef.current = chatId;
+    }
+  }, [chatId]);
+  useEffect3(() => {
+    if (!chatId || typeof window === "undefined") {
+      return;
+    }
+    const isConversationPage = pathname?.startsWith("/conversation/") || pathname?.startsWith("/shared/");
+    if (!isConversationPage) {
+      return;
+    }
+    if (hasLoadedRef.current || isLoadingRef.current) {
+      return;
+    }
+    const controller = new AbortController();
+    isLoadingRef.current = true;
+    const loadVisibility = (signal) => {
+      fetch(`/api/chat/share?chatId=${chatId}`, { signal }).then((res) => {
+        if (!res.ok) {
+          if (res.status === 404) {
+            isLoadingRef.current = false;
+            return;
+          }
+          throw new Error(`HTTP ${res.status}`);
+        }
+        return res.json();
+      }).then((data) => {
+        if (data && data.visibility) {
+          setVisibility(data.visibility);
+          hasLoadedRef.current = true;
+        }
+        isLoadingRef.current = false;
+      }).catch((err) => {
+        isLoadingRef.current = false;
+        if (err.name === "AbortError") {
+          return;
+        }
+        if (err.message && !err.message.includes("404")) {
+          console.error("Error loading visibility:", err);
+        }
+      });
+    };
+    loadVisibility(controller.signal);
+    return () => {
+      controller.abort();
+    };
+  }, [chatId, pathname]);
+  const toggle = useCallback2(async () => {
+    if (!chatId) {
+      showToast("Error: Chat ID not found", "error");
+      return;
+    }
+    const newVisibility = visibility === "public" ? "private" : "public";
+    try {
+      const response = await fetch("/api/chat/share", {
+        method: "POST",
+        headers: { "Content-Type": "application/json" },
+        body: JSON.stringify({ chatId, visibility: newVisibility })
+      });
+      if (!response.ok) {
+        const error = await response.json();
+        throw new Error(error.error || "Failed to update visibility");
+      }
+      setVisibility(newVisibility);
+      if (newVisibility === "public") {
+        const shareUrl = `${window.location.origin}/shared/${chatId}`;
+        await navigator.clipboard.writeText(shareUrl);
+        showToast("Now shareable. Link copied to clipboard");
+      } else {
+        showToast("Now private. Only you can see this");
+      }
+    } catch (err) {
+      console.error("Privacy toggle error:", err);
+      showToast(err.message || "Failed to update visibility", "error");
+    }
+  }, [chatId, visibility, showToast]);
+  return { visibility, setVisibility, toggle };
+}
+
+// src/hooks/useConversationLoad.js
+import { useState as useState4, useEffect as useEffect4, useRef as useRef4 } from "react";
+import { useRouter } from "next/navigation";
+function useConversationLoad(chatId, options = {}) {
+  const {
+    shouldLoad = true,
+    skipIfLoaded = false,
+    onSuccess,
+    onError
+  } = options;
+  const router = useRouter();
+  const [loading, setLoading] = useState4(false);
+  const hasLoadedRef = useRef4(false);
+  const onSuccessRef = useRef4(onSuccess);
+  const onErrorRef = useRef4(onError);
+  useEffect4(() => {
+    onSuccessRef.current = onSuccess;
+    onErrorRef.current = onError;
+  }, [onSuccess, onError]);
+  useEffect4(() => {
+    hasLoadedRef.current = false;
+  }, [chatId]);
+  useEffect4(() => {
+    if (!shouldLoad || !chatId) {
+      return;
+    }
+    if (skipIfLoaded && hasLoadedRef.current) {
+      setLoading(false);
+      return;
+    }
+    const controller = new AbortController();
+    const { signal } = controller;
+    const loadConversation = async () => {
+      setLoading(true);
+      try {
+        const response = await fetch(`/api/chat/load/${chatId}`, {
+          signal: controller.signal
+        });
+        if (response.status === 403) {
+          const reason = "This conversation is private and you do not have access.";
+          const err = new Error(reason);
+          if (!signal.aborted) {
+            onErrorRef.current?.(err);
+          }
+          router.replace("/?reason=private");
+          return;
+        }
+        if (response.status === 404) {
+          const reason = "Conversation not found.";
+          const err = new Error(reason);
+          if (!signal.aborted) {
+            onErrorRef.current?.(err);
+          }
+          router.replace("/?reason=not_found");
+          return;
+        }
+        if (!response.ok) {
+          const reason = `Failed to load conversation (HTTP ${response.status})`;
+          const err = new Error(reason);
+          if (!signal.aborted) {
+            onErrorRef.current?.(err);
+          }
+          return;
+        }
+        const data = await response.json();
+        if (!data || typeof data !== "object") {
+          const err = new Error("Invalid response format from server");
+          if (!signal.aborted) {
+            onErrorRef.current?.(err);
+          }
+          return;
+        }
+        hasLoadedRef.current = true;
+        if (!signal.aborted && Array.isArray(data.messages)) {
+          onSuccessRef.current?.(data.messages);
+        }
+      } catch (err) {
+        if (err.name === "AbortError") {
+          return;
+        }
+        const errorObj = err instanceof Error ? err : new Error(String(err));
+        console.error(`Error loading conversation ${chatId}:`, errorObj);
+        if (!signal.aborted) {
+          onErrorRef.current?.(errorObj);
+        }
+      } finally {
+        if (!signal.aborted) {
+          setLoading(false);
+        }
+      }
+    };
+    loadConversation();
+    return () => {
+      controller.abort();
+    };
+  }, [chatId, shouldLoad, skipIfLoaded, router]);
+  return { loading };
+}
+
+// src/hooks/useEmailForm.js
+import { useState as useState5, useMemo, useCallback as useCallback3 } from "react";
+var EMAIL_REGEX = /^(?:[a-zA-Z0-9_'^&+%`{}~|-]+(?:\.[a-zA-Z0-9_'^&+%`{}~|-]+)*)@(?:(?:[a-zA-Z0-9](?:[a-zA-Z0-9-]{0,61}[a-zA-Z0-9])?\.)*[a-zA-Z0-9](?:[a-zA-Z0-9-]{0,61}[a-zA-Z0-9])?)$/;
+function useEmailForm(messages, options = {}) {
+  const { toolName = "emailCapture" } = options;
+  const [email, setEmail] = useState5("");
+  const [name, setName] = useState5("");
+  const [phone, setPhone] = useState5("");
+  const [message, setMessage] = useState5("");
+  const [error, setError] = useState5("");
+  const autoMessage = useMemo(() => {
+    if (!Array.isArray(messages) || messages.length === 0) {
+      return "";
+    }
+    for (const msg of messages) {
+      if (!msg.parts || !Array.isArray(msg.parts)) {
+        continue;
+      }
+      for (const part of msg.parts) {
+        if (part.type && part.type.includes(toolName) && part.input?.summary) {
+          return part.input.summary;
+        }
+      }
+    }
+    return "";
+  }, [messages, toolName]);
+  const isEmailValid = useCallback3((value) => {
+    if (!value || !value.trim()) {
+      return false;
+    }
+    return EMAIL_REGEX.test(value.trim());
+  }, []);
+  const isValid = useCallback3(() => {
+    return isEmailValid(email) && name.trim().length > 0;
+  }, [email, name, isEmailValid]);
+  const reset = useCallback3(() => {
+    setEmail("");
+    setName("");
+    setPhone("");
+    setMessage("");
+    setError("");
+  }, []);
+  const validateEmail = useCallback3(
+    (value) => {
+      if (!isEmailValid(value)) {
+        setError("Please enter a valid email address");
+        return false;
+      }
+      setError("");
+      return true;
+    },
+    [isEmailValid]
+  );
+  return {
+    email,
+    name,
+    phone,
+    message: message || autoMessage,
+    error,
+    setEmail,
+    setName,
+    setPhone,
+    setMessage,
+    setError,
+    isEmailValid,
+    isValid,
+    validateEmail,
+    reset
+  };
+}
+
+// src/hooks/useForkConversation.js
+import { useState as useState6 } from "react";
+import { useRouter as useRouter2 } from "next/navigation";
+function useForkConversation() {
+  const router = useRouter2();
+  const [isForking, setIsForking] = useState6(false);
+  const { showToast } = useToast();
+  const forkConversation = async ({ questionId, sourceChatId }) => {
+    if (isForking) {
+      return;
+    }
+    setIsForking(true);
+    showToast("Creating your copy...");
+    try {
+      const res = await fetch("/api/chat/fork", {
+        method: "POST",
+        headers: { "Content-Type": "application/json" },
+        body: JSON.stringify({ questionId, sourceChatId })
+      });
+      if (!res.ok) {
+        const error = await res.json().catch(() => ({}));
+        throw new Error(error.error || "Failed to create copy");
+      }
+      const { chatId } = await res.json();
+      router.push(`/conversation/${chatId}`);
+    } catch (err) {
+      console.error("Fork error:", err);
+      showToast(
+        err.message || "Failed to create copy. Please try again.",
+        "error"
+      );
+      setIsForking(false);
+    }
+  };
+  return { forkConversation, isForking };
+}
+
+// src/hooks/useNavigateWithQuestion.js
+import { useState as useState7 } from "react";
+import { useRouter as useRouter3 } from "next/navigation";
+function useNavigateWithQuestion() {
+  const router = useRouter3();
+  const [isNavigating, setIsNavigating] = useState7(false);
+  const { showToast } = useToast();
+  const navigate = async (question) => {
+    if (isNavigating) {
+      return;
+    }
+    setIsNavigating(true);
+    showToast("Starting new conversation...");
+    try {
+      const res = await fetch("/api/chat/create", {
+        method: "POST",
+        headers: { "Content-Type": "application/json" },
+        body: JSON.stringify({ question })
+      });
+      if (!res.ok) {
+        const error = await res.json().catch(() => ({}));
+        throw new Error(error.error || "Failed to create conversation");
+      }
+      const { chatId } = await res.json();
+      router.push(`/conversation/${chatId}`);
+    } catch (err) {
+      console.error("Navigate with question error:", err);
+      showToast(
+        err.message || "Failed to start conversation. Please try again.",
+        "error"
+      );
+      setIsNavigating(false);
+    }
+  };
+  return { navigate, isNavigating };
+}
+
+// src/hooks/useParentRouteSync.js
+import { useEffect as useEffect5 } from "react";
+function useParentRouteSync(pathname) {
+  useEffect5(() => {
+    if (typeof window === "undefined") {
+      return;
+    }
+    if (window.parent === window) {
+      return;
+    }
+    window.parent.postMessage({ type: "route", path: pathname }, "*");
+  }, [pathname]);
+}
+export {
+  useChatVisibility,
+  useConversationLoad,
+  useCountdown,
+  useEmailForm,
+  useForkConversation,
+  useNavigateWithQuestion,
+  useParentRouteSync
+};