refactor: get rid of unused stuff from old project

viewer/src/api/urdfApi.ts

@@ -1,103 +0,0 @@
-
-import { supabase } from "@/integrations/supabase/client";
-import { Database } from "@/integrations/supabase/types";
-import { ContentItem, Category } from "@/lib/types";
-
-// Type for Urdf table row
-type UrdfRow = Database["public"]["Tables"]["urdf"]["Row"];
-
-// Convert a Supabase URDF row to our ContentItem format
-export const mapUrdfToContentItem = (urdf: UrdfRow): ContentItem => {
-  // Convert tags to categories
-  const categories = urdf.tags || [];
-
-  return {
-    id: urdf.id,
-    title: urdf.name,
-    imageUrl: urdf.image_uri || "/placeholder.svg", // This now contains the storage path or full URL
-    description: urdf.summary || undefined,
-    categories,
-    urdfPath: urdf.urdf_uri || "",
-  };
-};
-
-// Get all URDFs
-export const getUrdfs = async (): Promise<ContentItem[]> => {
-  console.log("Fetching URDFs");
-  const { data, error } = await supabase.from("urdf").select("*").order("name");
-  console.log("URDFs fetched", data);
-
-  if (error) {
-    console.error("Error fetching URDFs:", error);
-    throw error;
-  }
-
-  return (data || []).map(mapUrdfToContentItem);
-};
-
-// Get unique categories from all URDFs
-export const getCategories = async (): Promise<Category[]> => {
-  const { data, error } = await supabase.from("urdf").select("tags");
-
-  if (error) {
-    console.error("Error fetching categories:", error);
-    throw error;
-  }
-
-  // Extract all unique tags across all URDFs
-  const allTags = new Set<string>();
-  data.forEach((urdf) => {
-    if (urdf.tags && Array.isArray(urdf.tags)) {
-      urdf.tags.forEach((tag) => allTags.add(tag));
-    }
-  });
-
-  // Convert to Category objects
-  return Array.from(allTags).map((tag) => ({
-    id: tag,
-    name: tag.charAt(0).toUpperCase() + tag.slice(1), // Capitalize first letter
-  }));
-};
-
-// Get URDF by ID
-export const getUrdfById = async (id: string): Promise<ContentItem | null> => {
-  const { data, error } = await supabase
-    .from("urdf")
-    .select("*")
-    .eq("id", id)
-    .single();
-
-  if (error) {
-    if (error.code === "PGRST116") {
-      // Row not found
-      return null;
-    }
-    console.error("Error fetching URDF by ID:", error);
-    throw error;
-  }
-
-  return mapUrdfToContentItem(data);
-};
-
-// Get public URL for image
-export const getImageUrl = async (path: string): Promise<string> => {
-  if (!path || path.startsWith('http') || path.startsWith('data:')) {
-    return path || '/placeholder.svg';
-  }
-
-  try {
-    // Get public URL for the image
-    const { data, error } = await supabase.storage
-      .from('urdf-images')
-      .createSignedUrl(path, 3600); // 1 hour expiry
-      
-    if (data && !error) {
-      return data.signedUrl;
-    }
-  } catch (error) {
-    console.error(`Error fetching image at ${path}:`, error);
-  }
-  
-  return '/placeholder.svg';
-};
-

viewer/src/components/AnimationDialog.tsx

@@ -1,139 +0,0 @@
-import React, { useState } from "react";
-import {
-  Dialog,
-  DialogContent,
-  DialogHeader,
-  DialogTitle,
-  DialogFooter,
-} from "./ui/dialog";
-import { Button } from "./ui/button";
-import { Textarea } from "./ui/textarea";
-import { Loader } from "lucide-react";
-import { toast } from "sonner";
-import { useCreateAnimation } from "@/hooks/useCreateAnimation";
-import { AnimationRequest, RobotAnimationConfig } from "@/lib/types";
-import { useUrdf } from "@/hooks/useUrdf";
-
-interface AnimationDialogProps {
-  open: boolean;
-  onOpenChange: (open: boolean) => void;
-  robotName: string;
-}
-
-const AnimationDialog: React.FC<AnimationDialogProps> = ({
-  open,
-  onOpenChange,
-  robotName,
-}) => {
-  const [animationPrompt, setAnimationPrompt] = useState("");
-  const [isGeneratingAnimation, setIsGeneratingAnimation] = useState(false);
-  const { createAnimation, clearError } = useCreateAnimation();
-  const { urdfContent, currentRobotData, setCurrentAnimationConfig } =
-    useUrdf();
-
-  // Handle dialog close - clear error states
-  const handleOpenChange = (open: boolean) => {
-    if (!open) {
-      clearError();
-    }
-    onOpenChange(open);
-  };
-
-  const handleAnimationRequest = async () => {
-    if (!animationPrompt.trim()) {
-      toast.error("Please enter an animation description");
-      return;
-    }
-
-    if (!urdfContent) {
-      toast.error("No URDF content available", {
-        description: "Please upload a URDF model first.",
-      });
-      return;
-    }
-
-    setIsGeneratingAnimation(true);
-
-    try {
-      // Create the animation request
-      const request: AnimationRequest = {
-        robotName: currentRobotData?.name || robotName,
-        urdfContent,
-        description: animationPrompt,
-      };
-
-      // Call the createAnimation function
-      const animationResult = await createAnimation(request);
-
-      setIsGeneratingAnimation(false);
-      onOpenChange(false);
-
-      // Reset the prompt for next time
-      setAnimationPrompt("");
-
-      // Store animation in the context instead of using the onAnimationApplied callback
-      if (animationResult) {
-        setCurrentAnimationConfig(animationResult);
-
-        // Show success message
-        toast.success("Animation applied successfully", {
-          description: `Applied: "${animationPrompt}"`,
-          duration: 2000,
-        });
-      }
-    } catch (error) {
-      setIsGeneratingAnimation(false);
-
-      // The error toast is already handled in the hook
-      console.error("Animation generation failed:", error);
-    }
-  };
-
-  return (
-    <Dialog open={open} onOpenChange={handleOpenChange}>
-      <DialogContent className="sm:max-w-[425px] font-mono">
-        <DialogHeader>
-          <DialogTitle className="text-center">
-            Animation Request for {currentRobotData?.name || robotName}
-          </DialogTitle>
-        </DialogHeader>
-
-        <div className="py-4">
-          <Textarea
-            placeholder="Describe the animation you want to see (e.g., 'Make the robot wave its arm' or 'Make one of the wheels spin in circles')"
-            className="min-h-[100px] font-mono"
-            value={animationPrompt}
-            onChange={(e) => setAnimationPrompt(e.target.value)}
-            disabled={isGeneratingAnimation}
-          />
-        </div>
-
-        <DialogFooter>
-          <Button
-            onClick={() => handleOpenChange(false)}
-            variant="outline"
-            disabled={isGeneratingAnimation}
-          >
-            Cancel
-          </Button>
-          <Button
-            onClick={handleAnimationRequest}
-            disabled={isGeneratingAnimation || !urdfContent}
-            className="ml-2"
-          >
-            {isGeneratingAnimation ? (
-              <>
-                <Loader className="mr-2 h-4 w-4 animate-spin" />
-                Generating...
-              </>
-            ) : (
-              "Apply Animation"
-            )}
-          </Button>
-        </DialogFooter>
-      </DialogContent>
-    </Dialog>
-  );
-};
-
-export default AnimationDialog;

viewer/src/components/Carousel.tsx

