use anyhow::{Context as _, Result};use collections::HashMap;use futures::lock::{Mutex, OwnedMutexGuard};use std::{    cell::RefCell,    path::{Path, PathBuf},    sync::Arc,}; use crate::paths::REPOS_DIR; thread_local! {    static REPO_LOCKS: RefCell<HashMap<PathBuf, Arc<Mutex<()>>>> = RefCell::new(HashMap::default());} #[must_use]pub async fn lock_repo(path: impl AsRef<Path>) -> OwnedMutexGuard<()> {    REPO_LOCKS        .with(|cell| {            cell.borrow_mut()                .entry(path.as_ref().to_path_buf())                .or_default()                .clone()        })        .lock_owned()        .await} pub async fn run_git(repo_path: &Path, args: &[&str]) -> Result<String> {    let output = smol::process::Command::new("git")        .current_dir(repo_path)        .args(args)        .output()        .await?;     anyhow::ensure!(        output.status.success(),        "`git {}` within `{}` failed with status: {}\nstderr:\n{}\nstdout:\n{}",        args.join(" "),        repo_path.display(),        output.status,        String::from_utf8_lossy(&output.stderr),        String::from_utf8_lossy(&output.stdout),    );    Ok(String::from_utf8(output.stdout)?.trim().to_string())} pub fn parse_repo_url(url: &str) -> Result<(String, String)> {    if url.contains('@') {        let (_, path) = url.split_once(':').context("expected : in git url")?;        let (owner, repo) = path.split_once('/').context("expected / in git url")?;        Ok((owner.to_string(), repo.trim_end_matches(".git").to_string()))    } else {        let parsed = http_client::Url::parse(url)?;        let mut segments = parsed.path_segments().context("empty http url")?;        let owner = segments.next().context("expected owner")?;        let repo = segments.next().context("expected repo")?;        Ok((owner.to_string(), repo.trim_end_matches(".git").to_string()))    }} pub fn repo_path_for_url(url: &str) -> Result<PathBuf> {    let (owner, name) = parse_repo_url(url)?;    Ok(REPOS_DIR.join(&owner).join(&name))} pub async fn ensure_repo_cloned(repo_url: &str) -> Result<PathBuf> {    let repo_path = repo_path_for_url(repo_url)?;    let _lock = lock_repo(&repo_path).await;     // Validate existing repo has correct origin, otherwise remove and re-init.    let mut git_repo_exists = false;    if repo_path.is_dir() {        if run_git(&repo_path, &["remote", "get-url", "origin"])            .await            .map_or(false, |origin| origin.trim() == repo_url)        {            git_repo_exists = true;        } else {            std::fs::remove_dir_all(&repo_path).ok();        }    }     if !git_repo_exists {        log::info!("Cloning {} into {:?}", repo_url, repo_path);        std::fs::create_dir_all(&repo_path)?;        run_git(&repo_path, &["init"]).await?;        run_git(&repo_path, &["remote", "add", "origin", repo_url])            .await            .ok();    }     // Always fetch to get latest commits    run_git(&repo_path, &["fetch", "--depth", "1000", "origin"]).await?;     // Check if we have a valid HEAD, if not checkout FETCH_HEAD    let has_head = run_git(&repo_path, &["rev-parse", "HEAD"]).await.is_ok();    if !has_head {        // Use reset to set HEAD without needing a branch        run_git(&repo_path, &["reset", "--hard", "FETCH_HEAD"]).await?;    }     Ok(repo_path)} pub async fn fetch_if_needed(repo_path: &Path, revision: &str) -> Result<String> {    let resolved = run_git(        repo_path,        &["rev-parse", &format!("{}^{{commit}}", revision)],    )    .await;     if let Ok(sha) = resolved {        return Ok(sha);    }     if run_git(repo_path, &["fetch", "--depth", "1", "origin", revision])        .await        .is_err()    {        run_git(repo_path, &["fetch", "origin"]).await?;    }     run_git(        repo_path,        &["rev-parse", &format!("{}^{{commit}}", revision)],    )    .await}