mur_core/workflow/

versioning.rs

//! Git-based workflow version control — track, list, and restore workflow versions.

use anyhow::{Context, Result};
use chrono::{DateTime, Utc};
use serde::{Deserialize, Serialize};
use std::path::{Path, PathBuf};
use std::process::Command;

/// A single version entry from the git history of a workflow file.
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct WorkflowVersion {
    /// Git commit hash (short).
    pub version: String,
    /// Author of the commit.
    pub author: String,
    /// Timestamp of the commit.
    pub timestamp: DateTime<Utc>,
    /// Commit message / diff summary.
    pub diff: String,
}

/// Get the versioned workflows repository path.
fn versioned_repo_path() -> PathBuf {
    directories::BaseDirs::new()
        .map(|d| d.home_dir().join(".mur").join("workflows"))
        .unwrap_or_else(|| PathBuf::from(".mur/workflows"))
}

/// Ensure the workflows directory is a git repository.
fn ensure_git_repo(repo_path: &Path) -> Result<()> {
    if !repo_path.exists() {
        std::fs::create_dir_all(repo_path)
            .with_context(|| format!("Creating workflows directory {:?}", repo_path))?;
    }

    let git_dir = repo_path.join(".git");
    if !git_dir.exists() {
        let output = Command::new("git")
            .args(["init"])
            .current_dir(repo_path)
            .output()
            .context("Running git init")?;

        if !output.status.success() {
            let stderr = String::from_utf8_lossy(&output.stderr);
            anyhow::bail!("git init failed: {}", stderr);
        }
    }
    Ok(())
}

/// Auto-commit workflow changes to the git repository at `~/.mur/workflows/`.
///
/// Creates or updates the workflow file and commits the change.
pub fn version_workflow(workflow_id: &str, yaml_content: &str) -> Result<WorkflowVersion> {
    let repo_path = versioned_repo_path();
    ensure_git_repo(&repo_path)?;

    let file_path = repo_path.join(format!("{}.yaml", workflow_id));
    std::fs::write(&file_path, yaml_content)
        .with_context(|| format!("Writing workflow file {:?}", file_path))?;

    // Stage the file
    let output = Command::new("git")
        .args(["add", &format!("{}.yaml", workflow_id)])
        .current_dir(&repo_path)
        .output()
        .context("git add")?;

    if !output.status.success() {
        anyhow::bail!("git add failed: {}", String::from_utf8_lossy(&output.stderr));
    }

    // Check if there are staged changes
    let status = Command::new("git")
        .args(["diff", "--cached", "--quiet"])
        .current_dir(&repo_path)
        .status()
        .context("git diff --cached")?;

    if status.success() {
        // No changes to commit
        anyhow::bail!("No changes to version for workflow '{}'", workflow_id);
    }

    // Commit
    let message = format!("Update workflow: {}", workflow_id);
    let output = Command::new("git")
        .args(["commit", "-m", &message, "--author", "mur-commander <mur@localhost>"])
        .current_dir(&repo_path)
        .output()
        .context("git commit")?;

    if !output.status.success() {
        anyhow::bail!(
            "git commit failed: {}",
            String::from_utf8_lossy(&output.stderr)
        );
    }

    // Get the commit info
    let log_output = Command::new("git")
        .args(["log", "-1", "--format=%H%n%an%n%aI%n%s"])
        .current_dir(&repo_path)
        .output()
        .context("git log")?;

    let log_str = String::from_utf8_lossy(&log_output.stdout);
    let lines: Vec<&str> = log_str.trim().lines().collect();

    let version = lines.first().unwrap_or(&"unknown").to_string();
    let author = lines.get(1).unwrap_or(&"unknown").to_string();
    let timestamp = lines
        .get(2)
        .and_then(|s| DateTime::parse_from_rfc3339(s).ok())
        .map(|dt| dt.with_timezone(&Utc))
        .unwrap_or_else(Utc::now);
    let diff = lines.get(3).unwrap_or(&"").to_string();

    Ok(WorkflowVersion {
        version,
        author,
        timestamp,
        diff,
    })
}

