cat-fetch 0.1.1

MusKitty multi-repo source management CLI — one command to clone, build, test, push, and publish 8 independent crate repositories
//! `cat setup <project>` — one-command dev environment setup.

use crate::config::Config;
use crate::git;
use crate::ui;
use std::path::Path;

pub fn run(config: Config, project: &str) {
    ui::heading(&format!("Setting up {} development environment", project));

    // Step 1: Ensure all repos are cloned
    ui::heading("── Step 1: Clone missing repos ──");
    let crates_token = std::env::var("CRATES_GIT_TOKEN").ok();
    let main_token = std::env::var("MAIN_GIT_TOKEN").ok();

    // Main repo
    let _ = git::clone(
        &config.main_repo.url,
        &config.main_repo.dir,
        main_token.as_deref(),
    );
    if let Some(ref upstream) = config.main_repo.upstream {
        if git::is_git_repo(&config.main_repo.dir) {
            let _ = git::fetch_upstream(&config.main_repo.dir, upstream);
        }
    }

    // Crate repos
    let token = crates_token.as_deref();
    for repo in &config.repos {
        let _ = git::clone(&repo.url, &repo.abs_dir, token);
    }

    // Step 2: Verify path dependencies
    ui::heading("── Step 2: Verify path dependencies ──");
    let mut all_ok = true;
    for repo in &config.repos {
        if !repo.abs_dir.join("Cargo.toml").is_file() {
            continue; // Not cloned yet
        }
        let missing = check_path_deps(&repo.abs_dir, &config.crates_dir);
        if missing.is_empty() {
            ui::info(&format!("{} — all deps resolved", repo.name));
        } else {
            ui::warn(&format!(
                "{} — missing path deps: {}",
                repo.name,
                missing.join(", ")
            ));
            all_ok = false;
        }
    }

    // Step 3: Pull latest
    ui::heading("── Step 3: Pull latest ──");
    let _ = git::pull(&config.main_repo.dir);
    for repo in &config.repos {
        let _ = git::pull(&repo.abs_dir);
    }

    // Report
    ui::separator();
    if all_ok {
        ui::success(&format!(
            "✓ {} ready — {}/{} crates available",
            project,
            count_cloned(&config),
            config.repos.len()
        ));
    } else {
        ui::warn("Some path dependencies are missing. Run 'cat setup <project>' again or 'cat clone <project>' to fix.");
    }
}

/// Check that all `path = "../xxx"` deps in a crate's Cargo.toml point to existing dirs.
fn check_path_deps(crate_dir: &Path, _crates_dir: &Path) -> Vec<String> {
    let mut missing = Vec::new();
    let cargo_toml = crate_dir.join("Cargo.toml");
    if !cargo_toml.is_file() {
        return missing;
    }
    let content = match std::fs::read_to_string(&cargo_toml) {
        Ok(c) => c,
        Err(_) => return missing,
    };

    for line in content.lines() {
        let trimmed = line.trim();
        if trimmed.starts_with("path") && trimmed.contains('=') {
            if let Some(start) = trimmed.find('"') {
                let rest = &trimmed[start + 1..];
                if let Some(end) = rest.find('"') {
                    let dep_path = &rest[..end];
                    // Resolve relative path
                    let abs_dep = crate_dir.join(dep_path);
                    if !abs_dep.join("Cargo.toml").is_file() {
                        if let Some(name) = abs_dep.file_name() {
                            missing.push(name.to_string_lossy().to_string());
                        }
                    }
                }
            }
        }
    }
    missing
}

fn count_cloned(config: &Config) -> usize {
    config
        .repos
        .iter()
        .filter(|r| r.abs_dir.join("Cargo.toml").is_file() && git::is_git_repo(&r.abs_dir))
        .count()
}