use std::path::Path;
use crate::model::Pane;
use crate::subagents::{Subagent, SubagentRoster};
pub const AGENT_CWD_TOKEN: &str = "vsh-cwd";
#[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord)]
pub enum CwdSource {
SubagentReported,
AgentReported,
Foreground,
PaneStart,
}
impl CwdSource {
pub fn marker(self) -> &'static str {
match self {
Self::SubagentReported => "subagent",
Self::AgentReported => "agent",
Self::Foreground => "process",
Self::PaneStart => "launch",
}
}
pub fn is_reported(self) -> bool {
matches!(self, Self::SubagentReported | Self::AgentReported)
}
}
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub struct Cwd<'a> {
pub path: &'a str,
pub source: CwdSource,
}
impl<'a> Cwd<'a> {
pub fn as_path(&self) -> &'a Path {
Path::new(self.path)
}
}
#[derive(Debug, Clone, Copy, Default)]
pub struct Reported<'a> {
pub subagent: Option<&'a Subagent>,
pub roster: Option<&'a SubagentRoster>,
}
pub fn resolve(pane: &Pane) -> Option<Cwd<'_>> {
resolve_with(pane, Reported::default())
}
pub fn resolve_with<'a>(pane: &'a Pane, known: Reported<'a>) -> Option<Cwd<'a>> {
let candidates = [
(
CwdSource::SubagentReported,
known.subagent.and_then(|subagent| subagent.cwd.as_deref()),
),
(
CwdSource::AgentReported,
known
.roster
.and_then(|roster| roster.cwd.as_deref())
.or_else(|| pane.tokens.get(AGENT_CWD_TOKEN).and_then(Option::as_deref)),
),
(CwdSource::Foreground, pane.foreground_cwd.as_deref()),
(CwdSource::PaneStart, pane.cwd.as_deref()),
];
candidates.into_iter().find_map(|(source, path)| {
path.filter(|value| !value.is_empty())
.map(|path| Cwd { path, source })
})
}
#[cfg(test)]
mod tests {
use super::*;
fn pane() -> Pane {
Pane {
cwd: Some("/launch".into()),
foreground_cwd: Some("/process".into()),
..Pane::default()
}
}
fn reported(pane: &mut Pane, value: Option<&str>) {
pane.tokens
.insert(AGENT_CWD_TOKEN.to_string(), value.map(str::to_owned));
}
fn isolated(cwd: &str) -> Subagent {
Subagent {
name: "child".into(),
cwd: Some(cwd.into()),
..Subagent::default()
}
}
#[test]
fn an_erased_token_still_resolves_from_the_roster_file() {
let mut pane = pane();
reported(&mut pane, None);
let long = format!(
"/Users/operator/workspace/project/repo/_worktrees/{}",
"a".repeat(40)
);
assert!(
long.len() > 80,
"the path has to be one a token could not hold"
);
let roster = SubagentRoster {
cwd: Some(long.clone()),
..SubagentRoster::default()
};
let resolved = resolve_with(
&pane,
Reported {
roster: Some(&roster),
..Reported::default()
},
)
.unwrap();
assert_eq!(resolved.path, long);
assert_eq!(resolved.source, CwdSource::AgentReported);
}
#[test]
fn a_worktree_isolated_subagent_outranks_its_parents_own_report() {
let mut pane = pane();
reported(&mut pane, Some("/where/the/parent/is"));
let child = isolated("/repo/_worktrees/child");
let resolved = resolve_with(
&pane,
Reported {
subagent: Some(&child),
..Reported::default()
},
)
.unwrap();
assert_eq!(resolved.path, "/repo/_worktrees/child");
assert_eq!(resolved.source, CwdSource::SubagentReported);
}
#[test]
fn a_subagent_sharing_its_parents_directory_falls_through_to_the_parent() {
let mut pane = pane();
reported(&mut pane, Some("/where/the/parent/is"));
let child = Subagent {
name: "child".into(),
..Subagent::default()
};
let resolved = resolve_with(
&pane,
Reported {
subagent: Some(&child),
..Reported::default()
},
)
.unwrap();
assert_eq!(resolved.path, "/where/the/parent/is");
assert_eq!(resolved.source, CwdSource::AgentReported);
}
#[test]
fn a_roster_beats_the_token_it_duplicates() {
let long = format!(
"/Users/operator/workspace/{}/_worktrees/child",
"x".repeat(60)
);
let mut pane = pane();
reported(&mut pane, Some(&long[..80]));
let roster = SubagentRoster {
cwd: Some(long.clone()),
..SubagentRoster::default()
};
let resolved = resolve_with(
&pane,
Reported {
roster: Some(&roster),
..Reported::default()
},
)
.unwrap();
assert_eq!(resolved.path, long);
assert_eq!(resolved.source, CwdSource::AgentReported);
}
#[test]
fn a_roster_without_a_directory_leaves_the_token_in_charge() {
let mut pane = pane();
reported(&mut pane, Some("/from/the/token"));
let roster = SubagentRoster::default();
let resolved = resolve_with(
&pane,
Reported {
roster: Some(&roster),
..Reported::default()
},
)
.unwrap();
assert_eq!(resolved.path, "/from/the/token");
}
#[test]
fn selecting_the_parent_ignores_a_subagents_directory() {
let pane = pane();
assert_eq!(resolve(&pane).unwrap().source, CwdSource::Foreground);
}
#[test]
fn only_the_reported_sources_can_see_an_agent_move() {
assert!(CwdSource::SubagentReported.is_reported());
assert!(CwdSource::AgentReported.is_reported());
assert!(!CwdSource::Foreground.is_reported());
assert!(!CwdSource::PaneStart.is_reported());
}
#[test]
fn the_agents_own_report_wins() {
let mut pane = pane();
reported(&mut pane, Some("/where/the/agent/actually/is"));
let resolved = resolve(&pane).unwrap();
assert_eq!(resolved.path, "/where/the/agent/actually/is");
assert_eq!(resolved.source, CwdSource::AgentReported);
}
#[test]
fn foreground_is_used_when_no_agent_has_reported() {
let pane = pane();
let resolved = resolve(&pane).unwrap();
assert_eq!(resolved.path, "/process");
assert_eq!(resolved.source, CwdSource::Foreground);
}
#[test]
fn launch_is_the_floor() {
let mut pane = pane();
pane.foreground_cwd = None;
let resolved = resolve(&pane).unwrap();
assert_eq!(resolved.path, "/launch");
assert_eq!(resolved.source, CwdSource::PaneStart);
}
#[test]
fn an_erased_token_falls_through_rather_than_blanking_the_answer() {
let mut pane = pane();
reported(&mut pane, None);
assert_eq!(resolve(&pane).unwrap().source, CwdSource::Foreground);
reported(&mut pane, Some(""));
assert_eq!(resolve(&pane).unwrap().source, CwdSource::Foreground);
}
#[test]
fn a_pane_with_nothing_to_go_on_resolves_to_nothing() {
assert_eq!(resolve(&Pane::default()), None);
}
#[test]
fn precedence_is_the_declaration_order() {
assert!(CwdSource::SubagentReported < CwdSource::AgentReported);
assert!(CwdSource::AgentReported < CwdSource::Foreground);
assert!(CwdSource::Foreground < CwdSource::PaneStart);
}
}