codetree 0.2.0

AI-native version control system for autonomous agents
Documentation
use crate::error::{Context, Result};

use crate::branch::{BranchManager, BranchStatus};
use crate::vcs::VcsManager;

use super::{load_config, run_hooks, withdraw_single};
use super::merge::merge_command;

pub async fn finish_command(branch: Option<String>, tag: Option<String>, dry_run: bool) -> Result<()> {
    if let Some(tag) = tag {
        let current_dir = std::env::current_dir()
            .context("Failed to get current directory")?;
        let branch_manager = BranchManager::new(
            current_dir.join(".codetree").join("branches.json")
        ).await?;

        let tagged: Vec<_> = branch_manager.list_branches_by_tag(&tag)
            .into_iter()
            .filter(|b| matches!(b.status, BranchStatus::Active))
            .map(|b| b.name.clone())
            .collect();

        if tagged.is_empty() {
            return Err(format!("No active operations with tag '{}'", tag).into());
        }

        if dry_run {
            println!("[dry-run] Would finish {} operation(s) with tag '{}':", tagged.len(), tag);
            for name in &tagged {
                println!("  - {}", name);
            }
            return Ok(());
        }

        println!("Finishing {} operation(s) with tag '{}'", tagged.len(), tag);
        let mut errors = Vec::new();
        for name in tagged {
            if let Err(e) = merge_command(Some(name), false).await {
                errors.push(e.to_string());
            }
        }
        if !errors.is_empty() {
            return Err(format!("Batch finish completed with {} error(s): {}", errors.len(), errors.join("; ")).into());
        }
        return Ok(());
    }

    if dry_run {
        let current_dir = std::env::current_dir()
            .context("Failed to get current directory")?;
        let git_manager = VcsManager::new(current_dir.clone())?;
        let branch_manager = BranchManager::new(
            current_dir.join(".codetree").join("branches.json")
        ).await?;
        let config = load_config(None).await?;
        let base_branch = &config.git.base_branch;

        let current = git_manager.get_current_branch().await?;
        let target = branch.unwrap_or(current);
        let branch_info = branch_manager.get_branch(&target)
            .ok_or_else(|| format!("Branch '{}' is not tracked by codetree", target))?;
        if !matches!(branch_info.status, BranchStatus::Active) {
            return Err(format!("Branch '{}' is not active (status: {})", target, branch_info.status.as_str()).into());
        }
        let (ahead, behind) = git_manager.get_branch_divergence(&target, base_branch).unwrap_or((0, 0));
        println!("[dry-run] Would finish: {}", target);
        println!("  Merge '{}' into '{}'", target, base_branch);
        println!("  Divergence: +{} / -{}", ahead, behind);
        if !branch_info.depends_on.is_empty() {
            let unmerged: Vec<_> = branch_info.depends_on.iter()
                .filter(|d| branch_manager.get_branch(d)
                    .map(|b| matches!(b.status, BranchStatus::Active))
                    .unwrap_or(false))
                .collect();
            if !unmerged.is_empty() {
                println!("  Warning: unmerged dependencies: {}", unmerged.iter().map(|s| s.as_str()).collect::<Vec<_>>().join(", "));
            }
        }
        println!("  Would delete branch ref and mark as merged");
        return Ok(());
    }

    let config = load_config(None).await?;
    let current_dir = std::env::current_dir()
        .context("Failed to get current directory")?;

    run_hooks(&config, "pre_finish", &current_dir).await?;

    merge_command(branch, false).await?;

    run_hooks(&config, "post_finish", &current_dir).await?;

    Ok(())
}

pub async fn withdraw_command(branch: Option<String>, tag: Option<String>) -> Result<()> {
    if let Some(tag) = tag {
        let current_dir = std::env::current_dir()
            .context("Failed to get current directory")?;
        let branch_manager = BranchManager::new(
            current_dir.join(".codetree").join("branches.json")
        ).await?;

        let tagged: Vec<_> = branch_manager.list_branches_by_tag(&tag)
            .into_iter()
            .filter(|b| matches!(b.status, BranchStatus::Active))
            .map(|b| b.name.clone())
            .collect();

        if tagged.is_empty() {
            return Err(format!("No active operations with tag '{}'", tag).into());
        }

        println!("Withdrawing {} operation(s) with tag '{}'", tagged.len(), tag);
        let mut errors = Vec::new();
        for name in tagged {
            if let Err(e) = withdraw_single(&name).await {
                errors.push(e.to_string());
            }
        }
        if !errors.is_empty() {
            return Err(format!("Batch withdraw completed with {} error(s): {}", errors.len(), errors.join("; ")).into());
        }
        return Ok(());
    }

    let branch_name = branch.ok_or("Must specify a branch or --tag")?;
    withdraw_single(&branch_name).await
}