imp(cache): initial implementation for repo change detection

Author: omarabid

core/Cargo.toml

@@ -14,6 +14,8 @@ ignore = "0.4.23"
 serde = { version = "1.0.219", features = ["derive"] }
 serde_json = "1.0.140"
 bincode = {version= "2.0.1", features = ["serde"] }
+git2 = { version = "0.20.2" }
+sha2 = { version = "0.10.9" }
 
 [dev-dependencies]
 tempfile = "3.8"

core/src/cache.rs

@@ -1,12 +1,17 @@
 use std::io::{Read, Write};
 use std::path::{Path, PathBuf};
 
-use crate::common::{collect_owners, collect_tags, find_owners_for_file, find_tags_for_file};
+use crate::common::{
+    collect_owners, collect_tags, find_owners_for_file, find_tags_for_file, get_repo_hash,
+};
+use crate::parse::parse_repo;
 use crate::types::{CacheEncoding, CodeownersCache, CodeownersEntry, FileEntry};
 use utils::error::{Error, Result};
 
 /// Create a cache from parsed CODEOWNERS entries and files
-pub fn build_cache(entries: Vec<CodeownersEntry>, files: Vec<PathBuf>) -> Result<CodeownersCache> {
+pub fn build_cache(
+    entries: Vec<CodeownersEntry>, files: Vec<PathBuf>, hash: [u8; 32],
+) -> Result<CodeownersCache> {
     let mut file_entries = Vec::new();
     let mut owners_map = std::collections::HashMap::new();
     let mut tags_map = std::collections::HashMap::new();
@@ -48,6 +53,7 @@ pub fn build_cache(entries: Vec<CodeownersEntry>, files: Vec<PathBuf>) -> Result
     });
 
     Ok(CodeownersCache {
+        hash,
         entries,
         files: file_entries,
         owners_map,
@@ -143,11 +149,24 @@ pub fn sync_cache(
     }
 
     // Load the cache from the specified file
-    load_cache(&repo.join(cache_file)).map_err(|e| {
+    let cache = load_cache(&repo.join(cache_file)).map_err(|e| {
         utils::error::Error::new(&format!(
             "Failed to load cache from {}: {}",
             cache_file.display(),
             e
         ))
-    })
+    })?;
+
+    // verify the hash of the cache matches the current repo hash
+    let current_hash = get_repo_hash(repo)?;
+    dbg!(current_hash);
+    let cache_hash = cache.hash;
+    dbg!(cache_hash);
+
+    if cache_hash != current_hash {
+        // parse the codeowners files and build the cache
+        return parse_repo(&repo, &cache_file);
+    } else {
+        return Ok(cache);
+    }
 }

core/src/commands.rs

@@ -1,7 +1,7 @@
 use std::io::{self, Write};
 
 use crate::cache::{build_cache, load_cache, store_cache, sync_cache};
-use crate::common::find_files;
+use crate::common::{find_files, get_repo_hash};
 use crate::parse::parse_repo;
 use crate::types::{CacheEncoding, CodeownersCache, CodeownersEntry, OutputFormat};
 
@@ -22,6 +22,10 @@ pub fn codeowners_parse(
 ) -> Result<()> {
     println!("Parsing CODEOWNERS files at {}", path.display());
 
+    let hash = get_repo_hash(path.as_ref())?;
+    dbg!(hash);
+    panic!();
+
     let cache_file = match cache_file {
         Some(file) => path.join(file),
         None => {
@@ -47,7 +51,8 @@ pub fn codeowners_parse(
     let files = find_files(path)?;
 
     // Build the cache from the parsed CODEOWNERS entries and the files
-    let cache = build_cache(parsed_codeowners, files)?;
+    let hash = get_repo_hash(path)?;
+    let cache = build_cache(parsed_codeowners, files, hash)?;
 
     // Store the cache in the specified file
     store_cache(&cache, &cache_file, encoding)?;

core/src/common.rs

@@ -1,7 +1,9 @@
+use git2::{DiffFormat, DiffOptions, Repository};
 use ignore::{
     Walk,
     overrides::{Override, OverrideBuilder},
 };
+use sha2::{Digest, Sha256};
 use std::path::{Path, PathBuf};
 use utils::error::{Error, Result};
 
@@ -357,6 +359,52 @@ pub fn collect_tags(entries: &[CodeownersEntry]) -> Vec<Tag> {
     tags.into_iter().collect()
 }
 
+pub fn get_repo_hash(repo_path: &Path) -> Result<[u8; 32]> {
+    let repo = Repository::open(repo_path)
+        .map_err(|e| Error::with_source("Failed to open repo", Box::new(e)))?;
+
+    // 1. Get HEAD commit hash (or zeros if unborn)
+    let head_oid = repo
+        .head()
+        .and_then(|r| r.resolve())
+        .and_then(|r| Ok(r.target()))
+        .unwrap_or(None);
+
+    // 2. Get index/staging area tree hash
+    let mut index = repo
+        .index()
+        .map_err(|e| Error::with_source("Failed to get index", Box::new(e)))?;
+
+    let index_tree = index
+        .write_tree()
+        .map_err(|e| Error::with_source("Failed to write index tree", Box::new(e)))?;
+
+    // 3. Calculate hash of unstaged changes
+    // TODO: this doesn't work and also we need to exclude .codeowners.cache file
+    // otherwise the hash will change every time we parse the repo
+    let unstaged_hash = {
+        let diff = repo
+            .diff_index_to_workdir(None, Some(DiffOptions::new().include_untracked(true)))
+            .map_err(|e| Error::with_source("Failed to get diff", Box::new(e)))?;
+
+        let mut hasher = Sha256::new();
+        diff.print(DiffFormat::Patch, |_, _, line| {
+            hasher.update(line.content());
+            true
+        })
+        .map_err(|e| Error::with_source("Failed to print diff", Box::new(e)))?;
+        hasher.finalize()
+    };
+
+    // 4. Combine all components into final hash
+    let mut hasher = Sha256::new();
+    hasher.update(head_oid.unwrap_or(git2::Oid::zero()).as_bytes());
+    hasher.update(index_tree.as_bytes());
+    hasher.update(&unstaged_hash);
+
+    Ok(hasher.finalize().into())
+}
+
 #[cfg(test)]
 mod tests {
     use super::*;

core/src/parse.rs

@@ -2,7 +2,7 @@ use utils::error::Result;
 
 use crate::{
     cache::{build_cache, store_cache},
-    common::{find_codeowners_files, find_files, parse_codeowners},
+    common::{find_codeowners_files, find_files, get_repo_hash, parse_codeowners},
     types::{CacheEncoding, CodeownersCache, CodeownersEntry},
 };
 
@@ -25,8 +25,11 @@ pub fn parse_repo(repo: &std::path::Path, cache_file: &std::path::Path) -> Resul
     // Collect all files in the specified path
     let files = find_files(repo)?;
 
+    // Get the hash of the repository
+    let hash = get_repo_hash(repo)?;
+
     // Build the cache from the parsed CODEOWNERS entries and the files
-    let cache = build_cache(parsed_codeowners, files)?;
+    let cache = build_cache(parsed_codeowners, files, hash)?;
 
     // Store the cache in the specified file
     store_cache(&cache, &repo.join(cache_file), CacheEncoding::Bincode)?;

core/src/types.rs

@@ -74,6 +74,7 @@ pub struct FileEntry {
 /// Cache for storing parsed CODEOWNERS information
 #[derive(Debug)]
 pub struct CodeownersCache {
+    pub hash: [u8; 32],
     pub entries: Vec<CodeownersEntry>,
     pub files: Vec<FileEntry>,
     // Derived data for lookups
@@ -89,6 +90,7 @@ impl Serialize for CodeownersCache {
         use serde::ser::SerializeStruct;
 
         let mut state = serializer.serialize_struct("CodeownersCache", 4)?;
+        state.serialize_field("hash", &self.hash)?;
         state.serialize_field("entries", &self.entries)?;
         state.serialize_field("files", &self.files)?;
 
@@ -112,6 +114,7 @@ impl<'de> Deserialize<'de> for CodeownersCache {
     {
         #[derive(Deserialize)]
         struct CodeownersCacheHelper {
+            hash: [u8; 32],
             entries: Vec<CodeownersEntry>,
             files: Vec<FileEntry>,
             owners_map: Vec<(Owner, Vec<PathBuf>)>,
@@ -132,6 +135,7 @@ impl<'de> Deserialize<'de> for CodeownersCache {
         }
 
         Ok(CodeownersCache {
+            hash: helper.hash,
             entries: helper.entries,
             files: helper.files,
             owners_map,