taskroot 0.1.2

Project-local Markdown task tracking for humans and coding agents
Documentation
use std::{fs, path::Path, process::Command};

use serde_json::Value;
use taskroot::{project::TaskProject, validate::validate_repo};
use tempfile::TempDir;

fn project(domains: &[(&str, &str)]) -> TempDir {
    let temp = tempfile::tempdir().expect("temp project created");
    fs::create_dir(temp.path().join(".tasks")).expect("task directory created");
    let domains = domains
        .iter()
        .map(|(domain, prefix)| format!(r#""{domain}": {{"prefixes": ["{prefix}"]}}"#))
        .collect::<Vec<_>>()
        .join(",");
    fs::write(
        temp.path().join(".tasks/config.json"),
        format!(r#"{{"version":1,"domains":{{{domains}}},"task_types":{{"Feature":{{"criteria":"acceptance"}}}},"tags":{{"policy":"open"}}}}"#),
    )
    .expect("configuration written");
    temp
}

fn write_task(root: &Path, domain: &str, id: &str, suffix: &str) {
    let directory = root.join(".tasks").join(domain);
    fs::create_dir_all(&directory).expect("domain directory created");
    fs::write(
        directory.join(format!("{id}-{suffix}.md")),
        format!(
            "---\nid: {id}\ntitle: Domain task {suffix}\nstatus: To Do\npriority: High\n\
             type: Feature\n---\n\n## Summary\n\nExercise project domain behavior.\n\n\
             ## Acceptance Criteria\n\n- [ ] Domain behavior works.\n"
        ),
    )
    .expect("task written");
}

fn run(root: &Path, args: &[&str]) -> std::process::Output {
    Command::new(env!("CARGO_BIN_EXE_taskroot"))
        .args(args)
        .arg("--root")
        .arg(root)
        .output()
        .expect("taskroot command should run")
}

fn add(root: &Path, domain: Option<&str>, id: &str) -> std::process::Output {
    let mut args = vec![
        "add",
        "--id",
        id,
        "--title",
        "Domain task title",
        "--priority",
        "High",
        "--type",
        "Feature",
    ];
    if let Some(domain) = domain {
        args.extend(["--domain", domain]);
    }
    run(root, &args)
}

#[test]
fn configured_domains_load_exact_local_ids_and_cross_domain_duplicates() {
    let repo = project(&[("backend", "WORK"), ("release", "WORK")]);
    write_task(repo.path(), "backend", "WORK-001", "backend");
    write_task(repo.path(), "backend", "WORK-1", "short-number");
    let created = add(repo.path(), None, "release:WORK-001");
    assert!(created.status.success());

    let output = run(
        repo.path(),
        &["list", "--sort-by", "id", "--format", "json"],
    );

    assert!(output.status.success());
    let tasks: Value = serde_json::from_slice(&output.stdout).expect("list output should be JSON");
    let tasks = tasks.as_array().expect("list output should be an array");
    assert_eq!(tasks.len(), 3);
    for (domain, id) in [
        ("backend", "WORK-001"),
        ("backend", "WORK-1"),
        ("release", "WORK-001"),
    ] {
        assert!(
            tasks
                .iter()
                .any(|task| task["domain"] == domain && task["id"] == id)
        );
    }

    let filtered = run(
        repo.path(),
        &["list", "--domain", "release", "--format", "json"],
    );
    let tasks: Value = serde_json::from_slice(&filtered.stdout).expect("filtered output is JSON");
    assert_eq!(tasks.as_array().expect("array output").len(), 1);
    assert_eq!(tasks[0]["domain"], "release");
    assert_eq!(tasks[0]["id"], "WORK-001");
}

#[test]
fn add_accepts_qualified_and_explicit_default_domain_forms() {
    let repo = project(&[("default", "WORK")]);

    let qualified = add(repo.path(), Some("default"), "default:WORK-001");
    assert!(qualified.status.success());

    let explicit = add(repo.path(), Some("default"), "WORK-002");
    assert!(explicit.status.success());
}

#[test]
fn add_requires_a_domain_and_rejects_conflicts() {
    let repo = project(&[("default", "WORK"), ("release", "WORK")]);
    let required = add(repo.path(), None, "WORK-001");
    assert!(!required.status.success());
    assert!(String::from_utf8_lossy(&required.stderr).contains("domain is required"));

    let conflict = add(repo.path(), Some("release"), "default:WORK-001");
    assert!(!conflict.status.success());
    assert!(String::from_utf8_lossy(&conflict.stderr).contains("conflicts with"));
}

#[test]
fn add_rejects_invalid_and_windows_device_domains() {
    let repo = project(&[("work", "WORK")]);
    for domain in ["Core", "con", "nul", "com1", "lpt1"] {
        let id = format!("{domain}:WORK-001");
        let output = add(repo.path(), None, &id);
        assert!(!output.status.success());
        assert!(String::from_utf8_lossy(&output.stderr).contains(domain));
    }
}

#[test]
fn layout_ignores_reserved_files_and_reports_undeclared_domains() {
    let repo = project(&[("work", "WORK")]);
    fs::write(repo.path().join(".tasks/task.schema.json"), "{}")
        .expect("compatibility schema written");
    write_task(repo.path(), "work", "WORK-001", "configured");
    write_task(repo.path(), "ghost", "WORK-002", "undeclared");

    let project = TaskProject::open(repo.path()).expect("project opens");
    let report = validate_repo(&project).expect("repository scan succeeds");

    assert!(
        report
            .errors
            .iter()
            .any(|error| error.message.contains("undeclared task domain ghost"))
    );
    assert!(
        !report
            .errors
            .iter()
            .any(|error| error.message.contains("task.schema.json"))
    );
    assert_eq!(report.tasks.len(), 1);
    assert_eq!(report.tasks[0].domain, "work");
}