git_indexer/

extraction.rs

//! Git repository extraction functionality.
//!
//! This module provides functions to extract information from git repositories
//! including branches, commits, and file diffs.

use crate::error::{GitError, Result};
use crate::models::{BranchInfo, ChangeType, CommitInfo, DiffHunk, FileChange, GitInfo, TagInfo};
use gix::objs::tree::EntryKind;
use gix::{Repository, discover};
use imara_diff::{Algorithm, UnifiedDiffBuilder, diff};
use std::collections::{HashMap, HashSet};
use std::path::Path;

/// Maximum file size for diff extraction (10MB).
const MAX_FILE_SIZE: u64 = 10 * 1024 * 1024;

/// Extract git information from a repository.
///
/// # Arguments
///
/// * `repo_path` - Path to the git repository (or any subdirectory within it)
///
/// # Returns
///
/// Returns a `GitInfo` struct containing all branches and commits.
///
/// # Example
///
/// ```no_run
/// use git_indexer::extraction::extract;
/// use std::path::Path;
///
/// let git_info = extract(Path::new("/path/to/repo")).unwrap();
/// println!("Found {} branches", git_info.branches.len());
/// println!("Found {} commits", git_info.commits.len());
/// ```
pub fn extract(repo_path: &Path) -> Result<GitInfo> {
    let repo = discover(repo_path).map_err(|e| GitError::RepositoryNotFound {
        path: repo_path.to_path_buf(),
        message: e.to_string(),
    })?;

    let repo: Repository = repo.into();
    let branches = get_branches(&repo)?;
    let tags = get_tags(&repo)?;
    let commits = get_all_commits(&repo, &branches)?;

    Ok(GitInfo { branches, tags, commits })
}

/// Organize git information into a JSON string grouped by branch.
///
/// # Arguments
///
/// * `git_info` - The extracted git information
///
/// # Returns
///
/// Returns a pretty-printed JSON string with commits organized by branch name.
pub fn organize_info(git_info: &GitInfo) -> Result<String> {
    // Create a map of commit_id -> commit for easy lookup
    let commit_map: HashMap<&str, &CommitInfo> = git_info
        .commits
        .iter()
        .map(|c| (c.id.as_str(), c))
        .collect();

    // Build structure: branch_name -> list of commits reachable from that branch
    let mut branch_commits: HashMap<String, Vec<&CommitInfo>> = HashMap::new();

    for branch in &git_info.branches {
        let mut commits_for_branch = Vec::new();
        let mut visited = HashSet::new();
        let mut to_visit = Vec::new();

        // Start from the branch's commit
        to_visit.push(branch.commit_id.as_str());

        // Traverse the commit graph
        while let Some(commit_id) = to_visit.pop() {
            if visited.contains(commit_id) {
                continue;
            }
            visited.insert(commit_id);

            if let Some(commit) = commit_map.get(commit_id) {
                commits_for_branch.push(*commit);

                // Add parents to visit
                for parent_id in &commit.parent_ids {
                    if !visited.contains(parent_id.as_str()) {
                        to_visit.push(parent_id.as_str());
                    }
                }
            }
        }

        // Sort commits by timestamp (newest first)
        commits_for_branch.sort_by(|a, b| b.timestamp.cmp(&a.timestamp));

        branch_commits.insert(branch.name.clone(), commits_for_branch);
    }

    // Convert to pretty-printed JSON string
    Ok(serde_json::to_string_pretty(&branch_commits)?)
}

/// Get all branches (local and remote) from the repository.
fn get_branches(repo: &Repository) -> Result<Vec<BranchInfo>> {
    let mut branches = Vec::new();

    let head = repo
        .head()
        .map_err(|e| GitError::ReferencesError(format!("Failed to get HEAD: {}", e)))?;
    let head_name = head.referent_name().map(|n| n.as_bstr().to_string());

    let refs = repo
        .references()
        .map_err(|e| GitError::ReferencesError(e.to_string()))?;

    for reference in refs
        .all()
        .map_err(|e| GitError::ReferencesError(e.to_string()))?
        .flatten()
    {
        let ref_name = reference.name().as_bstr().to_string();

        // Local branches
        if ref_name.starts_with("refs/heads/") {
            let branch_name = ref_name.strip_prefix("refs/heads/").unwrap().to_string();
            let is_head = head_name.as_ref().map_or(false, |h| h == &ref_name);
            let commit_id = reference.id().to_hex().to_string();

            branches.push(BranchInfo {
                name: branch_name,
                is_head,
                commit_id,
                is_remote: false,
            });
        }
        // Remote branches
        else if ref_name.starts_with("refs/remotes/") && !ref_name.ends_with("/HEAD") {
            let branch_name = ref_name.strip_prefix("refs/remotes/").unwrap().to_string();
            let commit_id = reference.id().to_hex().to_string();

            branches.push(BranchInfo {
                name: branch_name,
                is_head: false,
                commit_id,
                is_remote: true,
            });
        }
    }

    Ok(branches)
}

