feat(maestro): TUI spawn form stops naming sessions
The name field starts empty behind a hint, ^R reroll is gone, and the fetched handle seeds the worktree branch instead. Fast-forward spawns with no name at all. A card whose name the daemon generated renders muted. Refs #131
This commit is contained in:
@@ -112,8 +112,6 @@ pub enum Effect {
|
||||
/// Fast-forward spawn (#67): resolve every default from the daemon and
|
||||
/// spawn with no form; unresolvable defaults open a pre-filled form.
|
||||
FastForward,
|
||||
/// A reroll drained the form's local name batch (#64).
|
||||
RefillNames,
|
||||
/// The form's target changed: probe `/api/gitroot` so the worktree
|
||||
/// section knows its base repo (#65). `seq` guards stale answers.
|
||||
ProbeGitRoot {
|
||||
@@ -301,7 +299,6 @@ impl App {
|
||||
Effect::Kill(id) => self.submit_kill(id).await,
|
||||
Effect::LoadDraft => self.spawn_load_draft(),
|
||||
Effect::FastForward => self.spawn_fast_forward(),
|
||||
Effect::RefillNames => self.spawn_refill_names(),
|
||||
Effect::ProbeGitRoot { seq, path } => self.spawn_probe_git_root(seq, path),
|
||||
Effect::LoadBranches => self.spawn_load_branches(),
|
||||
Effect::Rename { id, name } => self.submit_rename(id, &name).await,
|
||||
@@ -649,9 +646,6 @@ impl App {
|
||||
Err(e) => draft.error = Some(e.to_string()),
|
||||
}
|
||||
}
|
||||
if draft.take_name_refill() {
|
||||
effects.push(Effect::RefillNames);
|
||||
}
|
||||
if let Some((seq, path)) = draft.take_gitroot_probe(std::time::Instant::now()) {
|
||||
effects.push(Effect::ProbeGitRoot { seq, path });
|
||||
}
|
||||
@@ -696,17 +690,6 @@ impl App {
|
||||
});
|
||||
}
|
||||
|
||||
fn spawn_refill_names(&self) {
|
||||
let Some(draft) = self.draft_id() else {
|
||||
return;
|
||||
};
|
||||
let (_, http, base, tx) = self.loader_handles();
|
||||
tokio::spawn(async move {
|
||||
let names = fetch_names(&http, &base, crate::draft::NAME_BATCH_SIZE).await;
|
||||
let _ = tx.send(DraftUpdate::Names { draft, names });
|
||||
});
|
||||
}
|
||||
|
||||
fn spawn_probe_git_root(&self, seq: u32, path: PathBuf) {
|
||||
let Some(draft) = self.draft_id() else {
|
||||
return;
|
||||
@@ -774,7 +757,6 @@ impl App {
|
||||
}
|
||||
let want = match &update {
|
||||
DraftUpdate::Data { draft, .. }
|
||||
| DraftUpdate::Names { draft, .. }
|
||||
| DraftUpdate::GitRoot { draft, .. }
|
||||
| DraftUpdate::Branches { draft, .. } => *draft,
|
||||
// Handled above; it targets no particular draft.
|
||||
@@ -806,11 +788,6 @@ impl App {
|
||||
draft.seed_names(names);
|
||||
}
|
||||
}
|
||||
DraftUpdate::Names { names, .. } => {
|
||||
if !names.is_empty() {
|
||||
draft.extend_names(names);
|
||||
}
|
||||
}
|
||||
DraftUpdate::GitRoot { seq, root, .. } => {
|
||||
draft.resolve_gitroot(seq, root);
|
||||
follow_up_branches = draft.take_branch_load().is_some();
|
||||
@@ -1147,10 +1124,6 @@ enum DraftUpdate {
|
||||
projects: Option<Vec<maestro_protocol::Project>>,
|
||||
names: Vec<String>,
|
||||
},
|
||||
Names {
|
||||
draft: u64,
|
||||
names: Vec<String>,
|
||||
},
|
||||
GitRoot {
|
||||
draft: u64,
|
||||
seq: u32,
|
||||
@@ -1639,7 +1612,8 @@ mod tests {
|
||||
let req = &posts[0];
|
||||
assert_eq!(req["cwd"], json!("/repos/fresh"));
|
||||
assert_eq!(req["command"], json!("aider"));
|
||||
assert_eq!(req["metadata"]["name"], json!("crimson-otter"));
|
||||
// #131: the fast path names no session; the daemon does.
|
||||
assert_eq!(req["metadata"], json!({}));
|
||||
assert_eq!(req["worktree"]["base_repo"], json!("/repos/fresh"));
|
||||
assert_eq!(req["worktree"]["branch"], json!("crimson-otter"));
|
||||
assert_eq!(req["worktree"]["create_branch"], json!(true));
|
||||
@@ -1691,9 +1665,10 @@ mod tests {
|
||||
"the fallback is the spawn modal"
|
||||
);
|
||||
let draft = app.draft.as_ref().expect("a form behind the modal");
|
||||
// Whatever did resolve (nothing project-side) is seeded; the
|
||||
// generated name still lands so the form is ready to go.
|
||||
assert_eq!(draft.name.value(), "amber-falcon");
|
||||
// Whatever did resolve (nothing project-side) is seeded. The name
|
||||
// field stays empty (#131); the handle seeds the branch instead.
|
||||
assert_eq!(draft.name.value(), "");
|
||||
assert_eq!(draft.branch.value(), "amber-falcon");
|
||||
assert_eq!(draft.command(), "claude");
|
||||
}
|
||||
|
||||
@@ -1893,7 +1868,7 @@ mod tests {
|
||||
/// built-ins, projects land sorted, and the first generated name seeds
|
||||
/// the field.
|
||||
#[tokio::test]
|
||||
async fn load_draft_data_fills_presets_projects_and_names() {
|
||||
async fn load_draft_data_fills_presets_projects_and_the_branch_handle() {
|
||||
use axum::routing::get;
|
||||
use axum::Json;
|
||||
use serde_json::json;
|
||||
@@ -1946,7 +1921,12 @@ mod tests {
|
||||
assert_eq!(draft.groups.len(), 1);
|
||||
assert_eq!(draft.groups[0].main.name, "maestro");
|
||||
assert_eq!(draft.home_dir, "/home/u");
|
||||
assert_eq!(draft.name.value(), "crimson-otter");
|
||||
assert_eq!(
|
||||
draft.name.value(),
|
||||
"",
|
||||
"the operator names it, or nobody does"
|
||||
);
|
||||
assert_eq!(draft.branch.value(), "crimson-otter");
|
||||
}
|
||||
|
||||
/// Keys fed while the form is not up must be ignored, not panic.
|
||||
|
||||
+97
-107
@@ -10,7 +10,7 @@
|
||||
//! entry), a two-step project/worktree picker (#96, mirroring the web
|
||||
//! redesign in #95) fed by [`crate::projects`] over `/api/projects` plus an
|
||||
//! `Other directory…` escape hatch, a generated session name from
|
||||
//! `/api/names` with a reroll key, and validation that reports which field is
|
||||
//! `/api/names` for the branch default, and validation that reports which field is
|
||||
//! missing instead of posting an empty request. A worktree section (#65)
|
||||
//! mirrors `web/src/spawnForm.ts`: on by default over a git repository,
|
||||
//! branch tracking the generated name until touched, with a new-or-existing
|
||||
@@ -36,7 +36,6 @@
|
||||
//! 7. Neither step touches the command: the directory and what runs in it
|
||||
//! are independent choices.
|
||||
|
||||
use std::collections::VecDeque;
|
||||
use std::path::{Path, PathBuf};
|
||||
use std::time::{Duration, Instant};
|
||||
|
||||
@@ -53,10 +52,13 @@ use ratatui::Frame;
|
||||
use crate::input::InputKey;
|
||||
use crate::projects;
|
||||
|
||||
/// How many generated names one `/api/names` refill fetches. Rerolls consume
|
||||
/// the local batch so they stay instant; the daemon is hit only when it runs
|
||||
/// dry.
|
||||
pub const NAME_BATCH_SIZE: usize = 20;
|
||||
/// Shown in place of an empty name field: what happens if the operator types
|
||||
/// nothing (#131).
|
||||
pub const NAME_HINT: &str = "named after your first prompt";
|
||||
|
||||
/// How many handles one `/api/names` fetch asks for. One is enough: the name
|
||||
/// field starts empty (#131) and the handle only seeds the worktree branch.
|
||||
pub const NAME_BATCH_SIZE: usize = 1;
|
||||
|
||||
/// Quiet period after raw-path typing before a `/api/gitroot` probe fires
|
||||
/// (#74). Every keystroke resets it, so a burst issues one request once the
|
||||
@@ -234,11 +236,10 @@ pub struct DraftPane {
|
||||
/// `selected_group_key` is `None`.
|
||||
pub worktree_choice: WorktreeChoice,
|
||||
pub name: crate::text_input::TextInput,
|
||||
pub name_queue: VecDeque<String>,
|
||||
/// Set once the operator types or rerolls a name; guards refills against
|
||||
/// Set once the operator types a name; a fetched handle then seeds only
|
||||
/// the branch, never the field. Guards a late fetch against
|
||||
/// clobbering it, exactly like the web form's `nameTouched`.
|
||||
pub name_touched: bool,
|
||||
needs_name_refill: bool,
|
||||
/// Worktree on for this spawn (#65). Defaults on; a failed gitroot probe
|
||||
/// unticks it, like the web form.
|
||||
pub worktree_enabled: bool,
|
||||
@@ -302,9 +303,7 @@ impl Default for DraftPane {
|
||||
selected_group_key: None,
|
||||
worktree_choice: WorktreeChoice::New,
|
||||
name: crate::text_input::TextInput::default(),
|
||||
name_queue: VecDeque::new(),
|
||||
name_touched: false,
|
||||
needs_name_refill: false,
|
||||
worktree_enabled: true,
|
||||
advanced_collapsed: true,
|
||||
base_repo: None,
|
||||
@@ -388,30 +387,23 @@ impl DraftPane {
|
||||
self.select_group(&group);
|
||||
}
|
||||
|
||||
/// Fill the local name batch from `GET /api/names`, seeding the field
|
||||
/// itself unless the operator already typed one.
|
||||
pub fn seed_names(&mut self, names: Vec<String>) {
|
||||
self.name_queue.extend(names);
|
||||
if !self.name_touched && self.name.value().trim().is_empty() {
|
||||
if let Some(first) = self.name_queue.pop_front() {
|
||||
self.set_name(first);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
/// Append a refill batch; the first name replaces the field (this only
|
||||
/// happens after an explicit reroll on an empty batch).
|
||||
/// Seed the worktree branch from a `GET /api/names` handle (#131).
|
||||
///
|
||||
/// The shown name is *consumed*, not left at the head — queueing it too
|
||||
/// made the next reroll produce the same name and the key look dead
|
||||
/// (#67 review).
|
||||
pub fn extend_names(&mut self, mut names: Vec<String>) {
|
||||
if names.is_empty() {
|
||||
/// The name field is deliberately left alone: a session the operator does
|
||||
/// not name is named by the daemon — a provisional handle at spawn,
|
||||
/// replaced by one derived from the first prompt. The branch still needs
|
||||
/// a default, and the name field no longer supplies one.
|
||||
pub fn seed_names(&mut self, names: Vec<String>) {
|
||||
let Some(handle) = names.into_iter().next() else {
|
||||
return;
|
||||
};
|
||||
if self.branch_edited
|
||||
|| self.branch_mode != WorktreeBranchMode::New
|
||||
|| !self.branch.value().trim().is_empty()
|
||||
{
|
||||
return;
|
||||
}
|
||||
let first = names.remove(0);
|
||||
self.set_name(first);
|
||||
self.name_queue.extend(names);
|
||||
self.branch = crate::text_input::TextInput::with_value(handle);
|
||||
}
|
||||
|
||||
pub fn set_name(&mut self, name: impl Into<String>) {
|
||||
@@ -421,27 +413,18 @@ impl DraftPane {
|
||||
|
||||
/// The new-branch field mirrors the session name until the operator types
|
||||
/// their own branch — and only in `New` mode, like the web form.
|
||||
///
|
||||
/// A cleared name leaves the branch on its last value (#131): the branch
|
||||
/// still has to be something, while the session name no longer does.
|
||||
fn sync_branch_to_name(&mut self) {
|
||||
if !self.branch_edited && self.branch_mode == WorktreeBranchMode::New {
|
||||
if !self.branch_edited
|
||||
&& self.branch_mode == WorktreeBranchMode::New
|
||||
&& !self.name.value().is_empty()
|
||||
{
|
||||
self.branch = crate::text_input::TextInput::with_value(self.name.value().to_string());
|
||||
}
|
||||
}
|
||||
|
||||
/// Reroll the generated name. Pulls from the local batch; when it has run
|
||||
/// dry, flags the caller to fetch a new one via [`Self::take_name_refill`].
|
||||
pub fn reroll(&mut self) {
|
||||
self.name_touched = true;
|
||||
match self.name_queue.pop_front() {
|
||||
Some(next) => self.set_name(next),
|
||||
None => self.needs_name_refill = true,
|
||||
}
|
||||
}
|
||||
|
||||
/// Consume the reroll-needs-a-new-batch flag raised by [`Self::reroll`].
|
||||
pub fn take_name_refill(&mut self) -> bool {
|
||||
std::mem::take(&mut self.needs_name_refill)
|
||||
}
|
||||
|
||||
// -- worktree (#65) -----------------------------------------------------
|
||||
|
||||
/// Whether the branch controls are shown: the toggle alone appears until
|
||||
@@ -1070,12 +1053,6 @@ impl DraftPane {
|
||||
self.move_branch_selection(1);
|
||||
DraftInputResult::Consumed
|
||||
}
|
||||
InputKey::Char {
|
||||
c: 'r', ctrl: true, ..
|
||||
} if self.focused_field == DraftField::Name => {
|
||||
self.reroll();
|
||||
DraftInputResult::Consumed
|
||||
}
|
||||
other => {
|
||||
match self.focused_field {
|
||||
DraftField::Preset | DraftField::Submit => {}
|
||||
@@ -1310,28 +1287,30 @@ impl DraftPane {
|
||||
}
|
||||
}
|
||||
|
||||
// -- name + reroll ---------------------------------------------------------
|
||||
// -- name -----------------------------------------------------------------
|
||||
let name_row = next_row();
|
||||
draw_gutter(f, name_row, "name:");
|
||||
let col = draw_text_field(f, &self.name, name_row, field_style(DraftField::Name));
|
||||
if self.focused_field == DraftField::Name {
|
||||
cursor = Some((col, name_row.y));
|
||||
}
|
||||
// Dim reroll hint, tucked after the typed name without covering it.
|
||||
let hint_offset = (GUTTER as u16 + self.name.value().chars().count() as u16 + 1)
|
||||
.min(name_row.width.saturating_sub(10));
|
||||
f.render_widget(
|
||||
Paragraph::new(Line::from(Span::styled(
|
||||
"^R reroll",
|
||||
Style::default().add_modifier(Modifier::DIM),
|
||||
))),
|
||||
Rect {
|
||||
x: name_row.x + hint_offset,
|
||||
y: name_row.y,
|
||||
width: name_row.width.saturating_sub(hint_offset),
|
||||
height: 1,
|
||||
},
|
||||
);
|
||||
// An empty field is not a missing value (#131): the daemon names the
|
||||
// session, so the row says so rather than looking unfinished.
|
||||
if self.name.value().is_empty() {
|
||||
let hint_offset = (GUTTER as u16 + 1).min(name_row.width.saturating_sub(10));
|
||||
f.render_widget(
|
||||
Paragraph::new(Line::from(Span::styled(
|
||||
NAME_HINT,
|
||||
Style::default().add_modifier(Modifier::DIM),
|
||||
))),
|
||||
Rect {
|
||||
x: name_row.x + hint_offset,
|
||||
y: name_row.y,
|
||||
width: name_row.width.saturating_sub(hint_offset),
|
||||
height: 1,
|
||||
},
|
||||
);
|
||||
}
|
||||
|
||||
// -- advanced disclosure (#93) ------------------------------------------
|
||||
let advanced_row = next_row();
|
||||
@@ -2051,15 +2030,37 @@ mod tests {
|
||||
assert_eq!(draft.cwd_raw.value(), "/repos/picked");
|
||||
}
|
||||
|
||||
/// #131: the field stays empty and the request carries no name — the
|
||||
/// daemon names the session. The fetched handle only seeds the branch.
|
||||
#[test]
|
||||
fn generated_names_seed_the_field_and_metadata() {
|
||||
fn a_fetched_handle_seeds_the_branch_and_leaves_the_name_empty() {
|
||||
let mut draft = DraftPane::default();
|
||||
assert!(draft.name.value().is_empty());
|
||||
|
||||
draft.seed_names(vec!["crimson-otter".into()]);
|
||||
assert!(
|
||||
draft.name.value().is_empty(),
|
||||
"no name until /api/names lands"
|
||||
"the name field is the operator's"
|
||||
);
|
||||
draft.seed_names(vec!["crimson-otter".into(), "amber-falcon".into()]);
|
||||
assert_eq!(draft.name.value(), "crimson-otter");
|
||||
assert_eq!(draft.branch.value(), "crimson-otter");
|
||||
|
||||
draft.picked_cwd = Some(PathBuf::from("/w"));
|
||||
draft.base_repo = Some(PathBuf::from("/w"));
|
||||
draft.probed_cwd = Some(PathBuf::from("/w"));
|
||||
let req = draft.build_request().unwrap();
|
||||
assert!(
|
||||
!req.metadata.contains_key("name"),
|
||||
"an unnamed spawn sends no name"
|
||||
);
|
||||
}
|
||||
|
||||
/// A name the operator types still rides along, and still seeds the
|
||||
/// branch (#131).
|
||||
#[test]
|
||||
fn a_typed_name_rides_along_and_seeds_the_branch() {
|
||||
let mut draft = DraftPane::default();
|
||||
typed_name(&mut draft, "my-session");
|
||||
assert_eq!(draft.branch.value(), "my-session");
|
||||
|
||||
draft.picked_cwd = Some(PathBuf::from("/w"));
|
||||
draft.base_repo = Some(PathBuf::from("/w"));
|
||||
@@ -2067,36 +2068,19 @@ mod tests {
|
||||
let req = draft.build_request().unwrap();
|
||||
assert_eq!(
|
||||
req.metadata.get("name").and_then(|v| v.as_str()),
|
||||
Some("crimson-otter"),
|
||||
"name rides along as metadata.name"
|
||||
Some("my-session")
|
||||
);
|
||||
|
||||
draft.reroll();
|
||||
assert_eq!(
|
||||
draft.name.value(),
|
||||
"amber-falcon",
|
||||
"reroll consumes the batch"
|
||||
);
|
||||
draft.reroll();
|
||||
assert!(
|
||||
draft.take_name_refill(),
|
||||
"dry batch flags the caller to refetch"
|
||||
);
|
||||
assert!(!draft.take_name_refill(), "flag consumes");
|
||||
}
|
||||
|
||||
/// A handle arriving after the operator typed a name never overwrites it,
|
||||
/// nor the branch it seeded (#131).
|
||||
#[test]
|
||||
fn refills_do_not_clobber_a_name_the_operator_typed() {
|
||||
fn a_late_handle_never_clobbers_what_was_typed() {
|
||||
let mut draft = DraftPane::default();
|
||||
draft.seed_names(vec!["seeded".into()]);
|
||||
typed_name(&mut draft, "-mine");
|
||||
assert_eq!(draft.name.value(), "seeded-mine");
|
||||
draft.seed_names(vec!["late-batch".into()]);
|
||||
assert_eq!(
|
||||
draft.name.value(),
|
||||
"seeded-mine",
|
||||
"late initial batches never overwrite an edited name"
|
||||
);
|
||||
typed_name(&mut draft, "mine");
|
||||
draft.seed_names(vec!["late-handle".into()]);
|
||||
assert_eq!(draft.name.value(), "mine");
|
||||
assert_eq!(draft.branch.value(), "mine");
|
||||
}
|
||||
|
||||
fn typed_name(draft: &mut DraftPane, s: &str) {
|
||||
@@ -2147,7 +2131,7 @@ mod tests {
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn render_shows_every_field_group_and_the_reroll_hint() {
|
||||
fn render_shows_every_field_group_and_the_naming_hint() {
|
||||
let mut draft = DraftPane {
|
||||
home_dir: "/home/u".into(),
|
||||
..DraftPane::default()
|
||||
@@ -2165,7 +2149,7 @@ mod tests {
|
||||
"[Custom…]",
|
||||
"dir:",
|
||||
"name:",
|
||||
"^R reroll",
|
||||
NAME_HINT,
|
||||
"maestro",
|
||||
"[ Spawn ]",
|
||||
] {
|
||||
@@ -2453,18 +2437,24 @@ mod tests {
|
||||
#[test]
|
||||
fn the_new_branch_tracks_the_session_name_until_touched() {
|
||||
let mut draft = DraftPane::default();
|
||||
draft.seed_names(vec!["crimson-otter".into(), "amber-falcon".into()]);
|
||||
draft.seed_names(vec!["crimson-otter".into()]);
|
||||
assert_eq!(draft.branch.value(), "crimson-otter");
|
||||
draft.reroll();
|
||||
assert_eq!(draft.branch.value(), "amber-falcon", "rerolls carry over");
|
||||
|
||||
draft.focused_field = DraftField::Name;
|
||||
typed(&mut draft, "renamed");
|
||||
assert_eq!(
|
||||
draft.branch.value(),
|
||||
"renamed",
|
||||
"the branch tracks the name"
|
||||
);
|
||||
|
||||
draft.focused_field = DraftField::BranchNew;
|
||||
typed(&mut draft, "-mine");
|
||||
assert_eq!(draft.branch.value(), "amber-falcon-mine");
|
||||
draft.seed_names(vec!["late-batch".into()]);
|
||||
assert_eq!(draft.branch.value(), "renamed-mine");
|
||||
draft.seed_names(vec!["late-handle".into()]);
|
||||
assert_eq!(
|
||||
draft.branch.value(),
|
||||
"amber-falcon-mine",
|
||||
"renamed-mine",
|
||||
"an edited branch stops tracking the name"
|
||||
);
|
||||
}
|
||||
|
||||
@@ -2,11 +2,13 @@
|
||||
//!
|
||||
//! The defaults mirror what the spawn form would settle on after the operator
|
||||
//! picked the most recent project and kept their hands off everything else:
|
||||
//! its last command (or the first non-custom preset), a freshly generated
|
||||
//! name, and a worktree with a branch named after that name. Any default
|
||||
//! that cannot be resolved — no projects yet, no command, no generated
|
||||
//! name — downgrades the keystroke to the spawn form pre-filled with whatever
|
||||
//! did resolve ([`FastForwardDefaults::apply_to_draft`]).
|
||||
//! its last command (or the first non-custom preset), and a worktree on a new
|
||||
//! branch named after a generated handle. The session itself is left unnamed
|
||||
//! (#131) — the daemon gives it a provisional handle at spawn and names it
|
||||
//! after its first prompt. Any default that cannot be resolved — no projects
|
||||
//! yet, no command, no handle — downgrades the keystroke to the spawn form
|
||||
//! pre-filled with whatever did resolve
|
||||
//! ([`FastForwardDefaults::apply_to_draft`]).
|
||||
|
||||
use std::path::PathBuf;
|
||||
|
||||
@@ -21,16 +23,18 @@ use crate::draft::DraftPane;
|
||||
pub struct FastForwardDefaults {
|
||||
pub project: Option<Project>,
|
||||
pub command: Option<String>,
|
||||
pub name: Option<String>,
|
||||
/// A generated handle for the worktree branch (#131). Not a session name:
|
||||
/// the fast path names no session.
|
||||
pub handle: Option<String>,
|
||||
}
|
||||
|
||||
/// Resolve the fast-forward defaults from the daemon's answers. `name` is
|
||||
/// Resolve the fast-forward defaults from the daemon's answers. `handle` is
|
||||
/// `None` when `/api/names` yielded nothing; `presets` may be empty (the
|
||||
/// caller falls back to the built-ins it already has).
|
||||
pub fn resolve(
|
||||
projects: &[Project],
|
||||
presets: &[SpawnPreset],
|
||||
name: Option<String>,
|
||||
handle: Option<String>,
|
||||
now: DateTime<Utc>,
|
||||
) -> FastForwardDefaults {
|
||||
let project = crate::projects::sort_projects(projects.to_vec(), now)
|
||||
@@ -49,37 +53,35 @@ pub fn resolve(
|
||||
FastForwardDefaults {
|
||||
project,
|
||||
command,
|
||||
name,
|
||||
handle,
|
||||
}
|
||||
}
|
||||
|
||||
impl FastForwardDefaults {
|
||||
/// The spawn request when *every* default resolved: worktree on, new
|
||||
/// branch named after the generated session name, base repo from the
|
||||
/// scan (`None` means the project is itself a main checkout).
|
||||
/// The spawn request when *every* default resolved: worktree on, a new
|
||||
/// branch named after the generated handle, base repo from the scan
|
||||
/// (`None` means the project is itself a main checkout).
|
||||
///
|
||||
/// The request carries no name (#131): the daemon assigns a provisional
|
||||
/// one and replaces it once the session sees a prompt.
|
||||
pub fn build_request(&self) -> Option<CreateSessionRequest> {
|
||||
let project = self.project.as_ref()?;
|
||||
let command = self.command.as_deref()?.trim();
|
||||
let name = self.name.as_deref()?;
|
||||
if command.is_empty() || name.is_empty() {
|
||||
let handle = self.handle.as_deref()?;
|
||||
if command.is_empty() || handle.is_empty() {
|
||||
return None;
|
||||
}
|
||||
let mut metadata = std::collections::HashMap::new();
|
||||
metadata.insert(
|
||||
"name".to_string(),
|
||||
serde_json::Value::String(name.to_string()),
|
||||
);
|
||||
Some(CreateSessionRequest {
|
||||
cwd: project.path.clone(),
|
||||
command: command.to_string(),
|
||||
env: Default::default(),
|
||||
metadata,
|
||||
metadata: Default::default(),
|
||||
worktree: Some(WorktreeSpec {
|
||||
base_repo: project
|
||||
.base_repo
|
||||
.clone()
|
||||
.unwrap_or_else(|| project.path.clone()),
|
||||
branch: name.to_string(),
|
||||
branch: handle.to_string(),
|
||||
create_branch: true,
|
||||
}),
|
||||
})
|
||||
@@ -109,10 +111,10 @@ impl FastForwardDefaults {
|
||||
draft.custom_command = crate::text_input::TextInput::with_value(command);
|
||||
}
|
||||
}
|
||||
if let Some(name) = &self.name {
|
||||
draft.set_name(name.clone());
|
||||
// Seeded, not generated: a later refill must not clobber it.
|
||||
draft.name_touched = true;
|
||||
if let Some(handle) = &self.handle {
|
||||
// The branch, not the name: the form's name field stays empty so
|
||||
// the session is named after its first prompt (#131).
|
||||
draft.seed_names(vec![handle.clone()]);
|
||||
}
|
||||
}
|
||||
}
|
||||
@@ -161,19 +163,17 @@ mod tests {
|
||||
PathBuf::from("/repos/fresh")
|
||||
);
|
||||
assert_eq!(r.command.as_deref(), Some("claude"));
|
||||
assert_eq!(r.name.as_deref(), Some("amber-falcon"));
|
||||
assert_eq!(r.handle.as_deref(), Some("amber-falcon"));
|
||||
|
||||
let req = r.build_request().expect("all defaults resolved");
|
||||
assert_eq!(req.cwd, PathBuf::from("/repos/fresh"));
|
||||
assert_eq!(req.command, "claude");
|
||||
assert_eq!(
|
||||
req.metadata.get("name").and_then(|v| v.as_str()),
|
||||
Some("amber-falcon")
|
||||
);
|
||||
// #131: the fast path names no session — the daemon does.
|
||||
assert!(req.metadata.is_empty());
|
||||
let wt = req.worktree.expect("worktree on");
|
||||
assert_eq!(wt.base_repo, PathBuf::from("/repos/fresh"));
|
||||
assert_eq!(wt.branch, "amber-falcon");
|
||||
assert!(wt.create_branch, "fresh branch named after the session");
|
||||
assert!(wt.create_branch, "fresh branch named after the handle");
|
||||
}
|
||||
|
||||
#[test]
|
||||
@@ -243,31 +243,36 @@ mod tests {
|
||||
assert!(draft.worktree_enabled);
|
||||
}
|
||||
|
||||
/// The handle seeds the branch, never the name: a downgraded fast-forward
|
||||
/// opens a form the operator can still leave unnamed (#131).
|
||||
#[test]
|
||||
fn a_resolved_name_survives_late_refills_and_tracks_the_branch() {
|
||||
fn a_resolved_handle_seeds_the_branch_only() {
|
||||
let projects = vec![project("/repos/p", 0, Some("claude"))];
|
||||
let named = resolve(
|
||||
let resolved = resolve(
|
||||
&projects,
|
||||
&[preset("claude", "claude")],
|
||||
Some("amber-falcon".into()),
|
||||
Utc::now(),
|
||||
);
|
||||
let mut draft = DraftPane::default();
|
||||
named.apply_to_draft(&mut draft);
|
||||
// A later batch must not overwrite the name the spawn was seeded with.
|
||||
draft.seed_names(vec!["late-name".into()]);
|
||||
assert_eq!(draft.name.value(), "amber-falcon");
|
||||
resolved.apply_to_draft(&mut draft);
|
||||
assert!(draft.name.value().is_empty());
|
||||
assert_eq!(draft.branch.value(), "amber-falcon");
|
||||
|
||||
// A later handle finds the branch already seeded and leaves it.
|
||||
draft.seed_names(vec!["late-handle".into()]);
|
||||
assert_eq!(draft.branch.value(), "amber-falcon");
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn an_unresolved_name_still_gets_generated_by_a_later_batch() {
|
||||
fn an_unresolved_handle_still_arrives_from_a_later_batch() {
|
||||
let projects = vec![project("/repos/p", 0, Some("claude"))];
|
||||
let r = resolve(&projects, &[preset("claude", "claude")], None, Utc::now());
|
||||
let mut draft = DraftPane::default();
|
||||
r.apply_to_draft(&mut draft);
|
||||
draft.seed_names(vec!["late-name".into()]);
|
||||
assert_eq!(draft.name.value(), "late-name");
|
||||
draft.seed_names(vec!["late-handle".into()]);
|
||||
assert_eq!(draft.branch.value(), "late-handle");
|
||||
assert!(draft.name.value().is_empty());
|
||||
}
|
||||
|
||||
#[test]
|
||||
|
||||
@@ -251,10 +251,23 @@ impl Sidebar {
|
||||
),
|
||||
Span::styled(format!("{glyph} "), base),
|
||||
];
|
||||
// #131: a name the daemon generated is provisional — the session's
|
||||
// first prompt may replace it — so it reads muted, like the meta line,
|
||||
// rather than as a name someone chose. See docs/SIDEBAR.md.
|
||||
let name_style = if maestro_protocol::display::is_provisional_name(s) {
|
||||
base.patch(
|
||||
palette::active()
|
||||
.surface(highlighted && focused)
|
||||
.muted_style()
|
||||
.bg(base.bg.unwrap_or(palette::active().chrome_bg)),
|
||||
)
|
||||
} else {
|
||||
base
|
||||
};
|
||||
spans.extend(
|
||||
fit_to_width(vec![Span::raw(name_for(s))], name_budget)
|
||||
.into_iter()
|
||||
.map(|sp| Span::styled(sp.content, base.patch(sp.style))),
|
||||
.map(|sp| Span::styled(sp.content, name_style.patch(sp.style))),
|
||||
);
|
||||
pad_to_width(spans, width, base)
|
||||
}
|
||||
@@ -696,6 +709,39 @@ mod tests {
|
||||
}
|
||||
}
|
||||
|
||||
/// #131: a generated handle renders muted, a settled name in the card's
|
||||
/// own foreground — the same distinction the web sidebar draws.
|
||||
#[test]
|
||||
fn a_generated_name_renders_muted_until_it_settles() {
|
||||
let mut generated = session_named(1, "amber");
|
||||
generated.metadata.insert(
|
||||
maestro_protocol::NAME_SOURCE_KEY.into(),
|
||||
serde_json::Value::String("Generated".into()),
|
||||
);
|
||||
let mut settled = session_named(2, "falcon");
|
||||
settled.metadata.insert(
|
||||
maestro_protocol::NAME_SOURCE_KEY.into(),
|
||||
serde_json::Value::String("Haiku".into()),
|
||||
);
|
||||
let sb = Sidebar {
|
||||
sessions: vec![generated, settled],
|
||||
highlight: None,
|
||||
attached: Default::default(),
|
||||
};
|
||||
let buf = draw(&sb, 44, 8);
|
||||
let palette = palette::active();
|
||||
let surface = palette.surface(false);
|
||||
let colour_of = |needle: char| {
|
||||
(0..buf.area.height)
|
||||
.flat_map(|y| (0..buf.area.width).map(move |x| (x, y)))
|
||||
.find(|&(x, y)| buf[(x, y)].symbol() == needle.to_string())
|
||||
.map(|(x, y)| buf[(x, y)].fg)
|
||||
.expect("name must be drawn")
|
||||
};
|
||||
assert_eq!(colour_of('a'), surface.muted, "the generated handle");
|
||||
assert_ne!(colour_of('f'), surface.muted, "the settled name");
|
||||
}
|
||||
|
||||
/// The additions and deletions are the only coloured fragments: they are
|
||||
/// what a reader scans for, and colouring the rest would make the line
|
||||
/// compete with the activity rail.
|
||||
|
||||
Reference in New Issue
Block a user