@@ -1,175 +0,0 @@
-import React, { useRef, useState, useEffect } from "react";
-import { ContentItem } from "../lib/types";
-import { useNavigate } from "react-router-dom";
-import { ChevronLeft, ChevronRight, Star } from "lucide-react";
-import { cn } from "@/lib/utils";
-import { useIsMobile } from "@/hooks/use-mobile";
-import { useMyList } from "@/hooks/use-my-list";
-import { supabase } from "@/integrations/supabase/client";
-import { useUrdf } from "@/hooks/useUrdf";
-
-interface CarouselProps {
-  title: string;
-  items: ContentItem[];
-  className?: string;
-}
-
-const Carousel: React.FC<CarouselProps> = ({ title, items, className }) => {
-  const carouselRef = useRef<HTMLDivElement>(null);
-  const navigate = useNavigate();
-  const isMobile = useIsMobile();
-  const { myList, addToMyList, removeFromMyList, isInMyList } = useMyList();
-  const [imageUrls, setImageUrls] = useState<Record<string, string>>({});
-  const { urdfProcessor, processUrdfFiles } = useUrdf();
-
-  // Fetch image URLs for all items
-  useEffect(() => {
-    const fetchImages = async () => {
-      const urls: Record<string, string> = {};
-
-      for (const item of items) {
-        if (
-          item.imageUrl &&
-          !item.imageUrl.startsWith("http") &&
-          !item.imageUrl.startsWith("data:")
-        ) {
-          try {
-            // Get public URL for the image
-            const { data, error } = await supabase.storage
-              .from("urdf-images")
-              .createSignedUrl(item.imageUrl, 3600); // 1 hour expiry
-
-            if (data && !error) {
-              urls[item.id] = data.signedUrl;
-            } else {
-              // Fallback to placeholder
-              urls[item.id] = "/placeholder.svg";
-            }
-          } catch (error) {
-            console.error(`Error fetching image for ${item.id}:`, error);
-            urls[item.id] = "/placeholder.svg";
-          }
-        } else {
-          // For URLs that are already full URLs or data URIs
-          urls[item.id] = item.imageUrl || "/placeholder.svg";
-        }
-      }
-
-      setImageUrls(urls);
-    };
-
-    if (items.length > 0) {
-      fetchImages();
-    }
-  }, [items]);
-
-  const handleScrollLeft = () => {
-    if (carouselRef.current) {
-      const scrollAmount = carouselRef.current.offsetWidth / 4.1;
-      carouselRef.current.scrollBy({ left: -scrollAmount, behavior: "smooth" });
-    }
-  };
-
-  const handleScrollRight = () => {
-    if (carouselRef.current) {
-      const scrollAmount = carouselRef.current.offsetWidth / 4.1;
-      carouselRef.current.scrollBy({ left: scrollAmount, behavior: "smooth" });
-    }
-  };
-
-  const handleItemClick = async (item: ContentItem) => {
-    // Only navigate to the content detail page, let the detail page handle loading
-    navigate(`/content/${item.id}`);
-
-    // We've removed the URDF loading here to prevent duplication with ContentDetail's loading
-  };
-
-  const handleStarClick = (e: React.MouseEvent, item: ContentItem) => {
-    e.stopPropagation(); // Prevent navigation on star click
-
-    if (isInMyList(item.id)) {
-      removeFromMyList(item.id);
-    } else {
-      addToMyList(item);
-    }
-  };
-
-  // If no items, don't render the carousel
-  if (items.length === 0) return null;
-
-  return (
-    <div className={cn("my-5", className)}>
-      <div className="relative group">
-        <div
-          ref={carouselRef}
-          className="carousel-container flex items-center gap-2 overflow-x-auto py-2 px-4 scroll-smooth"
-        >
-          {items.map((item) => (
-            <div
-              key={item.id}
-              className="carousel-item flex-shrink-0 cursor-pointer relative hover:z-10"
-              style={{
-                width: "calc(100% / 4.1)",
-              }}
-              onClick={() => handleItemClick(item)}
-            >
-              <div className="relative rounded-md w-full h-full group/item">
-                {/* Image container with darker overlay on hover */}
-                <div className="rounded-md overflow-hidden w-full h-full bg-black">
-                  <img
-                    src={imageUrls[item.id] || "/placeholder.svg"}
-                    alt={item.title}
-                    className="w-full h-full object-cover rounded-md transition-all duration-300 group-hover/item:brightness-90"
-                    style={{
-                      aspectRatio: "0.8",
-                    }}
-                  />
-                </div>
-                {/* Star button */}
-                <div
-                  className="absolute top-4 right-4 p-2 z-20 invisible group-hover/item:visible"
-                  onClick={(e) => handleStarClick(e, item)}
-                >
-                  <Star
-                    size={24}
-                    className={cn(
-                      "transition-colors duration-300",
-                      isInMyList(item.id)
-                        ? "fill-yellow-400 text-yellow-400"
-                        : "text-white hover:text-yellow-400"
-                    )}
-                  />
-                </div>
-                {/* Title overlay - visible on hover without gradient */}
-                <div className="absolute bottom-4 left-4 opacity-0 group-hover/item:opacity-100 transition-opacity duration-300">
-                  <h3 className="text-gray-400 text-6xl font-bold drop-shadow-xl">
-                    {item.title}
-                  </h3>
-                </div>
-              </div>
-            </div>
-          ))}
-        </div>
-
-        {/* Scroll buttons - changed to always visible */}
-        <button
-          onClick={handleScrollLeft}
-          className="absolute left-0 top-1/2 -translate-y-1/2 bg-black text-white p-1 rounded-full z-40"
-          aria-label="Scroll left"
-        >
-          <ChevronLeft size={24} />
-        </button>
-
-        <button
-          onClick={handleScrollRight}
-          className="absolute right-0 top-1/2 -translate-y-1/2 bg-black text-white p-1 rounded-full z-40"
-          aria-label="Scroll right"
-        >
-          <ChevronRight size={24} />
-        </button>
-      </div>
-    </div>
-  );
-};
-
-export default Carousel;

viewer/src/components/ChatWindow.tsx

