change the way we check the dataset version (#8)

src/utils/versionUtils.ts

@@ -5,13 +5,31 @@
 const DATASET_URL = process.env.DATASET_URL || "https://huggingface.co/datasets";
 
 /**
- * Checks if a specific version/branch exists for a dataset
+ * Dataset information structure from info.json
  */
-async function checkVersionExists(repoId: string, version: string): Promise<boolean> {
+interface DatasetInfo {
+  codebase_version: string;
+  robot_type: string | null;
+  total_episodes: number;
+  total_frames: number;
+  total_tasks: number;
+  chunks_size: number;
+  data_files_size_in_mb: number;
+  video_files_size_in_mb: number;
+  fps: number;
+  splits: Record<string, string>;
+  data_path: string;
+  video_path: string;
+  features: Record<string, any>;
+}
+
+/**
+ * Fetches dataset information from the main revision
+ */
+export async function getDatasetInfo(repoId: string): Promise<DatasetInfo> {
   try {
-    const testUrl = `${DATASET_URL}/${repoId}/resolve/${version}/meta/info.json`;
+    const testUrl = `${DATASET_URL}/${repoId}/resolve/main/meta/info.json`;
     
-    // Try a simple GET request with a timeout
     const controller = new AbortController();
     const timeoutId = setTimeout(() => controller.abort(), 10000); // 10 second timeout
     
@@ -23,88 +41,66 @@ async function checkVersionExists(repoId: string, version: string): Promise<bool
     
     clearTimeout(timeoutId);
     
-    // Check if it's a successful response
-    if (response.ok) {
-      // Try to parse a bit of the JSON to make sure it's valid
-      try {
-        const text = await response.text();
-        const data = JSON.parse(text);
-        return !!data.features; // Only return true if it has features
-      } catch (parseError) {
-        return false;
-      }
+    if (!response.ok) {
+      throw new Error(`Failed to fetch dataset info: ${response.status}`);
+    }
+
+    const data = await response.json();
+    
+    // Check if it has the required structure
+    if (!data.features) {
+      throw new Error("Dataset info.json does not have the expected features structure");
     }
     
-    return false;
+    return data as DatasetInfo;
   } catch (error) {
-    return false;
+    if (error instanceof Error) {
+      throw error;
+    }
+    throw new Error(
+      `Dataset ${repoId} is not compatible with this visualizer. ` +
+      "Failed to read dataset information from the main revision."
+    );
   }
 }
 
+
 /**
- * Checks if a dataset has v3.0 chunked structure
+ * Gets the dataset version by reading the codebase_version from the main revision's info.json
  */
-async function checkV3ChunkedStructure(repoId: string): Promise<boolean> {
+export async function getDatasetVersion(repoId: string): Promise<string> {
   try {
-    const testUrl = `${DATASET_URL}/${repoId}/resolve/v3.0/meta/episodes/chunk-000/file-000.parquet`;
-    
-    const controller = new AbortController();
-    const timeoutId = setTimeout(() => controller.abort(), 10000);
+    const datasetInfo = await getDatasetInfo(repoId);
     
-    const response = await fetch(testUrl, { 
-      method: "HEAD",
-      cache: "no-store",
-      signal: controller.signal
-    });
+    // Extract codebase_version
+    const codebaseVersion = datasetInfo.codebase_version;
+    if (!codebaseVersion) {
+      throw new Error("Dataset info.json does not contain codebase_version");
+    }
     
-    clearTimeout(timeoutId);
+    // Validate that it's a supported version
+    const supportedVersions = ["v3.0", "v2.1", "v2.0"];
+    if (!supportedVersions.includes(codebaseVersion)) {
+      throw new Error(
+        `Dataset ${repoId} has codebase version ${codebaseVersion}, which is not supported. ` +
+        "This tool only works with dataset versions 3.0, 2.1, or 2.0. " +
+        "Please use a compatible dataset version."
+      );
+    }
     
-    return response.ok;
+    return codebaseVersion;
   } catch (error) {
-    return false;
-  }
-}
-
-/**
- * Determines the best available version for a dataset.
- * Prefers v3.0, falls back to v2.1, then v2.0, or throws an error if none exist.
- */
-export async function getDatasetVersion(repoId: string): Promise<string> {
-  // Check for v3.0 first - must have both info.json AND chunked episode structure
-  const hasV3Info = await checkVersionExists(repoId, "v3.0");
-  
-  if (hasV3Info) {
-    const hasV3Structure = await checkV3ChunkedStructure(repoId);
-    
-    if (hasV3Structure) {
-      return "v3.0";
+    if (error instanceof Error) {
+      throw error;
     }
+    throw new Error(
+      `Dataset ${repoId} is not compatible with this visualizer. ` +
+      "Failed to read dataset information from the main revision."
+    );
   }
-  
-  // Check for v2.1
-  const hasV21 = await checkVersionExists(repoId, "v2.1");
-  if (hasV21) {
-    return "v2.1";
-  }
-  
-  // Fall back to v2.0
-  const hasV20 = await checkVersionExists(repoId, "v2.0");
-  if (hasV20) {
-    return "v2.0";
-  }
-  
-  // If none of the supported versions exist, throw an error
-  throw new Error(
-    `Dataset ${repoId} is not compatible with this visualizer. ` +
-    "This tool only works with dataset versions 3.0, 2.1, or 2.0. " +
-    "Please use a compatible dataset version."
-  );
 }
 
-/**
- * Constructs a versioned URL for dataset resources
- */
 export function buildVersionedUrl(repoId: string, version: string, path: string): string {
-  return `${DATASET_URL}/${repoId}/resolve/${version}/${path}`;
+  return `${DATASET_URL}/${repoId}/resolve/main/${path}`;
 }