ironflow-ops-git 0.1.17

//! Repository-level operations: init, open, clone, discover, state.

use std::path::{Path, PathBuf};

use async_trait::async_trait;
use git2::build::RepoBuilder;
use git2::{FetchOptions, Repository, RepositoryState};
use ironflow_core::error::OperationError;
use ironflow_core::operation::{Operation, OperationContext, TypedOperation};
use serde::{Deserialize, Serialize};
use serde_json::Value;

use crate::helpers::{
    GitAuth, auth_builders, blocking, blocking_authenticated, credentials_callbacks, redact_url,
    to_value,
};

fn repo_state_label(state: RepositoryState) -> &'static str {
    match state {
        RepositoryState::Clean => "clean",
        RepositoryState::Merge => "merge",
        RepositoryState::Revert | RepositoryState::RevertSequence => "revert",
        RepositoryState::CherryPickSequence | RepositoryState::CherryPick => "cherrypick",
        RepositoryState::Bisect => "bisect",
        RepositoryState::Rebase
        | RepositoryState::RebaseInteractive
        | RepositoryState::RebaseMerge => "rebase",
        RepositoryState::ApplyMailbox | RepositoryState::ApplyMailboxOrRebase => "apply-mailbox",
    }
}

/// Output of [`RepoInit`].
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct RepoInitOutput {
    /// Path where the repository was created.
    pub path: PathBuf,
    /// Whether this is a bare repository.
    pub bare: bool,
}

/// Initialize a new Git repository.
///
/// Creates a new repository at the given path. If `bare` is true, creates
/// a bare repository (no working directory).
///
/// # Examples
///
/// ```no_run
/// use ironflow_ops_git::repository::RepoInit;
/// use ironflow_core::operation::Operation;
///
/// let op = RepoInit::new("/tmp/my-repo", false);
/// assert_eq!(op.kind(), "git");
/// ```
pub struct RepoInit {
    path: PathBuf,
    bare: bool,
}

impl RepoInit {
    /// Create a new init operation.
    pub fn new(path: impl Into<PathBuf>, bare: bool) -> Self {
        Self {
            path: path.into(),
            bare,
        }
    }

    /// Execute and return a typed result.
    pub async fn run(&self, _ctx: &OperationContext) -> Result<RepoInitOutput, OperationError> {
        let path = self.path.clone();
        let bare = self.bare;
        blocking(move || {
            if bare {
                Repository::init_bare(&path)?;
            } else {
                Repository::init(&path)?;
            }
            Ok(RepoInitOutput { path, bare })
        })
        .await
    }
}

#[async_trait]
impl Operation for RepoInit {
    fn kind(&self) -> &str {
        "git"
    }

    async fn execute(&self, ctx: &OperationContext) -> Result<Value, OperationError> {
        to_value(&self.run(ctx).await?)
    }

    fn input(&self) -> Option<Value> {
        Some(serde_json::json!({ "path": self.path, "bare": self.bare }))
    }
}

impl TypedOperation for RepoInit {
    type Output = RepoInitOutput;
}

/// Output of [`RepoOpen`].
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct RepoOpenOutput {
    /// Working directory path (or the bare repo path).
    pub path: PathBuf,
    /// Whether this is a bare repository.
    pub bare: bool,
}

/// Open an existing Git repository.
///
/// Returns the repository path and whether it is bare.
///
/// # Examples
///
/// ```no_run
/// use ironflow_ops_git::repository::RepoOpen;
/// use ironflow_core::operation::Operation;
///
/// let op = RepoOpen::new("/path/to/repo");
/// assert_eq!(op.kind(), "git");
/// ```
pub struct RepoOpen {
    path: PathBuf,
}

impl RepoOpen {
    /// Create a new open operation.
    pub fn new(path: impl Into<PathBuf>) -> Self {
        Self { path: path.into() }
    }

    /// Execute and return a typed result.
    pub async fn run(&self, _ctx: &OperationContext) -> Result<RepoOpenOutput, OperationError> {
        let path = self.path.clone();
        blocking(move || {
            let repo = Repository::open(&path)?;
            let is_bare = repo.is_bare();
            let workdir = repo.workdir().map(Path::to_path_buf);
            Ok(RepoOpenOutput {
                path: workdir.unwrap_or(path),
                bare: is_bare,
            })
        })
        .await
    }
}

#[async_trait]
impl Operation for RepoOpen {
    fn kind(&self) -> &str {
        "git"
    }

    async fn execute(&self, ctx: &OperationContext) -> Result<Value, OperationError> {
        to_value(&self.run(ctx).await?)
    }

    fn input(&self) -> Option<Value> {
        Some(serde_json::json!({ "path": self.path }))
    }
}

impl TypedOperation for RepoOpen {
    type Output = RepoOpenOutput;
}

/// Output of [`RepoClone`].
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct RepoCloneOutput {
    /// The cloned URL, with any userinfo masked as `***`.
    pub url: String,
    /// Local path of the clone.
    pub path: PathBuf,
    /// Whether the clone is a bare repository.
    pub bare: bool,
}

