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::{error::TaskError, repo::discover_project_root};
use tempfile::TempDir;

#[test]
fn discovers_tasks_directory_from_root_nested_paths_and_files() {
    let repo = task_repo("CORE-101", "First project task");
    let nested = repo.path().join("src/deep");
    fs::create_dir_all(&nested).expect("nested directory should exist");
    let file = nested.join("input.txt");
    fs::write(&file, "input").expect("nested file should exist");

    for start in [repo.path(), nested.as_path(), file.as_path()] {
        assert_eq!(
            discover_project_root(start).expect("project should be discovered"),
            repo.path()
        );
    }

    let nonexistent = nested.join("missing/child");
    assert_eq!(
        discover_project_root(&nonexistent).expect("nonexistent path should search its ancestors"),
        repo.path()
    );
}

#[test]
fn nested_project_wins_even_when_its_tasks_are_invalid() {
    let outer = task_repo("CORE-101", "Outer project task");
    let nested = outer.path().join("nested");
    fs::create_dir_all(nested.join(".tasks/core")).expect("nested project should exist");
    fs::write(
        nested.join(".tasks/core/CORE-102-invalid.md"),
        "invalid task content",
    )
    .expect("invalid task should be written");
    let work_dir = nested.join("work");
    fs::create_dir_all(&work_dir).expect("work directory should exist");

    assert_eq!(
        discover_project_root(&work_dir).expect("nested project should be discovered"),
        nested
    );

    let output = task_command(&work_dir, ["validate"]);
    assert!(!output.status.success());
    let stderr = String::from_utf8_lossy(&output.stderr);
    assert!(stderr.contains("task validation failed"), "{stderr}");
    assert!(!stderr.contains("could not find project"), "{stderr}");
}

#[test]
fn regular_tasks_file_is_not_a_project_marker() {
    let temp = tempfile::tempdir().expect("temp directory should exist");
    let start = temp.path().join("nested");
    fs::create_dir_all(&start).expect("start directory should exist");
    fs::write(start.join(".tasks"), "not a directory").expect("marker file should exist");

    let error = discover_project_root(&start).expect_err("regular file must not mark a project");
    assert!(
        matches!(error, TaskError::ProjectNotFound { start: error_start } if error_start == start)
    );
}

#[test]
fn missing_project_error_contains_the_original_search_start() {
    let temp = tempfile::tempdir().expect("temp directory should exist");
    let start = temp.path().join("nested");
    fs::create_dir_all(&start).expect("start directory should exist");

    let output = task_command(&start, ["validate"]);
    assert!(!output.status.success());
    let stderr = String::from_utf8(output.stderr).expect("stderr should be valid UTF-8");
    assert!(stderr.contains(&start.display().to_string()), "{stderr}");
    assert!(stderr.contains(".tasks directory"), "{stderr}");
}

#[test]
fn relative_and_absolute_roots_resolve_from_the_command_working_directory() {
    let temp = tempfile::tempdir().expect("temp directory should exist");
    let repo = temp.path().join("projects/alpha");
    create_task_repo(&repo, "CORE-101", "Alpha project task");
    let nested = repo.join("src/deep");
    fs::create_dir_all(&nested).expect("nested directory should exist");
    let unrelated = temp.path().join("unrelated/work");
    fs::create_dir_all(&unrelated).expect("unrelated directory should exist");

    let relative = Path::new("../../projects/alpha/src/deep");
    let relative_output = task_command_with_root(&unrelated, relative);
    assert_task_id(relative_output, "CORE-101");

    let absolute_output = task_command_with_root(&unrelated, &nested);
    assert_task_id(absolute_output, "CORE-101");
}

#[test]
fn commands_without_root_keep_independent_projects_isolated() {
    let first = task_repo("CORE-101", "First project task");
    let second = task_repo("CORE-202", "Second project task");
    let first_work = first.path().join("src/deep");
    let second_work = second.path().join("src/deep");
    fs::create_dir_all(&first_work).expect("first work directory should exist");
    fs::create_dir_all(&second_work).expect("second work directory should exist");

    assert_task_id(
        task_command(&first_work, ["list", "--format", "json"]),
        "CORE-101",
    );
    assert_task_id(
        task_command(&second_work, ["list", "--format", "json"]),
        "CORE-202",
    );
}

#[test]
fn command_help_explains_project_discovery_and_root_paths() {
    let output = Command::new(env!("CARGO_BIN_EXE_taskroot"))
        .args(["validate", "--help"])
        .output()
        .expect("help command should run");

    assert!(output.status.success());
    let stdout = String::from_utf8(output.stdout).expect("stdout should be valid UTF-8");
    assert!(
        stdout.contains("defaults to the current directory"),
        "{stdout}"
    );
    assert!(stdout.contains("paths nested inside a project"), "{stdout}");
}

#[test]
fn compatibility_schema_file_is_ignored() {
    let repo = task_repo("CORE-101", "Compatibility file task");
    fs::write(
        repo.path().join(".tasks/task.schema.json"),
        "not schema content",
    )
    .expect("compatibility file should be written");

    let output = task_command(repo.path(), ["validate"]);
    assert!(
        output.status.success(),
        "{}",
        String::from_utf8_lossy(&output.stderr)
    );
}

fn task_repo(id: &str, title: &str) -> TempDir {
    let temp = tempfile::tempdir().expect("temp directory should exist");
    create_task_repo(temp.path(), id, title);
    temp
}

fn create_task_repo(root: &Path, id: &str, title: &str) {
    fs::create_dir_all(root.join(".tasks/core")).expect("task directory should exist");
    fs::write(
        root.join(".tasks/core").join(format!("{id}-task.md")),
        format!(
            "---\nid: {id}\ntitle: {title}\nstatus: To Do\npriority: High\ntype: Feature\n---\n\n## Acceptance Criteria\n\n- [ ] Works\n"
        ),
    )
    .expect("task should be written");
}

fn task_command<const N: usize>(current_dir: &Path, args: [&str; N]) -> std::process::Output {
    Command::new(env!("CARGO_BIN_EXE_taskroot"))
        .args(args)
        .current_dir(current_dir)
        .output()
        .expect("taskroot command should run")
}

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

fn assert_task_id(output: std::process::Output, expected: &str) {
    assert!(
        output.status.success(),
        "{}",
        String::from_utf8_lossy(&output.stderr)
    );
    let tasks: Value = serde_json::from_slice(&output.stdout).expect("stdout should be JSON");
    let tasks = tasks.as_array().expect("task output should be an array");
    assert_eq!(tasks.len(), 1);
    assert_eq!(tasks[0]["id"], expected);
}