dpc-tau-cli 0.2.1

A minimal Unix-first coding agent.
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109

use std::path::PathBuf;

use super::*;
use crate::cli as path_crate_cli;

fn session(session_id: &str, project_root: impl Into<PathBuf>) -> RunningSession {
    RunningSession {
        session_id: session_id
            .parse::<tau_proto::SessionId>()
            .expect("known-safe SessionId must be valid"),
        project_root: project_root.into(),
    }
}

/// Bare output remains sorted, deduplicated, and headerless even
/// when multiple responsive harnesses report the same current session id.
#[test]
fn human_output_preserves_running_session_list_contract() {
    let output = render(
        &[
            session("z-session", "/work/z"),
            session("a_session", "/work/a"),
            session("a_session", "/work/duplicate"),
        ],
        &path_crate_cli::SessionListArgs::default(),
    )
    .expect("human output");

    assert_eq!(output, "a_session\nz-session\n");
}

/// JSON always emits one array with the two required stable fields and retains
/// one record per responsive harness so callers can detect duplicate
/// identities.
#[test]
fn json_output_preserves_each_responsive_harness_record() {
    let output = render(
        &[
            session("same-session", "/work/project"),
            session("same-session", "/work/project"),
        ],
        &crate::cli::SessionListArgs {
            dir: None,
            json: true,
        },
    )
    .expect("JSON output");

    let value: serde_json::Value = serde_json::from_str(&output).expect("valid JSON");
    assert_eq!(
        value,
        serde_json::json!([
            {
                "session_id": "same-session",
                "project_root": "/work/project"
            },
            {
                "session_id": "same-session",
                "project_root": "/work/project"
            }
        ])
    );
}

/// Directory filtering compares the already-canonical roots exactly rather than
/// admitting a parent, child, or textual-prefix path.
#[test]
fn directory_filter_matches_only_the_exact_project_root() {
    let output = render(
        &[
            session("parent", "/work"),
            session("exact", "/work/project"),
            session("child", "/work/project/child"),
            session("prefix", "/work/project-other"),
        ],
        &crate::cli::SessionListArgs {
            dir: Some(PathBuf::from("/work/project")),
            json: false,
        },
    )
    .expect("filtered output");

    assert_eq!(output, "exact\n");
}

/// Complete discovery stays silent so routine human and machine-readable
/// listings do not gain an unconditional stderr side channel.
#[test]
fn complete_listing_has_no_warning() {
    assert_eq!(incomplete_claim_warning(0), None);
}

/// Partial discovery reports one count-bearing warning without changing either
/// stdout representation.
#[test]
fn incomplete_listing_warning_is_counted_and_pluralized() {
    assert_eq!(
        incomplete_claim_warning(1).as_deref(),
        Some(
            "warning: omitted 1 contended runtime claim that did not complete compatible exact-session admission"
        )
    );
    assert_eq!(
        incomplete_claim_warning(3).as_deref(),
        Some(
            "warning: omitted 3 contended runtime claims that did not complete compatible exact-session admission"
        )
    );
}