/// Clone a remote or local repository.
///
/// Over HTTPS, the clone authenticates with the token held in the `git_token`
/// secret (username `oauth2`), see [`RepoClone::token_secret`] and
/// [`RepoClone::username`]. Without that secret, it falls back to the SSH
/// agent and the git credential helper. Any credentials embedded in the URL
/// are masked in [`Operation::input`] and in the output.
///
/// # Examples
///
/// ```no_run
/// use ironflow_ops_git::repository::RepoClone;
/// use ironflow_core::operation::Operation;
///
/// let op = RepoClone::new("https://github.com/user/repo.git", "/tmp/clone");
/// assert_eq!(op.kind(), "git");
/// ```
pub struct RepoClone {
    url: String,
    path: PathBuf,
    bare: bool,
    auth: GitAuth,
}

impl RepoClone {
    /// Create a new clone operation.
    pub fn new(url: impl Into<String>, path: impl Into<PathBuf>) -> Self {
        Self {
            url: url.into(),
            path: path.into(),
            bare: false,
            auth: GitAuth::default(),
        }
    }

    /// Clone as a bare repository (no working directory).
    ///
    /// # Examples
    ///
    /// ```no_run
    /// use ironflow_ops_git::repository::RepoClone;
    ///
    /// let op = RepoClone::new("https://gitlab.com/group/repo.git", "/tmp/repo.git").bare(true);
    /// ```
    pub fn bare(mut self, bare: bool) -> Self {
        self.bare = bare;
        self
    }

    /// Execute and return a typed result.
    ///
    /// # Errors
    ///
    /// Returns [`OperationError::Secret`] if the secret store fails, and
    /// [`OperationError::External`] if the clone fails. Neither the token nor
    /// URL credentials appear in the message.
    pub async fn run(&self, ctx: &OperationContext) -> Result<RepoCloneOutput, OperationError> {
        let url = self.url.clone();
        let path = self.path.clone();
        let bare = self.bare;
        blocking_authenticated(ctx, &self.auth, move |creds| {
            let mut fetch_opts = FetchOptions::new();
            fetch_opts.remote_callbacks(credentials_callbacks(creds));
            RepoBuilder::new()
                .bare(bare)
                .fetch_options(fetch_opts)
                .clone(&url, &path)?;
            Ok(RepoCloneOutput {
                url: redact_url(&url),
                path,
                bare,
            })
        })
        .await
    }
}

#[async_trait]
impl Operation for RepoClone {
    fn kind(&self) -> &str {
        "git"
    }

    async fn execute(&self, ctx: &OperationContext) -> Result<Value, OperationError> {
        to_value(&self.run(ctx).await?)
    }

    fn input(&self) -> Option<Value> {
        Some(serde_json::json!({
            "url": redact_url(&self.url),
            "path": self.path,
            "bare": self.bare,
        }))
    }
}

impl TypedOperation for RepoClone {
    type Output = RepoCloneOutput;
}

auth_builders!(
    RepoClone,
    "repository",
    "\"https://gitlab.com/group/repo.git\", \"/tmp/repo\""
);

/// Output of [`RepoDiscover`].
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct RepoDiscoverOutput {
    /// Working directory path (if not bare).
    pub path: Option<PathBuf>,
    /// Whether this is a bare repository.
    pub bare: bool,
}

/// Discover a repository by walking parent directories.
///
/// Starts from `start_path` and walks upward until a `.git` directory is found.
///
/// # Examples
///
/// ```no_run
/// use ironflow_ops_git::repository::RepoDiscover;
/// use ironflow_core::operation::Operation;
///
/// let op = RepoDiscover::new("/path/to/subdir");
/// assert_eq!(op.kind(), "git");
/// ```
pub struct RepoDiscover {
    start_path: PathBuf,
}

impl RepoDiscover {
    /// Create a new discover operation.
    pub fn new(start_path: impl Into<PathBuf>) -> Self {
        Self {
            start_path: start_path.into(),
        }
    }

    /// Execute and return a typed result.
    pub async fn run(&self, _ctx: &OperationContext) -> Result<RepoDiscoverOutput, OperationError> {
        let start = self.start_path.clone();
        blocking(move || {
            let repo = Repository::discover(&start)?;
            let workdir = repo.workdir().map(Path::to_path_buf);
            let is_bare = repo.is_bare();
            Ok(RepoDiscoverOutput {
                path: workdir,
                bare: is_bare,
            })
        })
        .await
    }
}

#[async_trait]
impl Operation for RepoDiscover {
    fn kind(&self) -> &str {
        "git"
    }

    async fn execute(&self, ctx: &OperationContext) -> Result<Value, OperationError> {
        to_value(&self.run(ctx).await?)
    }

    fn input(&self) -> Option<Value> {
        Some(serde_json::json!({ "start_path": self.start_path }))
    }
}