@@ -1,309 +0,0 @@
-import React, { useState, useRef, useEffect } from "react";
-import { contentItems } from "../../public/data/content";
-import { Send } from "lucide-react";
-import { useNavigate } from "react-router-dom";
-// Commenting out the backend API integration for now
-// import { useChatApi, ChatMessage } from "../hooks/useChatApi";
-
-// Define the ChatMessage interface locally since we're not importing it
-interface ChatMessage {
-  sender: string;
-  text: string;
-  imageUrl?: string;
-  robotId?: string; // Add robotId to track which robot this message refers to
-}
-
-// Mock data for quadruped robots
-const quadrupedRobots = [
-  {
-    name: "Go2",
-    description:
-      "Go1 is a lightweight, agile quadruped companion robot. It can follow you around, carry small items, and navigate complex indoor and outdoor environments. Perfect for research, education, or as a high-tech assistant in various settings.",
-    imageUrl:
-      "https://mizajlqhooderueazvnp.supabase.co/storage/v1/object/public/robotpicturesbucket/go2_description.png",
-    id: "0f041a8f-88cf-4b9c-93ef-a30e8fe2fdb1",
-  },
-  {
-    name: "ANYmal",
-    description:
-      "ANYmal is a rugged quadrupedal robot designed for autonomous operation in challenging environments. With its sophisticated perception systems, it excels at inspection and monitoring tasks in industrial settings, even in hazardous areas unsafe for humans.",
-    imageUrl:
-      "https://mizajlqhooderueazvnp.supabase.co/storage/v1/object/public/robotpicturesbucket/anymal_b_description.png",
-    id: "68e827db-4035-4ae0-a43c-158b610e21d5",
-  },
-];
-
-// Function to get a random wait time to simulate thinking
-const getRandomWaitTime = () => Math.floor(Math.random() * 150) + 50; // 50-200ms
-
-const ChatWindow: React.FC = () => {
-  const [messages, setMessages] = useState<ChatMessage[]>([]);
-  const [input, setInput] = useState("");
-  const [isLoading, setIsLoading] = useState(false);
-  const chatContainerRef = useRef<HTMLDivElement>(null);
-  const navigate = useNavigate();
-
-  // Commenting out the backend API integration
-  // const { sendMessage, streamResponse, isLoading, error } = useChatApi();
-
-  const handleSend = async () => {
-    if (input.trim()) {
-      const userMessage = input.trim();
-
-      // Add user message to chat
-      setMessages((prevMessages) => [
-        ...prevMessages,
-        {
-          sender: "User",
-          text: userMessage,
-        },
-      ]);
-
-      setInput("");
-      setIsLoading(true);
-
-      // Add empty bot message that will be filled with streaming response
-      setMessages((prevMessages) => [
-        ...prevMessages,
-        {
-          sender: "Bot",
-          text: "",
-        },
-      ]);
-
-      // Use our mock response generator instead of the API
-      await generateMockResponse(userMessage);
-    }
-  };
-
-  // Generate a fake response about quadruped robots
-  const generateMockResponse = async (userMessage: string) => {
-    try {
-      // Choose a relevant robot based on keywords in user message
-      let selectedRobot;
-      const userMessageLower = userMessage.toLowerCase();
-
-      if (
-        userMessageLower.includes("agile") ||
-        userMessageLower.includes("mobility")
-      ) {
-        selectedRobot = quadrupedRobots.find((robot) => robot.name === "Go2");
-      } else if (
-        userMessageLower.includes("companion") ||
-        userMessageLower.includes("small")
-      ) {
-        selectedRobot = quadrupedRobots.find((robot) => robot.name === "Go2");
-      } else if (
-        userMessageLower.includes("inspect") ||
-        userMessageLower.includes("monitor") ||
-        userMessageLower.includes("industrial")
-      ) {
-        selectedRobot = quadrupedRobots.find(
-          (robot) => robot.name === "ANYmal"
-        );
-      } else {
-        // If no specific match, pick a random robot
-        const randomIndex = Math.floor(Math.random() * quadrupedRobots.length);
-        selectedRobot = quadrupedRobots[randomIndex];
-      }
-
-      // Generate response text
-      const responseIntro = getResponseIntro(userMessage);
-      const fullResponse = `${responseIntro} ${selectedRobot.name}. ${selectedRobot.description}`;
-
-      // Simulate streaming by adding words one by one with small delays
-      const words = fullResponse.split(" ");
-      for (const word of words) {
-        await new Promise((resolve) =>
-          setTimeout(resolve, getRandomWaitTime())
-        );
-
-        setMessages((prevMessages) => {
-          const updatedMessages = [...prevMessages];
-          const lastMessage = updatedMessages[updatedMessages.length - 1];
-
-          if (lastMessage.sender === "Bot") {
-            lastMessage.text += word + " ";
-          }
-
-          return updatedMessages;
-        });
-      }
-
-      // Add the image and robot ID at the end
-      await new Promise((resolve) => setTimeout(resolve, 300));
-      setMessages((prevMessages) => {
-        const updatedMessages = [...prevMessages];
-        const lastMessage = updatedMessages[updatedMessages.length - 1];
-
-        if (lastMessage.sender === "Bot") {
-          lastMessage.imageUrl = selectedRobot.imageUrl;
-          lastMessage.robotId = selectedRobot.id; // Store the robot ID for navigation
-        }
-
-        return updatedMessages;
-      });
-    } catch (error) {
-      console.error("Error generating mock response:", error);
-      // Handle error by providing a generic fallback
-      setMessages((prevMessages) => {
-        const updatedMessages = [...prevMessages];
-        const lastMessage = updatedMessages[updatedMessages.length - 1];
-
-        if (lastMessage.sender === "Bot") {
-          lastMessage.text =
-            "I'm sorry, I couldn't process your request. Please try asking about robots in a different way.";
-        }
-
-        return updatedMessages;
-      });
-    } finally {
-      setIsLoading(false);
-    }
-  };
-
-  // Navigate to content detail page
-  const navigateToRobotDetail = (robotId: string) => {
-    if (robotId) {
-      navigate(`/content/${robotId}`);
-    }
-  };
-
-  // Get varied intro phrases to make responses seem more natural
-  const getResponseIntro = (userMessage: string) => {
-    const introOptions = [
-      "Based on your query, I recommend",
-      "I think you might be interested in",
-      "A great quadruped robot for your needs is",
-      "You should check out",
-      "Have you considered",
-      "I'd suggest looking at",
-    ];
-
-    const randomIndex = Math.floor(Math.random() * introOptions.length);
-    return introOptions[randomIndex];
-  };
-
-  // Fallback response is no longer needed since we're using mock responses
-
-  useEffect(() => {
-    if (chatContainerRef.current) {
-      setTimeout(() => {
-        chatContainerRef.current!.scrollTop =
-          chatContainerRef.current!.scrollHeight;
-      }, 50); // Add a slight delay to ensure the DOM is updated
-    }
-  }, [messages]);
-
-  return (
-    <div className="bg-[rgba(10,10,20,0.8)] backdrop-blur-lg border border-white/10 text-white p-6 rounded-lg shadow-2xl">
-      <div
-        ref={chatContainerRef}
-        className="overflow-y-auto mb-6 scrollbar-none"
-        style={{ maxHeight: "500px" }}
-      >
-        {messages.length === 0 && (
-          <div className="text-center py-8 text-gray-400 italic">
-            Ask me about robots, and I'll help you find the perfect fit for your
-            needs. NOTE: For this demo, I only know about Go2 and ANYmal + don't
-            want to use up all my LLM credits.
-          </div>
-        )}
-
-        {messages.map((message, index) => (
-          <div
-            key={index}
-            className={`mb-4 ${
-              message.sender === "User" ? "text-right" : "text-left"
-            } animate-fade-in`}
-          >
-            <div className="flex items-start gap-2 mb-1">
-              <span
-                className={`text-sm font-semibold ${
-                  message.sender === "User" ? "ml-auto" : ""
-                }`}
-              >
-                {message.sender === "User" ? "You" : "Assistant"}
-              </span>
-            </div>
-
-            <span
-              className={`inline-block px-4 py-3 rounded-lg ${
-                message.sender === "User"
-                  ? "bg-blue-600 text-white"
-                  : "bg-gray-700/70"
-              }`}
-              style={{ whiteSpace: "pre-wrap" }}
-            >
-              {message.text}
-            </span>
-
-            {message.imageUrl && (
-              <div
-                className="mt-3 transition-all duration-300 hover:scale-105 cursor-pointer"
-                onClick={() =>
-                  message.robotId && navigateToRobotDetail(message.robotId)
-                }
-                title="Click to view robot details"
-              >
-                <img
-                  src={message.imageUrl}
-                  alt="Robot"
-                  className="rounded-lg w-auto shadow-lg border border-white/10 hover:border-white/30"
-                  style={{ maxHeight: "260px" }}
-                />
-                <div className="text-xs text-blue-300 mt-1 text-center">
-                  Click to view details
-                </div>
-              </div>
-            )}
-          </div>
-        ))}
-
-        {isLoading &&
-          messages.length > 0 &&
-          !messages[messages.length - 1].text && (
-            <div className="text-left animate-pulse">
-              <span className="inline-block px-4 py-3 rounded-lg bg-gray-700/50">
-                <div className="flex space-x-1">
-                  <div className="w-2 h-2 bg-gray-400 rounded-full animate-bounce"></div>
-                  <div className="w-2 h-2 bg-gray-400 rounded-full animate-bounce delay-75"></div>
-                  <div className="w-2 h-2 bg-gray-400 rounded-full animate-bounce delay-150"></div>
-                </div>
-              </span>
-            </div>
-          )}
-      </div>
-
-      <div className="flex items-center relative">
-        <textarea
-          value={input}
-          onChange={(e) => setInput(e.target.value)}
-          rows={1}
-          placeholder="Type your message..."
-          onInput={(e) => {
-            const target = e.target as HTMLTextAreaElement;
-            target.style.height = "auto";
-            target.style.height = `${target.scrollHeight}px`;
-          }}
-          onKeyDown={(e) => {
-            if (e.key === "Enter" && !e.shiftKey) {
-              e.preventDefault();
-              handleSend();
-            }
-          }}
-          className="flex-1 px-4 py-4 rounded-lg bg-gray-800/80 text-white placeholder-gray-400 focus:outline-none focus:ring-1 focus:ring-white/25 resize-none overflow-hidden pr-12 border border-white/5"
-        />
-        <button
-          onClick={handleSend}
-          className="absolute right-2 bottom-2 p-2.5 bg-blue-600 rounded-full hover:bg-blue-700 transition-colors disabled:opacity-50"
-          disabled={isLoading}
-        >
-          <Send size={18} className="text-white" />
-        </button>
-      </div>
-    </div>
-  );
-};
-
-export default ChatWindow;

viewer/src/components/ContentCarousel.tsx

@@ -1,29 +0,0 @@
-import React from "react";
-import Carousel from "./Carousel";
-import { Category } from "../lib/types";
-import { useUrdfsByCategory } from "@/hooks/useUrdfData";
-import { Skeleton } from "@/components/ui/skeleton";
-
-interface ContentCarouselProps {
-  category: Category;
-}
-
-const ContentCarousel: React.FC<ContentCarouselProps> = ({ category }) => {
-  const { data: filteredItems, isLoading } = useUrdfsByCategory(category.id);
-
-  if (isLoading) {
-    return (
-      <div className="relative w-full">
-        <Skeleton className="h-64 w-full" />
-      </div>
-    );
-  }
-
-  return filteredItems.length > 0 ? (
-    <div className="relative w-full">
-      <Carousel title={category.name} items={filteredItems} />
-    </div>
-  ) : null;
-};
-
-export default ContentCarousel;

viewer/src/components/Header.tsx