/// List all versions (git log) for a workflow file.
pub fn list_versions(workflow_id: &str) -> Result<Vec<WorkflowVersion>> {
    let repo_path = versioned_repo_path();
    let file_name = format!("{}.yaml", workflow_id);

    if !repo_path.join(".git").exists() {
        return Ok(vec![]);
    }

    let output = Command::new("git")
        .args([
            "log",
            "--format=%H%n%an%n%aI%n%s%n---",
            "--follow",
            "--",
            &file_name,
        ])
        .current_dir(&repo_path)
        .output()
        .context("git log")?;

    if !output.status.success() {
        return Ok(vec![]);
    }

    let log_str = String::from_utf8_lossy(&output.stdout);
    let mut versions = Vec::new();

    for entry in log_str.split("---\n") {
        let entry = entry.trim();
        if entry.is_empty() {
            continue;
        }
        let lines: Vec<&str> = entry.lines().collect();
        if lines.len() < 4 {
            continue;
        }

        let version = lines[0].to_string();
        let author = lines[1].to_string();
        let timestamp = DateTime::parse_from_rfc3339(lines[2])
            .map(|dt| dt.with_timezone(&Utc))
            .unwrap_or_else(|_| Utc::now());
        let diff = lines[3].to_string();

        versions.push(WorkflowVersion {
            version,
            author,
            timestamp,
            diff,
        });
    }

    Ok(versions)
}

/// Restore a workflow file to a specific git version.
pub fn restore_version(workflow_id: &str, version: &str) -> Result<String> {
    let repo_path = versioned_repo_path();
    let file_name = format!("{}.yaml", workflow_id);

    if !repo_path.join(".git").exists() {
        anyhow::bail!("No version history found for workflows");
    }

    // Checkout the file at the specified version
    let output = Command::new("git")
        .args(["checkout", version, "--", &file_name])
        .current_dir(&repo_path)
        .output()
        .context("git checkout")?;

    if !output.status.success() {
        anyhow::bail!(
            "Failed to restore version '{}': {}",
            version,
            String::from_utf8_lossy(&output.stderr)
        );
    }

    // Read the restored content
    let content = std::fs::read_to_string(repo_path.join(&file_name))
        .with_context(|| format!("Reading restored workflow '{}'", file_name))?;

    Ok(content)
}

#[cfg(test)]
mod tests {
    use super::*;

    #[test]
    fn test_versioned_repo_path() {
        let path = versioned_repo_path();
        assert!(path.to_string_lossy().contains("workflows"));
    }

    #[test]
    fn test_list_versions_no_repo() {
        // When no git repo exists, should return empty
        let result = list_versions("nonexistent-workflow");
        assert!(result.is_ok());
        assert!(result.unwrap().is_empty());
    }

    #[test]
    fn test_workflow_version_serialization() {
        let version = WorkflowVersion {
            version: "abc123".into(),
            author: "test-user".into(),
            timestamp: Utc::now(),
            diff: "Update workflow: test".into(),
        };

        let json = serde_json::to_string(&version).unwrap();
        assert!(json.contains("abc123"));
        assert!(json.contains("test-user"));
    }

    #[test]
    fn test_version_and_list_roundtrip() {
        let tmp = tempfile::tempdir().unwrap();
        let repo = tmp.path().join("workflows");
        std::fs::create_dir_all(&repo).unwrap();

        // Init a git repo manually in the temp dir
        let output = Command::new("git")
            .args(["init"])
            .current_dir(&repo)
            .output()
            .unwrap();
        assert!(output.status.success());

        // Configure git user for the test repo
        Command::new("git")
            .args(["config", "user.email", "test@test.com"])
            .current_dir(&repo)
            .output()
            .unwrap();
        Command::new("git")
            .args(["config", "user.name", "Test"])
            .current_dir(&repo)
            .output()
            .unwrap();

        // Write a file, add and commit
        let file = repo.join("test-wf.yaml");
        std::fs::write(&file, "id: test-wf\nname: Test\nsteps: []\n").unwrap();
        Command::new("git")
            .args(["add", "test-wf.yaml"])
            .current_dir(&repo)
            .output()
            .unwrap();
        Command::new("git")
            .args(["commit", "-m", "Initial"])
            .current_dir(&repo)
            .output()
            .unwrap();

        // Verify we can parse the git log format
        let output = Command::new("git")
            .args(["log", "--format=%H%n%an%n%aI%n%s%n---", "--", "test-wf.yaml"])
            .current_dir(&repo)
            .output()
            .unwrap();
        let log_str = String::from_utf8_lossy(&output.stdout);
        assert!(log_str.contains("Initial"));
    }
}