impl TypedOperation for RepoDiscover {
    type Output = RepoDiscoverOutput;
}

/// Output of [`RepoState`].
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct RepoStateOutput {
    /// Repository state (e.g. "Clean", "Merge", "Rebase").
    pub state: String,
}

/// Query the current state of the repository.
///
/// Returns the repository state (clean, merge, rebase, etc.).
///
/// # Examples
///
/// ```no_run
/// use ironflow_ops_git::repository::RepoState;
/// use ironflow_core::operation::Operation;
///
/// let op = RepoState::new("/path/to/repo");
/// assert_eq!(op.kind(), "git");
/// ```
pub struct RepoState {
    repo_path: PathBuf,
}

impl RepoState {
    /// Create a new state query operation.
    pub fn new(repo_path: impl Into<PathBuf>) -> Self {
        Self {
            repo_path: repo_path.into(),
        }
    }

    /// Execute and return a typed result.
    pub async fn run(&self, _ctx: &OperationContext) -> Result<RepoStateOutput, OperationError> {
        let path = self.repo_path.clone();
        blocking(move || {
            let repo = Repository::open(&path)?;
            let state = repo_state_label(repo.state()).to_string();
            Ok(RepoStateOutput { state })
        })
        .await
    }
}

#[async_trait]
impl Operation for RepoState {
    fn kind(&self) -> &str {
        "git"
    }

    async fn execute(&self, ctx: &OperationContext) -> Result<Value, OperationError> {
        to_value(&self.run(ctx).await?)
    }

    fn input(&self) -> Option<Value> {
        Some(serde_json::json!({ "repo_path": self.repo_path }))
    }
}

impl TypedOperation for RepoState {
    type Output = RepoStateOutput;
}

#[cfg(test)]
mod tests {
    use std::fs;

    use super::*;
    use crate::test_helpers::{ctx, init_repo};

    #[tokio::test]
    async fn init_creates_repo() {
        let tmp = tempfile::tempdir().unwrap();
        let target = tmp.path().join("new-repo");
        let op = RepoInit::new(&target, false);
        let result = op.run(&ctx()).await.unwrap();
        assert!(!result.bare);
        assert!(target.join(".git").exists());
    }

    #[tokio::test]
    async fn init_creates_bare_repo() {
        let tmp = tempfile::tempdir().unwrap();
        let target = tmp.path().join("bare-repo");
        let op = RepoInit::new(&target, true);
        let result = op.run(&ctx()).await.unwrap();
        assert!(result.bare);
        assert!(target.join("HEAD").exists());
    }

    #[tokio::test]
    async fn clone_local() {
        let tmp = tempfile::tempdir().unwrap();
        let origin = tmp.path().join("origin");
        Repository::init(&origin).unwrap();

        let target = tmp.path().join("clone");
        let url = origin.to_str().unwrap();
        let op = RepoClone::new(url, &target);
        let result = op.run(&ctx()).await.unwrap();
        assert_eq!(result.path, target);
        assert!(target.join(".git").exists());
    }

    #[tokio::test]
    async fn clone_bare_creates_repo_without_workdir() {
        let tmp = tempfile::tempdir().unwrap();
        let origin = tmp.path().join("origin");
        init_repo(&origin);

        let target = tmp.path().join("clone.git");
        let result = RepoClone::new(origin.to_str().unwrap(), &target)
            .bare(true)
            .run(&ctx())
            .await
            .unwrap();

        assert!(result.bare);
        let repo = Repository::open(&target).unwrap();
        assert!(repo.is_bare());
        assert!(target.join("HEAD").exists());
        assert!(!target.join("file.txt").exists());
    }

    #[tokio::test]
    async fn clone_into_non_empty_directory_fails() {
        let tmp = tempfile::tempdir().unwrap();
        let origin = tmp.path().join("origin");
        init_repo(&origin);
        let target = tmp.path().join("busy");
        fs::create_dir_all(&target).unwrap();
        fs::write(target.join("keep.txt"), "x").unwrap();

        let result = RepoClone::new(origin.to_str().unwrap(), &target)
            .run(&ctx())
            .await;

        assert!(result.is_err());
    }

    #[tokio::test]
    async fn discover_finds_repo() {
        let tmp = tempfile::tempdir().unwrap();
        Repository::init(tmp.path()).unwrap();
        let subdir = tmp.path().join("a").join("b");
        std::fs::create_dir_all(&subdir).unwrap();

        let op = RepoDiscover::new(&subdir);
        let result = op.run(&ctx()).await.unwrap();
        assert!(!result.bare);
    }

    #[tokio::test]
    async fn state_on_clean_repo() {
        let tmp = tempfile::tempdir().unwrap();
        Repository::init(tmp.path()).unwrap();

        let op = RepoState::new(tmp.path());
        let result = op.run(&ctx()).await.unwrap();
        assert_eq!(result.state, "clean");
    }
}