Use full version tags (v0.16.0, v0.16.4) instead of minor versions

Author: milanofthe

scripts/extract-versions.py

@@ -101,14 +101,15 @@ def version_gte(version: str, min_version: str) -> bool:
 
 
 def get_cached_versions(package_id: str) -> set[str]:
-    """Get set of already cached version strings for a package."""
+    """Get set of already cached version tags for a package."""
     package_dir = VERSIONS_DIR / package_id
     if not package_dir.exists():
         return set()
 
     cached = set()
     for f in package_dir.glob("v*.json"):
-        match = re.match(r"^v(\d+\.\d+)\.json$", f.name)
+        # Match full version tags like v0.16.0.json or v0.16.4.json
+        match = re.match(r"^(v\d+\.\d+\.\d+)\.json$", f.name)
         if match:
             cached.add(match.group(1))
     return cached
@@ -243,67 +244,68 @@ def extract_package_versions(
     print(f"  Historical vX.Y.0 versions: {sorted(supported_historical.keys(), key=parse_minor_version, reverse=True)}")
 
     # Determine which versions to extract
+    # Now using full tags (e.g., v0.16.0, v0.16.4) not just minor versions
     cached = get_cached_versions(package_id)
 
-    # Build extraction list
-    versions_to_extract = []
+    # Build extraction list: all vX.Y.0 tags + latest patch if different
+    versions_to_extract = []  # List of (tag, is_latest) tuples
 
     if extract_all:
-        # Extract all historical vX.Y.0 versions
+        # Extract all vX.Y.0 versions
         for minor_version, tag in sorted(supported_historical.items(), key=lambda x: parse_minor_version(x[0]), reverse=True):
-            # Skip if this is the latest minor (we'll add the actual latest tag separately)
-            if minor_version != latest_minor:
-                versions_to_extract.append((minor_version, tag))
-        print(f"  Mode: Extract ALL historical ({len(versions_to_extract)} versions) + latest")
+            versions_to_extract.append((tag, False))
+        # Add latest if it's a patch release (not .0)
+        if latest_tag not in [t for t, _ in versions_to_extract]:
+            versions_to_extract.append((latest_tag, True))
+        print(f"  Mode: Extract ALL ({len(versions_to_extract)} versions)")
     else:
-        # Smart mode: only missing historical + latest
+        # Smart mode: only missing .0 versions + always re-extract latest
         for minor_version, tag in sorted(supported_historical.items(), key=lambda x: parse_minor_version(x[0]), reverse=True):
-            # Skip if this is the latest minor (we'll add the actual latest tag separately)
-            if minor_version == latest_minor:
-                continue
-            if minor_version not in cached:
-                versions_to_extract.append((minor_version, tag))
+            if tag not in cached:
+                versions_to_extract.append((tag, False))
 
-        missing_count = len(versions_to_extract)
-        print(f"  Mode: Smart extraction")
-        print(f"    Cached: {len(cached)} versions")
-        print(f"    Missing historical: {missing_count} versions")
+        # Always add latest (will be re-extracted)
+        # Mark as latest so we know to always extract it
+        versions_to_extract.append((latest_tag, True))
 
-    # Always add the latest tag (uses actual latest, not necessarily vX.Y.0)
-    versions_to_extract.append((latest_minor, latest_tag))
-    print(f"    Latest ({latest_tag}): will {'re-' if latest_minor in cached else ''}extract")
-    print(f"    Total to extract: {len(versions_to_extract)} versions")
+        missing_count = len([t for t, is_latest in versions_to_extract if not is_latest])
+        print(f"  Mode: Smart extraction")
+        print(f"    Cached: {len(cached)} tags")
+        print(f"    Missing .0 releases: {missing_count}")
+        print(f"    Latest ({latest_tag}): will {'re-' if latest_tag in cached else ''}extract")
+        print(f"    Total to extract: {len(versions_to_extract)} versions")
 
     extracted = []
     output_dir = VERSIONS_DIR / package_id
     output_dir.mkdir(parents=True, exist_ok=True)
 
-    for minor_version, tag in versions_to_extract:
-        is_latest = minor_version == latest_minor
-        is_cached = minor_version in cached
+    for tag, is_latest in versions_to_extract:
+        is_cached = tag in cached
         status = "LATEST" if is_latest else ("NEW" if not is_cached else "cached")
+        # Extract version string from tag (e.g., "v0.16.4" -> "0.16.4")
+        version_str = tag[1:] if tag.startswith('v') else tag
 
-        print(f"\n  Version {minor_version} (tag: {tag}) [{status}]")
+        print(f"\n  {tag} [{status}]")
 
         if dry_run:
-            print(f"    Would extract to: {output_dir / f'v{minor_version}.json'}")
+            print(f"    Would extract to: {output_dir / f'{tag}.json'}")
             extracted.append({
-                "version": minor_version,
                 "tag": tag,
                 "released": "",
+                "latest": is_latest,
             })
             continue
 
         # Checkout the tag
         if not git_checkout(repo_path, tag):
             continue
 
-        # Run extraction
-        if run_extraction(package_id, minor_version, VERSIONS_DIR):
+        # Run extraction - pass full version string (e.g., "0.16.4")
+        if run_extraction(package_id, version_str, VERSIONS_DIR):
             extracted.append({
-                "version": minor_version,
                 "tag": tag,
                 "released": get_tag_date(repo_path, tag),
+                "latest": is_latest,
             })
             print(f"    ✓ Extracted successfully")
         else:

scripts/generate-manifests.py

@@ -30,27 +30,27 @@
 }
 
 
-def parse_version(version: str) -> tuple[int, int]:
-    """Parse version string into (major, minor) tuple."""
-    match = re.match(r"^(\d+)\.(\d+)$", version)
+def parse_version(version: str) -> tuple[int, int, int]:
+    """Parse version string into (major, minor, patch) tuple."""
+    match = re.match(r"^(\d+)\.(\d+)\.(\d+)$", version)
     if not match:
-        return (0, 0)
-    return (int(match.group(1)), int(match.group(2)))
+        return (0, 0, 0)
+    return (int(match.group(1)), int(match.group(2)), int(match.group(3)))
 
 
 def get_version_files(package_dir: Path) -> list[str]:
     """Get all version JSON files in a package directory."""
     if not package_dir.exists():
         return []
 
-    versions = []
+    tags = []
     for f in package_dir.glob("v*.json"):
-        # Extract version from filename (e.g., "v0.16.json" -> "0.16")
-        match = re.match(r"^v(\d+\.\d+)\.json$", f.name)
+        # Extract full tag from filename (e.g., "v0.16.4.json" -> "v0.16.4")
+        match = re.match(r"^(v\d+\.\d+\.\d+)\.json$", f.name)
         if match:
-            versions.append(match.group(1))
+            tags.append(match.group(1))
 
-    return versions
+    return tags
 
 
 def get_tag_for_version(repo_path: Path, version: str) -> str:
@@ -105,36 +105,38 @@ def get_tag_date(repo_path: Path, tag: str) -> str:
 def generate_manifest(package_id: str, dry_run: bool = False) -> dict[str, Any] | None:
     """Generate manifest for a single package."""
     package_dir = VERSIONS_DIR / package_id
-    versions = get_version_files(package_dir)
+    tags = get_version_files(package_dir)
 
-    if not versions:
+    if not tags:
         print(f"  No version files found in {package_dir}")
         return None
 
-    # Sort versions (newest first)
-    sorted_versions = sorted(versions, key=parse_version, reverse=True)
-    latest_version = sorted_versions[0]
+    # Sort tags by version (newest first)
+    def tag_to_version(tag: str) -> tuple[int, int, int]:
+        version_str = tag[1:] if tag.startswith('v') else tag
+        return parse_version(version_str)
 
-    print(f"  Found {len(versions)} versions: {sorted_versions}")
-    print(f"  Latest: {latest_version}")
+    sorted_tags = sorted(tags, key=tag_to_version, reverse=True)
+    latest_tag = sorted_tags[0]
+
+    print(f"  Found {len(tags)} versions: {sorted_tags}")
+    print(f"  Latest: {latest_tag}")
 
     # Build version info list
     repo_path = PACKAGE_REPOS.get(package_id)
     version_infos = []
 
-    for version in sorted_versions:
-        tag = get_tag_for_version(repo_path, version) if repo_path else f"v{version}.0"
+    for tag in sorted_tags:
         released = get_tag_date(repo_path, tag) if repo_path else ""
 
         version_infos.append({
-            "version": version,
             "tag": tag,
             "released": released,
         })
 
     manifest = {
         "package": package_id,
-        "latestVersion": latest_version,
+        "latestTag": latest_tag,
         "versions": version_infos,
     }
 

src/lib/api/versions.ts

@@ -3,14 +3,13 @@ import { base } from '$app/paths';
 import type { APIPackage } from './generated';
 
 export interface VersionInfo {
-	version: string;
 	tag: string;
 	released: string;
 }
 
 export interface PackageManifest {
 	package: string;
-	latestVersion: string;
+	latestTag: string;
 	versions: VersionInfo[];
 }
 
@@ -32,39 +31,41 @@ export async function getVersionManifest(
 }
 
 /**
- * Fetch versioned API data for a specific package version
+ * Fetch versioned API data for a specific package version tag
  */
 export async function getVersionedApiData(
 	packageId: string,
-	version: string,
+	tag: string,
 	fetch: typeof globalThis.fetch
 ): Promise<APIPackage> {
-	const url = `${base}/api/versions/${packageId}/v${version}.json`;
+	// Ensure tag has 'v' prefix
+	const normalizedTag = tag.startsWith('v') ? tag : `v${tag}`;
+	const url = `${base}/api/versions/${packageId}/${normalizedTag}.json`;
 	const response = await fetch(url);
 
 	if (!response.ok) {
-		throw new Error(`Failed to load API data for ${packageId} v${version}: ${response.status}`);
+		throw new Error(`Failed to load API data for ${packageId} ${normalizedTag}: ${response.status}`);
 	}
 
 	return response.json();
 }
 
 /**
- * Resolve a version string to an actual version number
- * - 'latest' -> actual latest version from manifest
- * - undefined -> actual latest version from manifest
- * - 'v0.16' or '0.16' -> '0.16'
+ * Resolve a version/tag string to an actual tag
+ * - 'latest' -> actual latest tag from manifest
+ * - undefined -> actual latest tag from manifest
+ * - 'v0.16.4' or '0.16.4' -> 'v0.16.4'
  */
-export function resolveVersion(version: string | undefined, manifest: PackageManifest): string {
-	if (!version || version === 'latest') {
-		return manifest.latestVersion;
+export function resolveTag(tagOrVersion: string | undefined, manifest: PackageManifest): string {
+	if (!tagOrVersion || tagOrVersion === 'latest') {
+		return manifest.latestTag;
 	}
 
-	// Strip leading 'v' if present
-	const normalized = version.startsWith('v') ? version.slice(1) : version;
+	// Normalize to have 'v' prefix
+	const normalized = tagOrVersion.startsWith('v') ? tagOrVersion : `v${tagOrVersion}`;
 
-	// Validate the version exists in manifest
-	const exists = manifest.versions.some((v) => v.version === normalized);
+	// Validate the tag exists in manifest
+	const exists = manifest.versions.some((v) => v.tag === normalized);
 	if (!exists) {
 		throw new Error(`Version ${normalized} not found for ${manifest.package}`);
 	}
@@ -73,18 +74,19 @@ export function resolveVersion(version: string | undefined, manifest: PackageMan
 }
 
 /**
- * Check if a version is the latest version
+ * Check if a tag is the latest tag
  */
-export function isLatestVersion(version: string, manifest: PackageManifest): boolean {
-	return version === manifest.latestVersion;
+export function isLatestTag(tag: string, manifest: PackageManifest): boolean {
+	const normalized = tag.startsWith('v') ? tag : `v${tag}`;
+	return normalized === manifest.latestTag;
 }
 
 /**
- * Get the display label for a version
+ * Get the display label for a tag
  */
-export function getVersionLabel(version: string, manifest: PackageManifest): string {
-	if (isLatestVersion(version, manifest)) {
-		return `v${version} (latest)`;
+export function getTagLabel(tag: string, manifest: PackageManifest): string {
+	if (isLatestTag(tag, manifest)) {
+		return `${tag} (latest)`;
 	}
-	return `v${version}`;
+	return tag;
 }

src/lib/components/api/VersionSelector.svelte

@@ -3,15 +3,15 @@
 	import { base } from '$app/paths';
 	import Icon from '$lib/components/common/Icon.svelte';
 	import type { PackageManifest } from '$lib/api/versions';
-	import { isLatestVersion } from '$lib/api/versions';
+	import { isLatestTag } from '$lib/api/versions';
 
 	interface Props {
 		packageId: string;
-		currentVersion: string;
+		currentTag: string;
 		manifest: PackageManifest;
 	}
 
-	let { packageId, currentVersion, manifest }: Props = $props();
+	let { packageId, currentTag, manifest }: Props = $props();
 
 	let isOpen = $state(false);
 	let dropdownRef: HTMLDivElement | null = $state(null);
@@ -20,14 +20,15 @@
 		isOpen = !isOpen;
 	}
 
-	function selectVersion(version: string) {
+	function selectTag(tag: string) {
 		isOpen = false;
 
 		// Preserve current hash if it exists
 		const hash = typeof window !== 'undefined' ? window.location.hash : '';
 
-		// Navigate to the new version
-		const versionPath = isLatestVersion(version, manifest) ? '' : `/v${version}`;
+		// Navigate to the new version (strip 'v' prefix for URL)
+		const versionStr = tag.startsWith('v') ? tag.slice(1) : tag;
+		const versionPath = isLatestTag(tag, manifest) ? '' : `/${tag}`;
 		goto(`${base}/${packageId}/api${versionPath}${hash}`);
 	}
 
@@ -56,21 +57,20 @@
 </script>
 
 <div class="version-selector" bind:this={dropdownRef}>
-	{@const currentInfo = manifest.versions.find(v => v.version === currentVersion)}
 	<button class="version-trigger" onclick={toggleDropdown} aria-expanded={isOpen}>
-		<span class="version-text">{currentInfo?.tag ?? `v${currentVersion}`}</span>
+		<span class="version-text">{currentTag}</span>
 		<Icon name="chevron-down" size={10} />
 	</button>
 
 	{#if isOpen}
 		<div class="dropdown">
 			{#each manifest.versions as v}
-				{@const isSelected = v.version === currentVersion}
-				{@const isLatest = isLatestVersion(v.version, manifest)}
+				{@const isSelected = v.tag === currentTag}
+				{@const isLatest = isLatestTag(v.tag, manifest)}
 				<button
 					class="dropdown-item"
 					class:selected={isSelected}
-					onclick={() => selectVersion(v.version)}
+					onclick={() => selectTag(v.tag)}
 				>
 					<span class="dropdown-version">{v.tag}</span>
 					{#if isLatest}