assistant 1.1.0

Layer 3 super-app aggregating all claude_* CLI commands.
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
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148

//! `clt` CLI sanity tests
//!
//! ## Purpose
//!
//! Verify that the `assistant` crate and its `clt` binary compile and
//! link correctly against all aggregated Layer 2 crates. These tests do not
//! exercise runtime behaviour — the binary integration tests are in the
//! individual `claude_version`, `claude_runner`, `claude_storage`, and
//! `claude_profile` crates.
//!
//! ## Coverage
//!
//! - The crate name and version are present (confirms build metadata)
//! - The `clt` binary is present in the build output
//!
//! ## Test Matrix
//!
//! | Test | Scenario |
//! |------|----------|
//! | `clt_package_name_is_assistant` | build metadata sanity |
//! | `clt_binary_is_present` | binary builds and runs |
//! | `clt_processes_command_accepted` | `.processes` routed via manager programmatic registration |
//! | `clt_sessions_accepts_scope_param` | storage `.sessions` accepts `scope::` (manager collision gone) |
//! | `clt_usage_command_accepted` | `.usage` routed via profile programmatic registration |
//! | `clt_paths_command_accepted` | `.paths` routed via profile programmatic registration |
//! | `clt_account_list_command_accepted` | `.account.list` routed via manager (first-wins) |

#[test]
fn clt_package_name_is_assistant()
{
  let name = env!( "CARGO_PKG_NAME" );
  assert_eq!( name, "assistant", "unexpected package name: {name}" );
}

#[test]
fn clt_binary_is_present()
{
  // Locate the `clt` binary in Cargo's output directory.
  // `cargo_bin!` panics if the binary is absent — indicating the [[bin]] entry
  // in Cargo.toml is missing or the `enabled` feature was not activated.
  let bin = assert_cmd::cargo::cargo_bin!( "clt" );
  assert!( bin.exists(), "clt binary not found at: {}", bin.display() );
}

/// Verify `.processes` is routed through `clt` via manager's programmatic registration.
#[test]
fn clt_processes_command_accepted()
{
  let home = tempfile::TempDir::new().unwrap();
  let out = std::process::Command::new(
    assert_cmd::cargo::cargo_bin!( "clt" )
  )
    .env( "HOME", home.path() )
    .args( [ ".processes" ] )
    .output()
    .unwrap();
  assert_eq!(
    out.status.code().unwrap_or( -1 ), 0,
    "clt .processes should exit 0; stderr: {}",
    String::from_utf8_lossy( &out.stderr ),
  );
}

/// After `.sessions` → `.processes` rename in manager, storage's `.sessions`
/// (scope-based session listing) is now the winner in `clt`.  It accepts `scope::`.
#[test]
fn clt_sessions_accepts_scope_param()
{
  let home = tempfile::TempDir::new().unwrap();
  let out = std::process::Command::new(
    assert_cmd::cargo::cargo_bin!( "clt" )
  )
    .env( "HOME", home.path() )
    .args( [ ".sessions", "scope::local" ] )
    .output()
    .unwrap();
  assert_eq!(
    out.status.code().unwrap_or( -1 ), 0,
    "clt .sessions scope::local must succeed (storage variant accepts scope); stderr: {}",
    String::from_utf8_lossy( &out.stderr ),
  );
}

/// Verify `.usage` is routed through `clt` via profile's programmatic registration.
///
/// `.usage` reads `stats-cache.json` which may not exist in a fresh temp HOME,
/// so exit 2 (runtime error) is acceptable — it proves the command was found
/// and dispatched.  Exit 1 would mean unknown command (registration failure).
#[test]
fn clt_usage_command_accepted()
{
  let home = tempfile::TempDir::new().unwrap();
  let out = std::process::Command::new(
    assert_cmd::cargo::cargo_bin!( "clt" )
  )
    .env( "HOME", home.path() )
    .args( [ ".usage" ] )
    .output()
    .unwrap();
  let code = out.status.code().unwrap_or( -1 );
  assert_ne!(
    code, 1,
    "clt .usage must not exit 1 (unknown command); stderr: {}",
    String::from_utf8_lossy( &out.stderr ),
  );
}

/// Verify `.paths` is routed through `clt` via profile's programmatic registration.
#[test]
fn clt_paths_command_accepted()
{
  let home = tempfile::TempDir::new().unwrap();
  let out = std::process::Command::new(
    assert_cmd::cargo::cargo_bin!( "clt" )
  )
    .env( "HOME", home.path() )
    .args( [ ".paths" ] )
    .output()
    .unwrap();
  assert_eq!(
    out.status.code().unwrap_or( -1 ), 0,
    "clt .paths should exit 0; stderr: {}",
    String::from_utf8_lossy( &out.stderr ),
  );
}

/// Verify `.account.list` is routed through `clt`.
///
/// `.account.list` belongs exclusively to `claude_profile` — `claude_version`
/// does NOT register any `.account.*` commands. Profile owns all five account
/// commands; manager owns version, processes, and settings only.
#[test]
fn clt_account_list_command_accepted()
{
  let home = tempfile::TempDir::new().unwrap();
  let out = std::process::Command::new(
    assert_cmd::cargo::cargo_bin!( "clt" )
  )
    .env( "HOME", home.path() )
    .args( [ ".account.list" ] )
    .output()
    .unwrap();
  assert_eq!(
    out.status.code().unwrap_or( -1 ), 0,
    "clt .account.list should exit 0; stderr: {}",
    String::from_utf8_lossy( &out.stderr ),
  );
}