/// Get all tags from the repository.
fn get_tags(repo: &Repository) -> Result<Vec<TagInfo>> {
    let mut tags = Vec::new();

    let refs = repo
        .references()
        .map_err(|e| GitError::ReferencesError(e.to_string()))?;

    for reference in refs
        .prefixed("refs/tags/")
        .map_err(|e| GitError::ReferencesError(e.to_string()))?
        .flatten()
    {
        let ref_name = reference.name().as_bstr().to_string();
        let tag_name = ref_name
            .strip_prefix("refs/tags/")
            .unwrap_or(&ref_name)
            .to_string();

        let target_id = reference.id().to_hex().to_string();

        // Check if this is an annotated tag by trying to peel to a tag object
        let (is_annotated, tagger, message) = match repo.find_object(reference.id().detach()) {
            Ok(obj) => {
                if let Ok(tag) = obj.try_into_tag() {
                    if let Ok(decoded) = tag.decode() {
                        let tagger_str = decoded.tagger.map(|sig| {
                            format!("{} <{}>", sig.name, sig.email)
                        });
                        let msg = Some(decoded.message.to_string());
                        (true, tagger_str, msg)
                    } else {
                        (true, None, None)
                    }
                } else {
                    (false, None, None)
                }
            }
            Err(_) => (false, None, None),
        };

        tags.push(TagInfo {
            name: tag_name,
            target_id,
            is_annotated,
            tagger,
            message,
        });
    }

    Ok(tags)
}

/// Collect all unique commits from all branches with their diffs.
fn get_all_commits(repo: &Repository, branches: &[BranchInfo]) -> Result<Vec<CommitInfo>> {
    let mut seen_commits: HashSet<String> = HashSet::new();
    let mut commits: Vec<CommitInfo> = Vec::new();
    let mut to_process: Vec<gix::ObjectId> = Vec::new();

    // Collect all branch tips as starting points
    for branch in branches {
        if let Ok(oid) = gix::ObjectId::from_hex(branch.commit_id.as_bytes()) {
            if !seen_commits.contains(&branch.commit_id) {
                to_process.push(oid);
            }
        }
    }

    // Process commits in a breadth-first manner
    while let Some(commit_id) = to_process.pop() {
        let commit_id_str = commit_id.to_hex().to_string();

        if seen_commits.contains(&commit_id_str) {
            continue;
        }
        seen_commits.insert(commit_id_str.clone());

        // Get commit object
        let commit_obj = match repo.find_object(commit_id) {
            Ok(obj) => obj,
            Err(_) => continue,
        };

        let commit = match commit_obj.try_into_commit() {
            Ok(c) => c,
            Err(_) => continue,
        };

        let commit_decoded = match commit.decode() {
            Ok(d) => d,
            Err(_) => continue,
        };

        // Collect parent IDs
        let parent_ids: Vec<String> = commit
            .parent_ids()
            .map(|id| id.to_hex().to_string())
            .collect();

        // Add parents to processing queue
        for parent_id in commit.parent_ids() {
            let parent_id_str = parent_id.to_hex().to_string();
            if !seen_commits.contains(&parent_id_str) {
                to_process.push(parent_id.detach());
            }
        }

        // Extract file changes (diff against first parent, or empty for root commits)
        let file_changes = get_commit_diff(repo, &commit, commit.parent_ids().next())?;

        // tree sha  = dir structure
        // Get tree SHA for this commit
        let tree_id = match commit.tree() {
            Ok(tree) => tree.id().to_hex().to_string(),
            Err(_) => String::new(),
        };

        let message = commit_decoded.message();
        let author = commit_decoded.author();

        commits.push(CommitInfo {
            id: commit_id_str,
            tree_id,
            message: message.title.to_string(),
            author: format!("{} <{}>", author.name, author.email),
            timestamp: author.seconds() as i64,
            parent_ids,
            file_changes,
        });
    }

    // Sort by timestamp (newest first)
    commits.sort_by(|a, b| b.timestamp.cmp(&a.timestamp));

    Ok(commits)
}

/// Get file changes for a commit by diffing against its parent.
fn get_commit_diff(
    repo: &Repository,
    commit: &gix::Commit,
    parent_id: Option<gix::Id>,
) -> Result<Vec<FileChange>> {
    let mut file_changes = Vec::new();

    // Get the commit's tree
    let commit_tree = commit
        .tree()
        .map_err(|e| GitError::TreeReadError(e.to_string()))?;

    // Get parent's tree (or use empty tree for root commits)
    let parent_tree = if let Some(pid) = parent_id {
        let parent_obj = repo
            .find_object(pid.detach())
            .map_err(|e| GitError::TreeReadError(e.to_string()))?;
        let parent_commit = parent_obj
            .try_into_commit()
            .map_err(|e| GitError::TreeReadError(e.to_string()))?;
        Some(
            parent_commit
                .tree()
                .map_err(|e| GitError::TreeReadError(e.to_string()))?,
        )
    } else {
        None
    };

    // Collect entries from both trees
    let mut old_entries: HashMap<String, (gix::ObjectId, EntryKind)> = HashMap::new();
    let mut new_entries: HashMap<String, (gix::ObjectId, EntryKind)> = HashMap::new();

    // Recursively collect entries from parent tree
    if let Some(ref tree) = parent_tree {
        collect_tree_entries(repo, tree, String::new(), &mut old_entries)?;
    }

    // Recursively collect entries from commit tree
    collect_tree_entries(repo, &commit_tree, String::new(), &mut new_entries)?;

    // Find added and modified files
    for (path, (new_oid, new_kind)) in &new_entries {
        if *new_kind != EntryKind::Blob {
            continue; // Skip non-blob entries (directories, submodules, etc.)
        }

        if let Some((old_oid, _)) = old_entries.get(path) {
            // File exists in both trees
            if old_oid != new_oid {
                // Modified
                let hunks = get_blob_diff(repo, Some(*old_oid), *new_oid)?;
                file_changes.push(FileChange {
                    path: path.clone(),
                    old_path: None,
                    change_type: ChangeType::Modified,
                    old_blob_sha: Some(old_oid.to_hex().to_string()),
                    new_blob_sha: Some(new_oid.to_hex().to_string()),
                    hunks,
                });
            }
            // else: unchanged, skip
        } else {
            // Added
            let hunks = get_blob_diff(repo, None, *new_oid)?;
            file_changes.push(FileChange {
                path: path.clone(),
                old_path: None,
                change_type: ChangeType::Added,
                old_blob_sha: None,
                new_blob_sha: Some(new_oid.to_hex().to_string()),
                hunks,
            });
        }
    }

    // Find deleted files
    for (path, (old_oid, old_kind)) in &old_entries {
        if *old_kind != EntryKind::Blob {
            continue;
        }

        if !new_entries.contains_key(path) {
            let hunks = get_blob_diff(
                repo,
                Some(*old_oid),
                gix::ObjectId::empty_blob(gix::hash::Kind::Sha1),
            )?;
            file_changes.push(FileChange {
                path: path.clone(),
                old_path: None,
                change_type: ChangeType::Deleted,
                old_blob_sha: Some(old_oid.to_hex().to_string()),
                new_blob_sha: None,
                hunks,
            });
        }
    }

    Ok(file_changes)
}

/// Recursively collect all blob entries from a tree.
fn collect_tree_entries(
    repo: &Repository,
    tree: &gix::Tree,
    prefix: String,
    entries: &mut HashMap<String, (gix::ObjectId, EntryKind)>,
) -> Result<()> {
    for entry in tree.iter() {
        let entry = entry.map_err(|e| GitError::TreeReadError(e.to_string()))?;
        let name = entry.filename().to_string();
        let path = if prefix.is_empty() {
            name.clone()
        } else {
            format!("{}/{}", prefix, name)
        };

        let mode = entry.mode();
        let kind = mode.kind();
        let oid = entry.oid();

        match kind {
            EntryKind::Blob | EntryKind::BlobExecutable => {
                entries.insert(path, (oid.into(), kind));
            }
            EntryKind::Tree => {
                // Recurse into subdirectory
                if let Ok(subtree_obj) = repo.find_object(oid) {
                    if let Ok(subtree) = subtree_obj.try_into_tree() {
                        collect_tree_entries(repo, &subtree, path, entries)?;
                    }
                }
            }
            _ => {
                // Skip links, submodules, etc.
            }
        }
    }
    Ok(())
}

