fix: enhance cache management and validation logic

- Updated cache saving logic in `DownloadCache` to trigger more frequently, reducing the risk of data loss.
- Improved GitHub token validation in `GHFolderDownloadConfig` to support various valid formats and provide clearer error messages.
- Refined input validation patterns in `InputValidator` for better accuracy in GitHub username/org checks.
- Enhanced regex in `_parse_size_string` for stricter matching of size strings, ensuring valid input.
- Improved error handling in `RetryHandler` for better matching of temporary error indicators.

Author: leynier

gh_folder_download/cache.py

@@ -208,8 +208,9 @@ def add_file_to_cache(
         self.cache_data[cache_key] = cache_entry
         self.logger.debug(f"Added file to cache: {file_path}")
 
-        # Save cache periodically (every 10 new entries) or when cache is small
-        if len(self.cache_data) % 10 == 0 or len(self.cache_data) <= 5:
+        # Save cache more frequently to prevent data loss
+        # (every 5 new entries) or when cache is small
+        if len(self.cache_data) % 5 == 0 or len(self.cache_data) <= 3:
             self._save_cache()
 
     def get_cached_checksums(
@@ -283,4 +284,7 @@ def clear_cache(self) -> None:
 
     def finalize(self) -> None:
         """Finalize cache operations (save to disk)."""
-        self._save_cache()
+        # Always save to ensure no data loss
+        if self.cache_data:
+            self._save_cache()
+            self.logger.debug("Cache finalized and saved")

gh_folder_download/config.py

@@ -3,6 +3,7 @@
 """
 
 import os
+import re
 import sys
 from pathlib import Path
 from typing import Any
@@ -146,10 +147,36 @@ class GHFolderDownloadConfig(BaseModel):
     @validator("github_token", pre=True)
     def validate_github_token(cls, v):
         """Validate GitHub token format."""
-        if v and not isinstance(v, str):
+        if not v:
+            return v
+
+        if not isinstance(v, str):
             raise ValueError("GitHub token must be a string")
-        if v and len(v) < 10:
-            raise ValueError("GitHub token appears to be too short")
+
+        v = v.strip()
+        if not v:
+            return None
+
+        # Check for valid GitHub token formats
+
+        is_valid_format = False
+
+        if v.startswith("ghp_") and len(v) == 40:
+            # Classic personal access token
+            is_valid_format = True
+        elif v.startswith("github_pat_") and len(v) >= 50:
+            # Fine-grained personal access token
+            is_valid_format = True
+        elif len(v) == 40:
+            # Legacy format - must be hexadecimal
+            is_valid_format = bool(re.match(r"^[a-fA-F0-9]{40}$", v))
+
+        if not is_valid_format:
+            raise ValueError(
+                "Invalid GitHub token format. Expected: classic (ghp_...), "
+                "fine-grained (github_pat_...), or legacy (40-char hex) token."
+            )
+
         return v
 
 
@@ -277,6 +304,9 @@ def _set_nested_value(self, data: dict[str, Any], path: str, value: Any) -> None
 
     def _convert_env_value(self, value: str) -> Any:
         """Convert environment variable string to appropriate type."""
+        if not value:
+            return value
+
         # Boolean values
         if value.lower() in ("true", "1", "yes", "on"):
             return True
@@ -285,14 +315,22 @@ def _convert_env_value(self, value: str) -> Any:
 
         # Numeric values
         try:
+            # Check for float first (contains decimal point)
             if "." in value:
-                return float(value)
+                parsed_float = float(value)
+                # Ensure it's a valid number (not NaN or infinity)
+                if not (
+                    parsed_float != parsed_float or abs(parsed_float) == float("inf")
+                ):
+                    return parsed_float
             else:
-                return int(value)
-        except ValueError:
+                parsed_int = int(value)
+                return parsed_int
+        except (ValueError, OverflowError):
+            # If numeric parsing fails, continue to return as string
             pass
 
-        # String value
+        # String value (default)
         return value
 
     def save_config(self, file_path: Path | None = None) -> bool:
@@ -375,15 +413,15 @@ def create_sample_config(self, file_path: Path | None = None) -> bool:
   # Extension filters (include/exclude specific file types)
   # include_extensions: [".py", ".js", ".md"]
   # exclude_extensions: [".log", ".tmp"]
-  
+
   # Size filters
   # min_size_bytes: 1024      # Minimum file size in bytes
   # max_size_bytes: 10485760  # Maximum file size in bytes (10MB)
-  
+
   # Pattern filters (glob patterns)
   # include_patterns: ["src/**", "docs/**"]
   # exclude_patterns: ["**/test/**", "**/*.pyc"]
-  
+
   # Special filters
   exclude_binary: false        # Exclude binary files
   exclude_large_files: false   # Exclude files larger than 10MB

gh_folder_download/main.py

@@ -960,14 +960,18 @@ def _parse_size_string(size_str: str) -> int | None:
     # Try to extract number and unit
     import re
 
-    match = re.match(r"^(\d*\.?\d+)\s*([KMGT]?B?)$", size_str)
+    # Fixed regex: requires at least one digit, properly handles decimal numbers
+    match = re.match(r"^(\d+(?:\.\d+)?)\s*([KMGT]?B?)$", size_str)
     if not match:
         return None
 
     number_str, unit = match.groups()
 
     try:
         number = float(number_str)
+        # Ensure positive number
+        if number < 0:
+            return None
     except ValueError:
         return None
 

gh_folder_download/rate_limiter.py

@@ -113,7 +113,9 @@ def _update_rate_limit_info(self) -> None:
     def _should_update_rate_limit(self) -> bool:
         """Check if rate limit info should be updated."""
         # Update every 30 seconds or if we don't have info
-        return self._core_rate_limit is None or time.time() - self._last_update > 30
+        # Protected access to _last_update to prevent race conditions
+        with self._lock:
+            return self._core_rate_limit is None or time.time() - self._last_update > 30
 
     def _calculate_adaptive_delay(self, rate_limit: RateLimitInfo) -> float:
         """Calculate adaptive delay based on current rate limit status."""

gh_folder_download/retry.py

@@ -2,6 +2,7 @@
 Retry mechanism with exponential backoff for gh-folder-download.
 """
 
+import re
 import time
 from functools import wraps
 from typing import Any, Callable, cast
@@ -154,7 +155,12 @@ def _is_retryable(self, exception: Exception) -> bool:
             "rate limit",
         ]
 
-        return any(indicator in error_msg for indicator in temporary_indicators)
+        # Use word boundaries for more accurate matching
+
+        return any(
+            re.search(rf"\b{re.escape(indicator)}\b", error_msg)
+            for indicator in temporary_indicators
+        )
 
     def _calculate_delay(self, attempt: int, config: RetryConfig) -> float:
         """Calculate delay for the next retry attempt."""

gh_folder_download/validation.py

@@ -25,8 +25,8 @@ class InputValidator:
         r"^https://github\.com/([a-zA-Z0-9._-]+)/([a-zA-Z0-9._-]+)(?:/tree/([a-zA-Z0-9._/-]+))?(?:/(.+))?$"
     )
 
