feat: add cache versioning for forward compatibility

- Add CACHE_VERSION constant (v1) to track cache format
- Update CodeownersCache to include version field
- Update Serialize/Deserialize to handle version
- Check version on load and rebuild if outdated
- Handle deserialization failures gracefully by rebuilding
- Remove redundant cache verification load in parse command

This ensures that cache format changes trigger automatic rebuilds
instead of cryptic deserialization errors.

Author: claude

codeinput/src/core/cache.rs

@@ -5,7 +5,7 @@ use crate::{
         resolver::find_owners_and_tags_for_file,
         types::{
             codeowners_entry_to_matcher, CacheEncoding, CodeownersCache, CodeownersEntry,
-            CodeownersEntryMatcher, FileEntry,
+            CodeownersEntryMatcher, FileEntry, CACHE_VERSION,
         },
     },
     utils::error::{Error, Result},
@@ -121,6 +121,7 @@ pub fn build_cache(
     }
 
     Ok(CodeownersCache {
+        version: CACHE_VERSION,
         hash,
         entries,
         files: file_entries,
@@ -219,21 +220,32 @@ pub fn sync_cache(
     }
 
     // Load the cache from the specified file
-    let cache = load_cache(&repo.join(cache_file)).map_err(|e| {
-        crate::utils::error::Error::new(&format!(
-            "Failed to load cache from {}: {}",
-            cache_file.display(),
-            e
-        ))
-    })?;
+    let cache = match load_cache(&repo.join(cache_file)) {
+        Ok(cache) => cache,
+        Err(e) => {
+            // Cache is corrupted or incompatible format - rebuild it
+            log::info!("Cache could not be loaded ({}), rebuilding...", e);
+            return parse_repo(repo, cache_file);
+        }
+    };
+
+    // Check cache version - rebuild if outdated
+    if cache.version != CACHE_VERSION {
+        log::info!(
+            "Cache version mismatch (found v{}, expected v{}), rebuilding...",
+            cache.version,
+            CACHE_VERSION
+        );
+        return parse_repo(repo, cache_file);
+    }
 
     // verify the hash of the cache matches the current repo hash
     let current_hash = get_repo_hash(repo)?;
     let cache_hash = cache.hash;
 
     if cache_hash != current_hash {
         // parse the codeowners files and build the cache
-        return parse_repo(&repo, &cache_file);
+        return parse_repo(repo, cache_file);
     } else {
         return Ok(cache);
     }

codeinput/src/core/commands/parse.rs

@@ -1,6 +1,6 @@
 use crate::{
     core::{
-        cache::{build_cache, load_cache, store_cache},
+        cache::{build_cache, store_cache},
         common::{find_codeowners_files, find_files, get_repo_hash},
         parser::parse_codeowners,
         types::{CacheEncoding, CodeownersEntry},
@@ -46,8 +46,5 @@ pub fn run(
     // Store the cache in the specified file
     store_cache(&cache, &cache_file, encoding)?;
 
-    // Test the cache by loading it back
-    let _cache = load_cache(&cache_file)?;
-
     Ok(())
 }

codeinput/src/core/types.rs

@@ -249,11 +249,20 @@ pub struct FileEntry {
     pub tags: Vec<Tag>,
 }
 
+/// Current cache format version. Increment when making breaking changes.
+pub const CACHE_VERSION: u32 = 1;
+
 /// Pre-computed cache of CODEOWNERS information for fast lookups.
 ///
 /// The cache stores parsed CODEOWNERS rules, file ownership mappings,
 /// and reverse lookup indexes for efficient querying.
 ///
+/// # Cache Versioning
+///
+/// The cache includes a version field to detect incompatible formats.
+/// When loading an older cache version, the cache is automatically
+/// rebuilt to ensure compatibility.
+///
 /// # Cache Invalidation
 ///
 /// The cache is invalidated when the repository state changes, detected
@@ -263,6 +272,8 @@ pub struct FileEntry {
 /// - Unstaged file changes (excluding cache files themselves)
 #[derive(Debug)]
 pub struct CodeownersCache {
+    /// Cache format version for compatibility checking
+    pub version: u32,
     /// SHA-256 hash of the repository state for cache invalidation
     pub hash: [u8; 32],
     /// All parsed CODEOWNERS entries
@@ -282,7 +293,8 @@ impl Serialize for CodeownersCache {
     {
         use serde::ser::SerializeStruct;
 
-        let mut state = serializer.serialize_struct("CodeownersCache", 4)?;
+        let mut state = serializer.serialize_struct("CodeownersCache", 6)?;
+        state.serialize_field("version", &self.version)?;
         state.serialize_field("hash", &self.hash)?;
         state.serialize_field("entries", &self.entries)?;
         state.serialize_field("files", &self.files)?;
@@ -307,6 +319,7 @@ impl<'de> Deserialize<'de> for CodeownersCache {
     {
         #[derive(Deserialize)]
         struct CodeownersCacheHelper {
+            version: u32,
             hash: [u8; 32],
             entries: Vec<CodeownersEntry>,
             files: Vec<FileEntry>,
@@ -328,6 +341,7 @@ impl<'de> Deserialize<'de> for CodeownersCache {
         }
 
         Ok(CodeownersCache {
+            version: helper.version,
             hash: helper.hash,
             entries: helper.entries,
             files: helper.files,