/// Generate diff hunks between two blobs.
fn get_blob_diff(
    repo: &Repository,
    old_oid: Option<gix::ObjectId>,
    new_oid: gix::ObjectId,
) -> Result<Vec<DiffHunk>> {
    // Get old content
    let old_content = if let Some(oid) = old_oid {
        if oid == gix::ObjectId::empty_blob(gix::hash::Kind::Sha1) {
            String::new()
        } else {
            match repo.find_object(oid) {
                Ok(obj) => {
                    let data = obj.data.clone();
                    // Check size limit
                    if data.len() as u64 > MAX_FILE_SIZE {
                        return Ok(vec![]);
                    }
                    // Check if binary
                    if is_binary(&data) {
                        return Ok(vec![]);
                    }
                    String::from_utf8_lossy(&data).to_string()
                }
                Err(_) => String::new(),
            }
        }
    } else {
        String::new()
    };

    // Get new content
    let new_content = if new_oid == gix::ObjectId::empty_blob(gix::hash::Kind::Sha1) {
        String::new()
    } else {
        match repo.find_object(new_oid) {
            Ok(obj) => {
                let data = obj.data.clone();
                // Check size limit
                if data.len() as u64 > MAX_FILE_SIZE {
                    return Ok(vec![]);
                }
                // Check if binary
                if is_binary(&data) {
                    return Ok(vec![]);
                }
                String::from_utf8_lossy(&data).to_string()
            }
            Err(_) => String::new(),
        }
    };

    // Generate unified diff
    let input = imara_diff::intern::InternedInput::new(old_content.as_str(), new_content.as_str());
    let diff_output = diff(
        Algorithm::Histogram,
        &input,
        UnifiedDiffBuilder::new(&input),
    );

    // Parse the unified diff to extract hunks
    let hunks = parse_unified_diff(&diff_output);

    Ok(hunks)
}

/// Check if content is binary (contains null bytes in first 8KB).
fn is_binary(data: &[u8]) -> bool {
    let check_len = std::cmp::min(data.len(), 8192);
    data[..check_len].contains(&0)
}

/// Parse unified diff output into structured hunks.
fn parse_unified_diff(diff_text: &str) -> Vec<DiffHunk> {
    let mut hunks = Vec::new();
    let mut current_hunk: Option<DiffHunk> = None;
    let mut content_lines: Vec<String> = Vec::new();

    for line in diff_text.lines() {
        if line.starts_with("@@") {
            // Save previous hunk
            if let Some(mut hunk) = current_hunk.take() {
                hunk.content = content_lines.join("\n");
                hunks.push(hunk);
                content_lines.clear();
            }

            // Parse hunk header: @@ -old_start,old_lines +new_start,new_lines @@
            if let Some((old_start, old_lines, new_start, new_lines)) = parse_hunk_header(line) {
                current_hunk = Some(DiffHunk {
                    old_start,
                    old_lines,
                    new_start,
                    new_lines,
                    content: String::new(),
                });
            }
        } else if current_hunk.is_some() {
            // Content line (starts with +, -, or space)
            content_lines.push(line.to_string());
        }
    }

    // Save last hunk
    if let Some(mut hunk) = current_hunk.take() {
        hunk.content = content_lines.join("\n");
        hunks.push(hunk);
    }

    hunks
}

/// Parse a hunk header line: @@ -old_start,old_lines +new_start,new_lines @@
fn parse_hunk_header(line: &str) -> Option<(u32, u32, u32, u32)> {
    let line = line.trim_start_matches("@@").trim_end_matches("@@").trim();
    let parts: Vec<&str> = line.split_whitespace().collect();

    if parts.len() < 2 {
        return None;
    }

    let old_part = parts[0].trim_start_matches('-');
    let new_part = parts[1].trim_start_matches('+');

    let (old_start, old_lines) = parse_range(old_part)?;
    let (new_start, new_lines) = parse_range(new_part)?;

    Some((old_start, old_lines, new_start, new_lines))
}

/// Parse a range like "10,5" or "10" into (start, lines).
fn parse_range(s: &str) -> Option<(u32, u32)> {
    if let Some((start, lines)) = s.split_once(',') {
        Some((start.parse().ok()?, lines.parse().ok()?))
    } else {
        Some((s.parse().ok()?, 1))
    }
}