Files
luxe/crates/luxe-tui/src/app/plan_handoff.rs
Evan Whittaker 09a7de2520 Initial public release
Luxe 0.1.0: a coding agent harness for the terminal. See README.md to get started and CHANGELOG.md for releases.
2026-10-17 12:08:30 -05:00

162 lines
6.9 KiB
Rust

//! Plan handoff — what happens to a plan once plan mode has written it.
//!
//! When a turn in plan mode ends having written a plan file, the TUI asks what next, in the same
//! picker the agent's own questions use. The choice is the reader's and is acted on here rather than
//! sent to the agent: leaving plan mode is not something the model may do for itself, or plan mode
//! would hold only as long as the model agreed to stay in it.
use super::{App, ConvoBlock};
use luxe_core::engine::Action;
use luxe_core::question::{QuestionOption, QuestionRequestId};
const BUILD_HERE: &str = "Build it here";
const BUILD_FRESH: &str = "Build it in a fresh session";
const RUN_AS_LOOP: &str = "Run it as a loop";
const KEEP_PLANNING: &str = "Keep planning";
/// Asks what to do with the plan at `path`, unless something else is already being asked.
pub(super) fn offer(app: &mut App, path: String) {
if app.overlays.question.is_some() || app.overlays.permission.is_some() {
return;
}
let id = QuestionRequestId::new();
app.overlays.question = Some(crate::question_prompt::QuestionPromptState::new(
id.clone(),
format!("{path} is ready. What next?"),
vec![
QuestionOption::new(BUILD_HERE)
.with_description("this session, with the planning conversation in context")
.recommended(),
QuestionOption::new(BUILD_FRESH).with_description(format!(
"starts from {path} alone, which is cheaper after a long plan"
)),
QuestionOption::new(RUN_AS_LOOP)
.with_description("phase by phase, with your checks and a review at each"),
QuestionOption::new(KEEP_PLANNING),
],
false,
));
app.plan_handoff = Some(id);
app.plan_written = Some(path);
}
/// Whether `id` is the handoff's question, which the TUI answers rather than the engine.
pub(super) fn is_handoff(app: &App, id: &QuestionRequestId) -> bool {
app.plan_handoff.as_ref() == Some(id)
}
/// Acts on the reader's answer to the handoff: a choice, free text, or nothing (dismissed).
pub(super) fn answered(app: &mut App, answers: Option<Vec<String>>) {
app.plan_handoff = None;
let path = app.plan_written.take().unwrap_or_else(|| luxe_core::mode::DEFAULT_PLAN_FILE.into());
let Some(answer) = answers.and_then(|answers| answers.into_iter().next()) else {
return;
};
let build = format!("Build the plan in `{path}`, phase by phase, starting with phase 0.");
match answer.as_str() {
KEEP_PLANNING => {}
BUILD_HERE => {
set_build(app);
submit(app, &build);
}
BUILD_FRESH => {
set_build(app);
// Sent once the new session has loaded, or it would land in the one being left; parked
// only once there is a new session coming to send it to
if app.send_action(Action::NewSession, "start a new session") {
app.pending_build = Some(build);
}
}
RUN_AS_LOOP => {
set_build(app);
app.push_convo(ConvoBlock::System(format!(
"Run `luxe loop start` in this project to build {path} phase by phase. `luxe loop \
status` shows how it is going, and `gate` in your config sets what each phase \
has to pass."
)));
}
// Typed rather than picked: what to build, said in the reader's own words
typed => {
set_build(app);
submit(app, typed);
}
}
}
/// Sends what was waiting for a fresh session, now that one has loaded.
pub(super) fn session_loaded(app: &mut App) {
// a plan another session wrote is not this session's to offer
app.plan_written = None;
if let Some(build) = app.pending_build.take() {
submit(app, &build);
}
// A prompt typed on the start screen, which asked for this session to answer it
if std::mem::take(&mut app.send_draft_on_load) {
super::input::submit_prompt(app);
}
}
fn set_build(app: &mut App) {
app.send_action(Action::SetMode(luxe_core::mode::BUILD.into()), "change the mode");
}
/// Sends `text` through the composer's own path, so it shows and steers as anything typed does,
/// and leaves whatever the reader had drafted where it was.
fn submit(app: &mut App, text: &str) {
let draft = app.editor.current_input().to_string();
app.editor.cancel();
app.editor.insert_text(text);
super::input::submit_prompt(app);
if !draft.is_empty() {
app.editor.insert_text(&draft);
}
}
#[cfg(test)]
mod tests {
use super::*;
use crate::fixture::{seeded_app, seeded_session, FixtureScenario};
use luxe_core::event::Event;
/// A plan written in a turn that then failed is still offered once a turn finishes, in the
/// same session; a session that loads instead does not inherit it.
#[test]
fn a_written_plan_outlives_a_failed_turn_but_not_its_session() {
let (mut app, _engine) = seeded_session("nord", FixtureScenario::ChatIdle).unwrap();
app.update(crate::app::Msg::Engine(Event::PlanWritten { path: "PLAN.md".into() }));
app.update(crate::app::Msg::Engine(Event::Error("the provider went away".into())));
assert_eq!(app.plan_written.as_deref(), Some("PLAN.md"), "kept for the next turn's end");
session_loaded(&mut app);
assert_eq!(app.plan_written, None, "another session's plan is not offered here");
}
/// Building fresh parks the build prompt only once a new session is on its way, or it would be
/// sent into whatever session loads next.
#[test]
fn building_fresh_parks_nothing_when_no_session_is_coming() {
let mut app = seeded_app("nord", FixtureScenario::ChatIdle).unwrap();
answered(&mut app, Some(vec![BUILD_FRESH.to_string()]));
assert_eq!(app.pending_build, None);
}
/// Building fresh asks for a new session and sends the build prompt once that session loads.
#[test]
fn building_fresh_sends_the_prompt_into_the_new_session() {
let (mut app, mut engine) = seeded_session("nord", FixtureScenario::ChatIdle).unwrap();
answered(&mut app, Some(vec![BUILD_FRESH.to_string()]));
let asked: Vec<Action> = std::iter::from_fn(|| engine.try_recv().ok()).collect();
assert!(asked.iter().any(|action| matches!(action, Action::NewSession)), "{asked:?}");
assert!(app.pending_build.is_some());
let loaded = Event::SessionLoaded { session_id: "fresh".into(), messages: Vec::new() };
app.update(crate::app::Msg::Engine(loaded));
assert!(app.pending_build.is_none(), "sent into the session that loaded");
let sent: Vec<Action> = std::iter::from_fn(|| engine.try_recv().ok()).collect();
let submitted = sent.iter().any(|action| {
matches!(action, Action::SubmitUserMessage { content, .. } if content.contains("Build the plan"))
});
assert!(submitted, "{sent:?}");
}
}