@@ -1,150 +0,0 @@
-import React from "react";
-import { Link, useLocation } from "react-router-dom";
-import { Compass, User, Gamepad2 } from "lucide-react";
-import {
-  DropdownMenu,
-  DropdownMenuContent,
-  DropdownMenuItem,
-  DropdownMenuLabel,
-  DropdownMenuSeparator,
-  DropdownMenuTrigger,
-} from "@/components/ui/dropdown-menu";
-// import { useProjects } from '../hooks/use-projects';
-import { Avatar, AvatarFallback, AvatarImage } from "@/components/ui/avatar";
-import { cn } from "@/lib/utils";
-
-const Header: React.FC = () => {
-  // const { projects } = useProjects();
-  const location = useLocation();
-
-  const isActive = (path: string) => {
-    return location.pathname === path;
-  };
-
-  return (
-    <header className="backdrop-blur-md py-4 px-6 flex items-center justify-between sticky top-0 z-50 shadow-lg border-b border-white/5 bg-zinc-950">
-      <div className="flex items-center">
-        <Link to="/" className="flex items-center mr-8 group">
-          <div className="w-10 h-10 overflow-hidden">
-            <img
-              src="/lovable-uploads/166630d9-f089-4678-a27c-7a00882f5ed0.png"
-              alt="Spiral Logo"
-              className="w-full h-full object-contain transition-transform group-hover:scale-110"
-            />
-          </div>
-          <span className="ml-2 text-white font-bold text-xl tracking-wider group-hover:text-blue-400 transition-colors">
-            QUALIA
-          </span>
-        </Link>
-        <nav className="hidden md:flex space-x-8">
-          {/* <Link
-            to="/"
-            className="flex items-center gap-2 text-white/80 hover:text-white transition-colors text-sm"
-          >
-            <Home size={16} />
-            <span>Home</span>
-          </Link> */}
-          <Link
-            to="/explore"
-            className={cn(
-              "flex items-center gap-2 transition-colors text-sm relative",
-              isActive("/explore")
-                ? "text-blue-400 font-medium"
-                : "text-white/80 hover:text-white"
-            )}
-          >
-            <Compass size={16} />
-            <span>Explore</span>
-            {isActive("/explore") && (
-              <div className="absolute -bottom-2 left-0 w-full h-0.5 bg-blue-400 rounded-full" />
-            )}
-          </Link>
-          {/* <Link
-            to="/my-list"
-            className="flex items-center gap-2 text-white/80 hover:text-white transition-colors text-sm"
-          >
-            <Archive size={16} />
-            <span>Projects</span>
-          </Link> */}
-          <Link
-            to="/playground"
-            className={cn(
-              "flex items-center gap-2 transition-colors text-sm relative",
-              isActive("/playground")
-                ? "text-blue-400 font-medium"
-                : "text-white/80 hover:text-white"
-            )}
-          >
-            <div className="flex items-center gap-2">
-              <Gamepad2 size={16} />
-              <span>Playground</span>
-            </div>
-            {isActive("/playground") && (
-              <div className="absolute -bottom-2 left-0 w-full h-0.5 bg-blue-400 rounded-full" />
-            )}
-          </Link>
-        </nav>
-      </div>
-      <div className="flex items-center space-x-6">
-        <DropdownMenu>
-          <DropdownMenuTrigger asChild>
-            <div className="w-9 h-9 bg-gradient-to-br from-blue-500 to-purple-600 rounded-md transition-transform hover:scale-110 cursor-pointer flex items-center justify-center">
-              <Avatar className="w-full h-full">
-                <AvatarImage src="" alt="Profile" />
-                <AvatarFallback className="bg-transparent text-white">
-                  <User size={18} />
-                </AvatarFallback>
-              </Avatar>
-            </div>
-          </DropdownMenuTrigger>
-          <DropdownMenuContent
-            align="end"
-            className="w-56 bg-zinc-900 border-zinc-800 text-white"
-          >
-            <DropdownMenuLabel className="font-normal">
-              <div className="flex flex-col space-y-1">
-                <p className="text-sm font-medium leading-none">Victor</p>
-                <p className="text-xs leading-none text-zinc-400">
-                  [email protected]
-                </p>
-              </div>
-            </DropdownMenuLabel>
-            <DropdownMenuSeparator className="bg-zinc-800" />
-            <DropdownMenuLabel>Your Projects</DropdownMenuLabel>
-
-            {/* {projects.length > 0 ? (
-              <>
-                {projects.slice(0, 3).map(project => (
-                  <DropdownMenuItem key={project.id} className="cursor-pointer hover:bg-zinc-800" asChild>
-                    <Link to={`/my-list?project=${project.id}`} className="w-full">
-                      <span className="truncate">{project.name}</span>
-                    </Link>
-                  </DropdownMenuItem>
-                ))}
-                {projects.length > 3 && (
-                  <DropdownMenuItem className="text-xs text-zinc-400 hover:bg-zinc-800" asChild>
-                    <Link to="/my-list">View all projects</Link>
-                  </DropdownMenuItem>
-                )}
-              </>
-            ) : (
-              <DropdownMenuItem className="text-zinc-400 cursor-default">
-                No projects yet
-              </DropdownMenuItem>
-            )} */}
-
-            <DropdownMenuSeparator className="bg-zinc-800" />
-            <DropdownMenuItem
-              className="cursor-pointer hover:bg-zinc-800"
-              asChild
-            >
-              <Link to="/my-list">Manage Projects</Link>
-            </DropdownMenuItem>
-          </DropdownMenuContent>
-        </DropdownMenu>
-      </div>
-    </header>
-  );
-};
-
-export default Header;

viewer/src/components/TeamSection.tsx

@@ -1,83 +0,0 @@
-import React from "react";
-import { Card, CardContent } from "@/components/ui/card";
-import { Avatar, AvatarImage, AvatarFallback } from "@/components/ui/avatar";
-
-interface TeamMember {
-  id: string;
-  name: string;
-  role: string;
-  imageUrl: string;
-  bio?: string;
-}
-
-const teamMembers: TeamMember[] = [
-  {
-    id: "1",
-    name: "Max",
-    role: "Co-founder",
-    imageUrl: "/lovable-uploads/07251c16-3e3c-4c40-8450-c6c17f291e00.png",
-    bio: "Cracked engineer",
-  },
-  {
-    id: "2",
-    name: "Ludvig",
-    role: "Co-founder",
-    imageUrl: "/lovable-uploads/e6811f8e-3c1e-4a80-80e5-4b82f4704aec.png",
-    bio: "Cracked engineer",
-  },
-  {
-    id: "3",
-    name: "Victor",
-    role: "Co-founder",
-    imageUrl: "/lovable-uploads/21f0e012-4ef0-4db0-a1e2-aa5205c8400e.png",
-    bio: "Cracked engineer",
-  },
-  {
-    id: "4",
-    name: "Fabian",
-    role: "Co-founder",
-    imageUrl: "/lovable-uploads/e6f4bf50-ed44-4ce7-9fab-ff8a9476b584.png",
-    bio: "(Almost) cracked engineer",
-  },
-];
-
-const TeamSection: React.FC = () => {
-  return (
-    <section className="py-16 relative z-10">
-      <div className="container mx-auto px-4">
-        <h2 className="text-5xl font-bold mb-12 text-center text-netflix-text text-glow">
-          Our Team
-        </h2>
-
-        <div className="grid grid-cols-1 md:grid-cols-2 lg:grid-cols-4 gap-8">
-          {teamMembers.map((member) => (
-            <Card
-              key={member.id}
-              className="glass-panel hover:shadow-glow transition-all duration-300 transform hover:-translate-y-1"
-            >
-              <CardContent className="pt-6 text-center">
-                <Avatar className="h-32 w-32 mx-auto mb-4 border-2 border-white/20">
-                  <AvatarImage
-                    src={member.imageUrl}
-                    alt={member.name}
-                    className="filter grayscale"
-                  />
-                  <AvatarFallback className="text-2xl">
-                    {member.name.charAt(0)}
-                  </AvatarFallback>
-                </Avatar>
-                <h3 className="text-xl font-bold mb-1">{member.name}</h3>
-                <p className="text-netflix-lightText mb-3">{member.role}</p>
-                {member.bio && (
-                  <p className="text-sm text-netflix-text2">{member.bio}</p>
-                )}
-              </CardContent>
-            </Card>
-          ))}
-        </div>
-      </div>
-    </section>
-  );
-};
-
-export default TeamSection;

viewer/src/hooks/use-my-list.tsx