-    # Valid GitHub username/org pattern
-    GITHUB_NAME_PATTERN = re.compile(r"^[a-zA-Z0-9._-]+$")
+    # Valid GitHub username/org pattern - must start and end with alphanumeric
+    GITHUB_NAME_PATTERN = re.compile(r"^[a-zA-Z0-9]([a-zA-Z0-9._-]*[a-zA-Z0-9])?$")
 
     def __init__(self):
         self.logger = get_logger()
@@ -194,12 +194,24 @@ def validate_github_token(self, token: str | None) -> str | None:
         # GitHub token patterns
         # Classic personal access tokens: ghp_xxxx (40 chars total)
         # Fine-grained personal access tokens: github_pat_xxxx
-        if not (
-            (token.startswith("ghp_") and len(token) == 40)
-            or (token.startswith("github_pat_") and len(token) >= 50)
-            or (len(token) == 40 and token.isalnum())  # Legacy format
-        ):
-            self.logger.warning("Token format doesn't match expected GitHub patterns")
+        # Legacy tokens: 40-char hex strings
+        is_valid_format = False
+
+        if token.startswith("ghp_") and len(token) == 40:
+            # Classic personal access token
+            is_valid_format = True
+        elif token.startswith("github_pat_") and len(token) >= 50:
+            # Fine-grained personal access token
+            is_valid_format = True
+        elif len(token) == 40:
+            # Legacy format - must be hexadecimal
+            is_valid_format = bool(re.match(r"^[a-fA-F0-9]{40}$", token))
+
+        if not is_valid_format:
+            raise ValidationError(
+                "Invalid GitHub token format. Expected: classic (ghp_...), "
+                "fine-grained (github_pat_...), or legacy (40-char hex) token."
+            )
 
         # Test token validity
         try: