void_core/index/

rebuild.rs

//! Rebuild index from HEAD commit state + working tree scan.

use std::collections::HashMap;
use std::path::Path;

use camino::Utf8PathBuf;
use ignore::WalkBuilder;

use crate::crypto::KeyVault;
use crate::metadata::manifest_tree::TreeManifest;
use crate::refs;

use crate::store::{FsStore, ObjectStoreExt};
use void_crypto::EncryptedCommit;
use crate::support::configure_walker;
use crate::{Result, VoidError};

use super::entry::index_entry_from_file;
use super::io::write_index;
use super::types::IndexEntry;

/// Result of rebuilding the index.
#[derive(Debug, Clone)]
pub struct RebuildResult {
    /// Total number of entries in the rebuilt index.
    pub entries_rebuilt: usize,
    /// Number of entries sourced from HEAD commit.
    pub from_head: usize,
    /// Number of entries sourced from working tree scan.
    pub from_working_tree: usize,
}



/// Rebuild index from HEAD commit state + working tree scan.
///
/// Recovers from corrupted index by:
/// 1. Resolving HEAD to get current commit CID
/// 2. Loading file list from HEAD commit (walking shards, collecting paths + content hashes)
/// 3. Scanning working tree for current files
/// 4. Building index entries by comparing HEAD vs working tree
/// 5. Writing new index using atomic write
///
/// Files that exist in HEAD but not on disk are excluded from the rebuilt index.
/// Files that exist on disk but not in HEAD use their current disk state.
pub fn rebuild_index(void_dir: &Path, workspace: &Path, vault: &KeyVault) -> Result<RebuildResult> {
    let void_dir_utf8 = Utf8PathBuf::try_from(void_dir.to_path_buf())
        .map_err(|e| VoidError::Io(std::io::Error::new(std::io::ErrorKind::InvalidData, e)))?;
    let workspace_utf8 = Utf8PathBuf::try_from(workspace.to_path_buf())
        .map_err(|e| VoidError::Io(std::io::Error::new(std::io::ErrorKind::InvalidData, e)))?;

    // Step 1: Load HEAD entries
    let head_commit_cid = refs::resolve_head(&void_dir_utf8)?;
    let mut head_entries: HashMap<String, IndexEntry> = HashMap::new();
    let mut commit_cid_typed: Option<void_crypto::CommitCid> = None;

    if let Some(ref cid_typed) = head_commit_cid {
        commit_cid_typed = Some(cid_typed.clone());

        let objects_dir = Utf8PathBuf::try_from(void_dir.join("objects"))
            .map_err(|e| VoidError::Io(std::io::Error::new(std::io::ErrorKind::InvalidData, e)))?;
        let store = FsStore::new(objects_dir)?;

        let commit_cid = crate::cid::from_bytes(cid_typed.as_bytes())?;
        let commit_encrypted: EncryptedCommit = store.get_blob(&commit_cid)?;
        let (commit_bytes, reader) = crate::crypto::CommitReader::open_with_vault(vault, &commit_encrypted)?;
        let commit = commit_bytes.parse()?;

        let manifest = TreeManifest::from_commit(&store, &commit, &reader)?
            .ok_or_else(|| VoidError::IntegrityError {
                expected: "manifest_cid present on commit".into(),
                actual: "None".into(),
            })?;

        for me in manifest.iter() {
            let me = me?;
            head_entries.insert(
                me.path.clone(),
                IndexEntry {
                    path: me.path.clone(),
                    content_hash: me.content_hash,
                    mtime_secs: 0,
                    mtime_nanos: 0,
                    size: me.length,
                },
            );
        }
    }

    // Step 2: Walk working tree
    let void_dir_name = void_dir
        .file_name()
        .and_then(|s| s.to_str())
        .unwrap_or(".void")
        .to_string();

    let mut working_tree_files: HashMap<String, ()> = HashMap::new();
    let mut builder = WalkBuilder::new(workspace);
    let walker = configure_walker(&mut builder)
        .filter_entry({
            let void_dir_name = void_dir_name.clone();
            move |entry| {
                let name = entry.file_name().to_string_lossy();
                if name == void_dir_name
                    || name == ".git"
                    || name == "node_modules"
                    || name == ".DS_Store"
                {
                    return false;
                }
                true
            }
        })
        .build();

    for entry in walker.flatten() {
        if !entry.file_type().map(|t| t.is_file()).unwrap_or(false) {
            continue;
        }
        let path = entry.path().to_path_buf();
        let rel = match path.strip_prefix(workspace) {
            Ok(r) => r.to_string_lossy().replace('\\', "/"),
            Err(_) => continue,
        };
        working_tree_files.insert(rel, ());
    }

    // Step 3: Build index entries
    let mut entries = Vec::new();
    let mut from_head = 0usize;
    let mut from_working_tree = 0usize;

    for (rel_path, _) in &working_tree_files {
        if let Some(head_entry) = head_entries.get(rel_path) {
            // File exists in HEAD, check if it matches current disk state
            let current_entry = match index_entry_from_file(&workspace_utf8, rel_path) {
                Ok(entry) => entry,
                Err(_) => continue, // Skip if can't read file
            };

            if current_entry.content_hash == head_entry.content_hash {
                // File matches HEAD, use HEAD entry with current metadata
                entries.push(IndexEntry {
                    path: rel_path.clone(),
                    content_hash: head_entry.content_hash,
                    mtime_secs: current_entry.mtime_secs,
                    mtime_nanos: current_entry.mtime_nanos,
                    size: current_entry.size,
                });
                from_head += 1;
            } else {
                // File has been modified, use current state (staged)
                entries.push(current_entry);
                from_working_tree += 1;
            }
        } else {
            // File is new (not in HEAD), add to index as staged
            match index_entry_from_file(&workspace_utf8, rel_path) {
                Ok(entry) => {
                    entries.push(entry);
                    from_working_tree += 1;
                }
                Err(_) => continue, // Skip if can't read file
            }
        }
    }

    // Step 4: Write index
    let entries_rebuilt = entries.len();
    write_index(void_dir, vault.index_key()?, commit_cid_typed, entries)?;

    Ok(RebuildResult {
        entries_rebuilt,
        from_head,
        from_working_tree,
    })
}