@@ -1,74 +0,0 @@
-import {
-  useState,
-  useEffect,
-  createContext,
-  useContext,
-  ReactNode,
-} from "react";
-import { ContentItem } from "../lib/types";
-
-interface MyListContextType {
-  myList: ContentItem[];
-  addToMyList: (item: ContentItem) => void;
-  removeFromMyList: (id: string) => void;
-  isInMyList: (id: string) => boolean;
-}
-
-const MyListContext = createContext<MyListContextType | undefined>(undefined);
-
-export const MyListProvider: React.FC<{ children: ReactNode }> = ({
-  children,
-}) => {
-  const [myList, setMyList] = useState<ContentItem[]>([]);
-
-  // Load saved items from local storage
-  useEffect(() => {
-    const savedList = localStorage.getItem("myList");
-    if (savedList) {
-      try {
-        setMyList(JSON.parse(savedList));
-      } catch (error) {
-        console.error("Failed to parse saved list:", error);
-      }
-    }
-  }, []);
-
-  // Save items to local storage when list changes
-  useEffect(() => {
-    localStorage.setItem("myList", JSON.stringify(myList));
-  }, [myList]);
-
-  const addToMyList = (item: ContentItem) => {
-    setMyList((prev) => {
-      // Only add if not already in list
-      if (!prev.some((listItem) => listItem.id === item.id)) {
-        return [...prev, item];
-      }
-      return prev;
-    });
-  };
-
-  const removeFromMyList = (id: string) => {
-    setMyList((prev) => prev.filter((item) => item.id !== id));
-  };
-
-  const isInMyList = (id: string) => {
-    return myList.some((item) => item.id === id);
-  };
-
-  return (
-    <MyListContext.Provider
-      value={{ myList, addToMyList, removeFromMyList, isInMyList }}
-    >
-      {children}
-    </MyListContext.Provider>
-  );
-};
-
-export const useMyList = () => {
-  const context = useContext(MyListContext);
-  if (context === undefined) {
-    throw new Error("useMyList must be used within a MyListProvider");
-  }
-  return context;
-};

viewer/src/hooks/useChatApi.ts

@@ -1,129 +0,0 @@
-import { useState, useCallback, useEffect } from "react";
-import { useMutation } from "@tanstack/react-query";
-import { v4 as uuidv4 } from "uuid";
-
-// Generate a conversation ID to help backend keep track of the chat history
-const getConversationId = () => {
-  const storedId = localStorage.getItem("chat_conversation_id");
-  if (storedId) return storedId;
-
-  const newId = uuidv4();
-  localStorage.setItem("chat_conversation_id", newId);
-  return newId;
-};
-
-export interface ChatMessage {
-  sender: string;
-  text: string;
-  imageUrl?: string;
-}
-
-export const useChatApi = () => {
-  const [conversationId] = useState(getConversationId);
-  const [isStreaming, setIsStreaming] = useState(false);
-
-  // Use mutation for the API call
-  const chatMutation = useMutation({
-    mutationFn: async (prompt: string) => {
-      const controller = new AbortController();
-      const signal = controller.signal;
-
-      const response = await fetch("http://127.0.0.1:8000/prompt", {
-        method: "POST",
-        headers: {
-          "Content-Type": "application/json",
-        },
-        body: JSON.stringify({
-          session_id: conversationId,
-          prompt: prompt,
-        }),
-        signal,
-      });
-
-      if (!response.ok) {
-        throw new Error("Network response was not ok");
-      }
-
-      return { response, controller };
-    },
-  });
-
-  // Process the streaming response
-  const streamResponse = useCallback(
-    async (
-      response: Response,
-      onChunk: (chunk: string) => void,
-      onImage?: (imageUrl: string) => void
-    ) => {
-      if (!response.body) {
-        throw new Error("Response body is null");
-      }
-
-      setIsStreaming(true);
-
-      const reader = response.body.getReader();
-      const decoder = new TextDecoder();
-      let buffer = "";
-
-      try {
-        while (true) {
-          const { done, value } = await reader.read();
-
-          if (done) {
-            break;
-          }
-
-          // Decode the chunk
-          const text = decoder.decode(value, { stream: true });
-          buffer += text;
-
-          // Process SSE format: "data: {json}\n\n"
-          const lines = buffer.split("\n\n");
-          buffer = lines.pop() || "";
-
-          for (const line of lines) {
-            if (line.startsWith("data: ")) {
-              const jsonStr = line.slice(6);
-              try {
-                const data = JSON.parse(jsonStr);
-
-                // Check if there's text content
-                if (data.text) {
-                  onChunk(data.text);
-                }
-
-                // Check if there's an image URL
-                if (data.image_url) {
-                  onImage?.(data.image_url);
-                }
-              } catch (e) {
-                console.error("Error parsing SSE JSON:", e);
-              }
-            }
-          }
-        }
-      } catch (error) {
-        console.error("Error reading stream:", error);
-      } finally {
-        setIsStreaming(false);
-      }
-    },
-    []
-  );
-
-  // Cleanup function to abort any pending requests
-  useEffect(() => {
-    return () => {
-      if (chatMutation.data?.controller) {
-        chatMutation.data.controller.abort();
-      }
-    };
-  }, [chatMutation.data]);
-
-  return {
-    sendMessage: chatMutation.mutate,
-    streamResponse,
-    isLoading: chatMutation.isPending || isStreaming,
-    error: chatMutation.error,
-  };
-};

viewer/src/hooks/useCreateAnimation.ts

@@ -1,114 +0,0 @@
-import { useState } from "react";
-import { supabase } from "@/lib/supabase";
-import { AnimationRequest, RobotAnimationConfig } from "@/lib/types";
-import { toast } from "sonner";
-
-export const useCreateAnimation = () => {
-  const [isLoading, setIsLoading] = useState(false);
-  const [error, setError] = useState<string | null>(null);
-  const [animation, setAnimation] = useState<RobotAnimationConfig | null>(null);
-
-  const createAnimation = async (
-    request: AnimationRequest
-  ): Promise<RobotAnimationConfig | null> => {
-    const requestId = `anim-${Date.now()}`; // Generate unique ID for tracking
-    console.log(`[${requestId}] 🚀 Animation Generator: Starting request`);
-    console.log(`[${requestId}] 🔍 Description: "${request.description}"`);
-
-    setIsLoading(true);
-    setError(null);
-
-    const startTime = performance.now();
-
-    try {
-      console.log(
-        `[${requestId}] 📡 Calling Supabase edge function "create-animation"...`
-      );
-
-      const { data, error } = await supabase.functions.invoke(
-        "create-animation",
-        {
-          body: {
-            robotName: request.robotName,
-            urdfContent: request.urdfContent,
-            description: request.description,
-          },
-        }
-      );
-
-      if (error) {
-        console.error(`[${requestId}] ❌ Supabase function error:`, error);
-
-        // Format the error message for display
-        const errorMessage = error.message || "Unknown error occurred";
-        setError(errorMessage);
-
-        toast.error("Animation Generation Failed", {
-          description: errorMessage.includes("non-2xx status code")
-            ? "The animation generator encountered a server error."
-            : errorMessage,
-          duration: 5000,
-        });
-
-        throw new Error(errorMessage);
-      }
-
-      const endTime = performance.now();
-      console.log(
-        `[${requestId}] ✅ Edge function responded in ${(
-          endTime - startTime
-        ).toFixed(2)}ms`
-      );
-
-      if (!data) {
-        throw new Error("No data returned from edge function");
-      }
-
-      // Quick validation of minimum required structure
-      if (
-        !data.joints ||
-        !Array.isArray(data.joints) ||
-        data.joints.length === 0
-      ) {
-        console.error(`[${requestId}] ⚠️ Invalid animation data:`, data);
-        throw new Error(
-          "Invalid animation configuration: Missing joint animations"
-        );
-      }
-
-      console.log(
-        `[${requestId}] 🤖 Animation generated with ${data.joints.length} joint(s)`
-      );
-
-      // Store the animation data
-      setAnimation(data);
-      return data;
-    } catch (err) {
-      const errorMessage =
-        err instanceof Error ? err.message : "Unknown error occurred";
-      const endTime = performance.now();
-
-      console.error(
-        `[${requestId}] ❌ Error generating animation after ${(
-          endTime - startTime
-        ).toFixed(2)}ms:`,
-        err
-      );
-
-      setError(errorMessage);
-      return null;
-    } finally {
-      setIsLoading(false);
-      console.log(`[${requestId}] 🏁 Animation request completed`);
-    }
-  };
-
-  return {
-    createAnimation,
-    animation,
-    isLoading,
-    error,
-    clearAnimation: () => setAnimation(null),
-    clearError: () => setError(null),
-  };
-};

viewer/src/integrations/supabase/types.ts

@@ -1,330 +0,0 @@
-export type Json =
-  | string
-  | number
-  | boolean
-  | null
-  | { [key: string]: Json | undefined }
-  | Json[]
-
-export type Database = {
-  public: {
-    Tables: {
-      urdf: {
-        Row: {
-          dof: number | null
-          has_manipulator: boolean | null
-          id: string
-          image_uri: string | null
-          joints: Json | null
-          links: Json | null
-          maker: string | null
-          manipulators: string[] | null
-          name: string
-          num_joints: number | null
-          num_links: number | null
-          num_manipulators: number | null
-          summary: string | null
-          tags: string[] | null
-          total_mass: number | null
-          type: string | null
-          urdf_uri: string | null
-        }
-        Insert: {
-          dof?: number | null
-          has_manipulator?: boolean | null
-          id?: string
-          image_uri?: string | null
-          joints?: Json | null
-          links?: Json | null
-          maker?: string | null
-          manipulators?: string[] | null
-          name: string
-          num_joints?: number | null
-          num_links?: number | null
-          num_manipulators?: number | null
-          summary?: string | null
-          tags?: string[] | null
-          total_mass?: number | null
-          type?: string | null
-          urdf_uri?: string | null
-        }
-        Update: {
-          dof?: number | null
-          has_manipulator?: boolean | null
-          id?: string
-          image_uri?: string | null
-          joints?: Json | null
-          links?: Json | null
-          maker?: string | null
-          manipulators?: string[] | null
-          name?: string
-          num_joints?: number | null
-          num_links?: number | null
-          num_manipulators?: number | null
-          summary?: string | null
-          tags?: string[] | null
-          total_mass?: number | null
-          type?: string | null
-          urdf_uri?: string | null
-        }
-        Relationships: []
-      }
-      urdf_embeddings: {
-        Row: {
-          embeddings: string
-          id: string
-          name: string | null
-          summary: string | null
-        }
-        Insert: {
-          embeddings: string
-          id?: string
-          name?: string | null
-          summary?: string | null
-        }
-        Update: {
-          embeddings?: string
-          id?: string
-          name?: string | null
-          summary?: string | null
-        }
-        Relationships: [
-          {
-            foreignKeyName: "urdf_embeddings_id_fkey"
-            columns: ["id"]
-            isOneToOne: true
-            referencedRelation: "urdf"
-            referencedColumns: ["id"]
-          },
-        ]
-      }
-    }
-    Views: {
-      [_ in never]: never
-    }
-    Functions: {
-      binary_quantize: {
-        Args: { "": string } | { "": unknown }
-        Returns: unknown
-      }
-      halfvec_avg: {
-        Args: { "": number[] }
-        Returns: unknown
-      }
-      halfvec_out: {
-        Args: { "": unknown }
-        Returns: unknown
-      }
-      halfvec_send: {
-        Args: { "": unknown }
-        Returns: string
-      }
-      halfvec_typmod_in: {
-        Args: { "": unknown[] }
-        Returns: number
-      }
-      hnsw_bit_support: {
-        Args: { "": unknown }
-        Returns: unknown
-      }
-      hnsw_halfvec_support: {
-        Args: { "": unknown }
-        Returns: unknown
-      }
-      hnsw_sparsevec_support: {
-        Args: { "": unknown }
-        Returns: unknown
-      }
-      hnswhandler: {
-        Args: { "": unknown }
-        Returns: unknown
-      }
-      ivfflat_bit_support: {
-        Args: { "": unknown }
-        Returns: unknown
-      }
-      ivfflat_halfvec_support: {
-        Args: { "": unknown }
-        Returns: unknown
-      }
-      ivfflathandler: {
-        Args: { "": unknown }
-        Returns: unknown
-      }
-      l2_norm: {
-        Args: { "": unknown } | { "": unknown }
-        Returns: number
-      }
-      l2_normalize: {
-        Args: { "": string } | { "": unknown } | { "": unknown }
-        Returns: string
-      }
-      match_urdfs: {
-        Args: {
-          query_embedding: string
-          match_threshold: number
-          match_count: number
-        }
-        Returns: {
-          id: string
-          name: string
-          summary: string
-          score: number
-        }[]
-      }
-      sparsevec_out: {
-        Args: { "": unknown }
-        Returns: unknown
-      }
-      sparsevec_send: {
-        Args: { "": unknown }
-        Returns: string
-      }
-      sparsevec_typmod_in: {
-        Args: { "": unknown[] }
-        Returns: number
-      }
-      vector_avg: {
-        Args: { "": number[] }
-        Returns: string
-      }
-      vector_dims: {
-        Args: { "": string } | { "": unknown }
-        Returns: number
-      }
-      vector_norm: {
-        Args: { "": string }
-        Returns: number
-      }
-      vector_out: {
-        Args: { "": string }
-        Returns: unknown
-      }
-      vector_send: {
-        Args: { "": string }
-        Returns: string
-      }
-      vector_typmod_in: {
-        Args: { "": unknown[] }
-        Returns: number
-      }
-    }
-    Enums: {
-      [_ in never]: never
-    }
-    CompositeTypes: {
-      [_ in never]: never
-    }
-  }
-}
-
-type DefaultSchema = Database[Extract<keyof Database, "public">]
-
-export type Tables<
-  DefaultSchemaTableNameOrOptions extends
-    | keyof (DefaultSchema["Tables"] & DefaultSchema["Views"])
-    | { schema: keyof Database },
-  TableName extends DefaultSchemaTableNameOrOptions extends {
-    schema: keyof Database
-  }
-    ? keyof (Database[DefaultSchemaTableNameOrOptions["schema"]]["Tables"] &
-        Database[DefaultSchemaTableNameOrOptions["schema"]]["Views"])
-    : never = never,
-> = DefaultSchemaTableNameOrOptions extends { schema: keyof Database }
-  ? (Database[DefaultSchemaTableNameOrOptions["schema"]]["Tables"] &
-      Database[DefaultSchemaTableNameOrOptions["schema"]]["Views"])[TableName] extends {
-      Row: infer R
-    }
-    ? R
-    : never
-  : DefaultSchemaTableNameOrOptions extends keyof (DefaultSchema["Tables"] &
-        DefaultSchema["Views"])
-    ? (DefaultSchema["Tables"] &
-        DefaultSchema["Views"])[DefaultSchemaTableNameOrOptions] extends {
-        Row: infer R
-      }
-      ? R
-      : never
-    : never
-
-export type TablesInsert<
-  DefaultSchemaTableNameOrOptions extends
-    | keyof DefaultSchema["Tables"]
-    | { schema: keyof Database },
-  TableName extends DefaultSchemaTableNameOrOptions extends {
-    schema: keyof Database
-  }
-    ? keyof Database[DefaultSchemaTableNameOrOptions["schema"]]["Tables"]
-    : never = never,
-> = DefaultSchemaTableNameOrOptions extends { schema: keyof Database }
-  ? Database[DefaultSchemaTableNameOrOptions["schema"]]["Tables"][TableName] extends {
-      Insert: infer I
-    }
-    ? I
-    : never
-  : DefaultSchemaTableNameOrOptions extends keyof DefaultSchema["Tables"]
-    ? DefaultSchema["Tables"][DefaultSchemaTableNameOrOptions] extends {
-        Insert: infer I
-      }
-      ? I
-      : never
-    : never
-
-export type TablesUpdate<
-  DefaultSchemaTableNameOrOptions extends
-    | keyof DefaultSchema["Tables"]
-    | { schema: keyof Database },
-  TableName extends DefaultSchemaTableNameOrOptions extends {
-    schema: keyof Database
-  }
-    ? keyof Database[DefaultSchemaTableNameOrOptions["schema"]]["Tables"]
-    : never = never,
-> = DefaultSchemaTableNameOrOptions extends { schema: keyof Database }
-  ? Database[DefaultSchemaTableNameOrOptions["schema"]]["Tables"][TableName] extends {
-      Update: infer U
-    }
-    ? U
-    : never
-  : DefaultSchemaTableNameOrOptions extends keyof DefaultSchema["Tables"]
-    ? DefaultSchema["Tables"][DefaultSchemaTableNameOrOptions] extends {
-        Update: infer U
-      }
-      ? U
-      : never
-    : never
-
-export type Enums<
-  DefaultSchemaEnumNameOrOptions extends
-    | keyof DefaultSchema["Enums"]
-    | { schema: keyof Database },
-  EnumName extends DefaultSchemaEnumNameOrOptions extends {
-    schema: keyof Database
-  }
-    ? keyof Database[DefaultSchemaEnumNameOrOptions["schema"]]["Enums"]
-    : never = never,
-> = DefaultSchemaEnumNameOrOptions extends { schema: keyof Database }
-  ? Database[DefaultSchemaEnumNameOrOptions["schema"]]["Enums"][EnumName]
-  : DefaultSchemaEnumNameOrOptions extends keyof DefaultSchema["Enums"]
-    ? DefaultSchema["Enums"][DefaultSchemaEnumNameOrOptions]
-    : never
-
-export type CompositeTypes<
-  PublicCompositeTypeNameOrOptions extends
-    | keyof DefaultSchema["CompositeTypes"]
-    | { schema: keyof Database },
-  CompositeTypeName extends PublicCompositeTypeNameOrOptions extends {
-    schema: keyof Database
-  }
-    ? keyof Database[PublicCompositeTypeNameOrOptions["schema"]]["CompositeTypes"]
-    : never = never,
-> = PublicCompositeTypeNameOrOptions extends { schema: keyof Database }
-  ? Database[PublicCompositeTypeNameOrOptions["schema"]]["CompositeTypes"][CompositeTypeName]
-  : PublicCompositeTypeNameOrOptions extends keyof DefaultSchema["CompositeTypes"]
-    ? DefaultSchema["CompositeTypes"][PublicCompositeTypeNameOrOptions]
-    : never
-
-export const Constants = {
-  public: {
-    Enums: {},
-  },
-} as const

viewer/supabase/.temp/cli-latest

@@ -1 +0,0 @@
-v2.20.12

viewer/supabase/functions/create-animation/index.ts

@@ -1,517 +0,0 @@
-// @deno-types="npm:@types/node"
-import { XMLParser } from "npm:[email protected]";
-import { serve } from "https://deno.land/[email protected]/http/server.ts";
-import { createClient } from "https://esm.sh/@supabase/[email protected]";
-
-// Deno environment
-declare const Deno: {
-  env: {
-    get(key: string): string | undefined;
-  };
-};
-
-// OpenAI client
-const OPENAI_API_KEY = Deno.env.get("OPENAI_API_KEY");
-if (!OPENAI_API_KEY) {
-  console.error("Missing OPENAI_API_KEY environment variable");
-}
-
-// URDF Joint type definition
-interface URDFJoint {
-  name: string;
-  type: string;
-  parent: string;
-  child: string;
-  axis?: {
-    xyz: string;
-  };
-  origin?: {
-    xyz: string;
-    rpy: string;
-  };
-  limits?: {
-    lower?: number;
-    upper?: number;
-    effort?: number;
-    velocity?: number;
-  };
-}
-
-// URDF Element interface to avoid 'any' type
-interface URDFElement {
-  name?: string;
-  type?: string;
-  parent?: { link?: string };
-  child?: { link?: string };
-  axis?: { xyz?: string };
-  origin?: { xyz?: string; rpy?: string };
-  limit?: {
-    lower?: number;
-    upper?: number;
-    effort?: number;
-    velocity?: number;
-  };
-}
-
-// Animation request definition
-interface AnimationRequest {
-  robotName: string;
-  urdfContent: string;
-  description: string;
-}
-
-// Joint animation configuration
-interface JointAnimationConfig {
-  name: string;
-  type: "sine" | "linear" | "constant";
-  min: number;
-  max: number;
-  speed: number;
-  offset: number;
-  isDegrees?: boolean;
-}
-
-// Robot animation configuration
-interface RobotAnimationConfig {
-  joints: JointAnimationConfig[];
-  speedMultiplier?: number;
-}
-
-// CORS headers for cross-origin requests
-const corsHeaders = {
-  "Access-Control-Allow-Origin": "*",
-  "Access-Control-Allow-Headers":
-    "authorization, x-client-info, apikey, content-type",
-  "Access-Control-Allow-Methods": "POST, OPTIONS",
-};
-
-// Generate animation configuration using OpenAI
-async function generateAnimationConfig(
-  joints: URDFJoint[],
-  description: string,
-  robotName: string
-): Promise<RobotAnimationConfig> {
-  // Filter out fixed joints as they can't be animated
-  const movableJoints = joints.filter(
-    (joint) =>
-      joint.type !== "fixed" &&
-      joint.name &&
-      (joint.type === "revolute" ||
-        joint.type === "continuous" ||
-        joint.type === "prismatic")
-  );
-
-  // Create a description of available joints for the AI
-  const jointsDescription = movableJoints
-    .map((joint) => {
-      const limits = joint.limits
-        ? `(limits: ${
-            joint.limits.lower !== undefined ? joint.limits.lower : "none"
-          } to ${
-            joint.limits.upper !== undefined ? joint.limits.upper : "none"
-          })`
-        : "(no limits)";
-
-      const axisInfo = joint.axis ? `axis: ${joint.axis.xyz}` : "no axis info";
-
-      return `- ${joint.name}: type=${joint.type}, connects ${joint.parent} to ${joint.child}, ${axisInfo} ${limits}`;
-    })
-    .join("\n");
-
-  // Create prompt for OpenAI
-  const prompt = `
-You are a robotics animation expert. I need you to create animation configurations for a robot named "${robotName}".
-
-The user wants the following animation: "${description}"
-
-Here are the available movable joints in the robot:
-${jointsDescription}
-
-Based on these joints and the user's description, create a valid animation configuration in JSON format.
-The animation configuration should include:
-1. A list of joint animations (only include joints that should move)
-2. For each joint, specify:
-   - name: The exact joint name from the list above (string)
-   - type: Must be exactly one of "sine", "linear", or "constant" (string)
-   - min: Minimum position value (number, respect joint limits if available)
-   - max: Maximum position value (number, respect joint limits if available)
-   - speed: Speed multiplier (number, 0.5-2.0 is a reasonable range, lower is slower)
-   - offset: Phase offset in radians (number, 0 to 2π, useful for coordinating multiple joints)
-   - isDegrees: Optional boolean, set to true if the min/max values are in degrees rather than radians
-
-3. An optional global speedMultiplier (number, default: 1.0)
-
-You must return ONLY valid JSON matching this EXACT schema:
-{
-  "joints": [
-    {
-      "name": string,
-      "type": "sine" | "linear" | "constant",
-      "min": number,
-      "max": number,
-      "speed": number,
-      "offset": number,
-      "isDegrees"?: boolean
-    }
-  ],
-  "speedMultiplier"?: number
-}
-
-Important rules:
-- Only include movable joints from the list provided
-- Respect joint limits when available
-- Create natural, coordinated movements that match the user's description
-- If the description mentions specific joints, prioritize animating those
-- For walking animations, coordinate leg joints with appropriate phase offsets
-- For realistic motion, use sine waves with different offsets for natural movement
-- DO NOT ADD ANY PROPERTIES that aren't in the schema above
-- DO NOT INCLUDE customEasing or any other properties not in the schema
-- Return ONLY valid JSON without comments or explanations
-`;
-
-  try {
-    // Call OpenAI API
-    const response = await fetch("https://api.openai.com/v1/chat/completions", {
-      method: "POST",
-      headers: {
-        "Content-Type": "application/json",
-        Authorization: `Bearer ${OPENAI_API_KEY}`,
-      },
-      body: JSON.stringify({
-        model: "gpt-4o-mini",
-        messages: [
-          {
-            role: "system",
-            content:
-              "You are a robotics animation expert that produces only valid JSON as output.",
-          },
-          {
-            role: "user",
-            content: prompt,
-          },
-        ],
-        temperature: 0.7,
-        max_tokens: 1000,
-        response_format: { type: "json_object" },
-      }),
-    });
-
-    if (!response.ok) {
-      const errorData = await response.json();
-      console.error("OpenAI API error:", errorData);
-      throw new Error(`OpenAI API error: ${response.status}`);
-    }
-
-    const data = await response.json();
-    const animationText = data.choices[0].message.content.trim();
-
-    // Log the raw response for debugging
-    console.log(
-      "Raw OpenAI response:",
-      animationText.substring(0, 200) +
-        (animationText.length > 200 ? "..." : "")
-    );
-
-    // Parse JSON from the response
-    let animationConfig: RobotAnimationConfig;
-    try {
-      // Since we're using response_format: { type: "json_object" }, this should always be valid JSON
-      animationConfig = JSON.parse(animationText);
-    } catch (e) {
-      console.error("Failed to parse JSON response:", e);
-      throw new Error(
-        "Could not parse animation configuration from AI response"
-      );
-    }
-
-    // Validate the animation config against our RobotAnimationConfig type
-    if (!animationConfig.joints || !Array.isArray(animationConfig.joints)) {
-      throw new Error(
-        "Invalid animation configuration: missing or invalid joints array"
-      );
-    }
-
-    // Default speedMultiplier if not provided
-    if (animationConfig.speedMultiplier === undefined) {
-      animationConfig.speedMultiplier = 1.0;
-    } else if (typeof animationConfig.speedMultiplier !== "number") {
-      throw new Error("Invalid speedMultiplier: must be a number");
-    }
-
-    // Validate all joints have required properties and correct types
-    for (const joint of animationConfig.joints) {
-      // Check required properties
-      if (!joint.name || typeof joint.name !== "string") {
-        throw new Error("Invalid joint: name is required and must be a string");
-      }
-
-      if (!joint.type || !["sine", "linear", "constant"].includes(joint.type)) {
-        throw new Error(
-          `Invalid joint type: ${joint.type} for joint ${joint.name}. Must be "sine", "linear", or "constant"`
-        );
-      }
-
-      if (joint.min === undefined || typeof joint.min !== "number") {
-        throw new Error(
-          `Invalid min value for joint ${joint.name}: must be a number`
-        );
-      }
-
-      if (joint.max === undefined || typeof joint.max !== "number") {
-        throw new Error(
-          `Invalid max value for joint ${joint.name}: must be a number`
-        );
-      }
-
-      if (joint.speed === undefined || typeof joint.speed !== "number") {
-        throw new Error(
-          `Invalid speed value for joint ${joint.name}: must be a number`
-        );
-      }
-
-      if (joint.offset === undefined || typeof joint.offset !== "number") {
-        throw new Error(
-          `Invalid offset value for joint ${joint.name}: must be a number`
-        );
-      }
-
-      // Check optional properties
-      if (
-        joint.isDegrees !== undefined &&
-        typeof joint.isDegrees !== "boolean"
-      ) {
-        throw new Error(
-          `Invalid isDegrees value for joint ${joint.name}: must be a boolean`
-        );
-      }
-
-      // Ensure no custom properties that aren't in our type
-      const allowedProperties = [
-        "name",
-        "type",
-        "min",
-        "max",
-        "speed",
-        "offset",
-        "isDegrees",
-      ];
-      const extraProperties = Object.keys(joint).filter(
-        (key) => !allowedProperties.includes(key)
-      );
-
-      if (extraProperties.length > 0) {
-        console.warn(
-          `Warning: Joint ${
-            joint.name
-          } has extra properties not in JointAnimationConfig: ${extraProperties.join(
-            ", "
-          )}`
-        );
-        // Remove extra properties to ensure exact type match
-        extraProperties.forEach((prop) => {
-          delete joint[prop];
-        });
-      }
-    }
-
-    // Clean the final object to ensure it matches our type exactly
-    const cleanedConfig: RobotAnimationConfig = {
-      joints: animationConfig.joints.map((joint) => ({
-        name: joint.name,
-        type: joint.type,
-        min: joint.min,
-        max: joint.max,
-        speed: joint.speed,
-        offset: joint.offset,
-        ...(joint.isDegrees !== undefined && { isDegrees: joint.isDegrees }),
-      })),
-      speedMultiplier: animationConfig.speedMultiplier,
-    };
-
-    // Log the cleaned config for debugging
-    console.log(
-      `Cleaned config: ${cleanedConfig.joints.length} joints, speedMultiplier: ${cleanedConfig.speedMultiplier}`
-    );
-
-    return cleanedConfig;
-  } catch (error) {
-    console.error("Error generating animation:", error);
-    // Return a simple default animation if generation fails
-
-    // Get at most 2 movable joints to animate
-    const jointsToAnimate = movableJoints.slice(0, 2);
-
-    if (jointsToAnimate.length === 0) {
-      // If no movable joints found, create a message
-      throw new Error(
-        "Cannot generate animation: No movable joints found in the robot model"
-      );
-    }
-
-    // Create a simple, safe animation for the available joints
-    const fallbackConfig: RobotAnimationConfig = {
-      joints: jointsToAnimate.map((joint) => ({
-        name: joint.name,
-        type: "sine" as const,
-        min: joint.limits?.lower !== undefined ? joint.limits.lower : -0.5,
-        max: joint.limits?.upper !== undefined ? joint.limits.upper : 0.5,
-        speed: 1.0,
-        offset: 0,
-        isDegrees: false,
-      })),
-      speedMultiplier: 1.0,
-    };
-
-    console.log("Using fallback animation config:", fallbackConfig);
-    return fallbackConfig;
-  }
-}
-
-// Parse URDF XML and extract joint information
-function parseUrdfForJoints(urdfContent: string): URDFJoint[] {
-  const parser = new XMLParser({
-    ignoreAttributes: false,
-    attributeNamePrefix: "",
-    parseAttributeValue: true,
-  });
-
-  try {
-    const doc = parser.parse(urdfContent);
-
-    if (!doc || !doc.robot) {
-      throw new Error("No robot element found in URDF");
-    }
-
-    // Extract joints
-    const joints: URDFJoint[] = [];
-    const robotElement = doc.robot;
-
-    if (robotElement.joint) {
-      const jointElements = Array.isArray(robotElement.joint)
-        ? robotElement.joint
-        : [robotElement.joint];
-
-      jointElements.forEach((joint: URDFElement) => {
-        const jointData: URDFJoint = {
-          name: joint.name || "",
-          type: joint.type || "",
-          parent: joint.parent?.link || "",
-          child: joint.child?.link || "",
-        };
-
-        // Parse axis
-        if (joint.axis) {
-          jointData.axis = {
-            xyz: joint.axis.xyz || "0 0 0",
-          };
-        }
-
-        // Parse origin
-        if (joint.origin) {
-          jointData.origin = {
-            xyz: joint.origin.xyz || "0 0 0",
-            rpy: joint.origin.rpy || "0 0 0",
-          };
-        }
-
-        // Parse limits
-        if (joint.limit) {
-          jointData.limits = {
-            lower:
-              joint.limit.lower !== undefined ? joint.limit.lower : undefined,
-            upper:
-              joint.limit.upper !== undefined ? joint.limit.upper : undefined,
-            effort:
-              joint.limit.effort !== undefined ? joint.limit.effort : undefined,
-            velocity:
-              joint.limit.velocity !== undefined
-                ? joint.limit.velocity
-                : undefined,
-          };
-        }
-
-        joints.push(jointData);
-      });
-    }
-
-    return joints;
-  } catch (error) {
-    console.error("Error parsing URDF XML:", error);
-    throw new Error(
-      `Could not parse URDF: ${
-        error instanceof Error ? error.message : String(error)
-      }`
-    );
-  }
-}
-
-// Main server function
-serve(async (req) => {
-  // Handle CORS preflight requests
-  if (req.method === "OPTIONS") {
-    return new Response("ok", { headers: corsHeaders });
-  }
-
-  try {
-    if (req.method !== "POST") {
-      throw new Error("Method not allowed");
-    }
-
-    // Parse request
-    const requestData: AnimationRequest = await req.json();
-    const { robotName, urdfContent, description } = requestData;
-
-    if (!urdfContent) {
-      throw new Error("No URDF content provided");
-    }
-
-    if (!description) {
-      throw new Error("No animation description provided");
-    }
-
-    console.log(
-      `Generating animation for ${robotName}: "${description.substring(
-        0,
-        100
-      )}..."`
-    );
-
-    // Parse URDF to extract joint information
-    const joints = parseUrdfForJoints(urdfContent);
-    console.log(`Extracted ${joints.length} joints from URDF`);
-
-    // Generate animation configuration
-    const animationConfig = await generateAnimationConfig(
-      joints,
-      description,
-      robotName
-    );
-    console.log(
-      `Generated animation with ${animationConfig.joints.length} animated joints`
-    );
-
-    // Return the animation configuration
-    return new Response(JSON.stringify(animationConfig), {
-      headers: {
-        ...corsHeaders,
-        "Content-Type": "application/json",
-      },
-    });
-  } catch (error) {
-    console.error("Error processing animation request:", error);
-
-    return new Response(
-      JSON.stringify({
-        error:
-          error instanceof Error ? error.message : "Unknown error occurred",
-      }),
-      {
-        status: 500,
-        headers: {
-          ...corsHeaders,
-          "Content-Type": "application/json",
-        },
-      }
-    );
-  }
-});