mirror of
https://github.com/openai/codex.git
synced 2026-11-20 22:40:37 +00:00
## What changed - Group consecutive successful agent and unified-exec startup commands into a compact `Ran N commands` entry while preserving their full transcript. - Flush command groups at interaction boundaries, after failures, and after 32 completed commands. Keep manual shell commands and failed or declined commands visible. - Apply the same grouping rules when replaying thread history without duplicating command starts or disturbing unrelated active commands. ## Testing - Add TUI coverage for live and replayed grouping, transcript preservation, failures, overlapping commands, group limits, and interaction boundaries. GitOrigin-RevId: d6602a20201644012fcff3d6cecf4690024383a9
281 lines
9.2 KiB
Rust
281 lines
9.2 KiB
Rust
//! Data model for grouped exec-call history cells in the TUI transcript.
|
|
//!
|
|
//! An `ExecCell` can represent either a single command or an "exploring" group of related read/
|
|
//! list/search commands. The chat widget relies on stable `call_id` matching to route progress and
|
|
//! end events into the right cell, and it treats "call id not found" as a real signal (for
|
|
//! example, an orphan end that should render as a separate history entry).
|
|
|
|
use std::borrow::Cow;
|
|
use std::time::Duration;
|
|
use std::time::Instant;
|
|
|
|
use super::live_output::LiveCommandOutput;
|
|
use codex_app_server_protocol::CommandExecutionSource as ExecCommandSource;
|
|
use codex_protocol::parse_command::ParsedCommand;
|
|
use itertools::Either;
|
|
|
|
const MAX_GROUPED_COMMANDS: usize = 32;
|
|
|
|
#[derive(Debug, Default)]
|
|
pub(crate) struct CommandOutput {
|
|
pub(crate) exit_code: i32,
|
|
/// The finalized, interleaved stderr and stdout that replaces any streamed preview.
|
|
aggregated_output: String,
|
|
/// The live preview while command-output deltas are still arriving.
|
|
live_output: Option<LiveCommandOutput>,
|
|
}
|
|
|
|
impl CommandOutput {
|
|
pub(crate) fn new(exit_code: i32, aggregated_output: String) -> Self {
|
|
Self {
|
|
exit_code,
|
|
aggregated_output,
|
|
live_output: None,
|
|
}
|
|
}
|
|
|
|
/// Returns the total number of logical lines and the number retained for rendering.
|
|
pub(super) fn line_counts(&self) -> (usize, usize) {
|
|
match self.live_output.as_ref() {
|
|
Some(output) => (output.total_lines(), output.retained_lines()),
|
|
None => {
|
|
let total = self.aggregated_output.lines().count();
|
|
(total, total)
|
|
}
|
|
}
|
|
}
|
|
|
|
/// Returns retained preview lines with reverse traversal for efficient tail rendering.
|
|
pub(super) fn lines(&self) -> impl DoubleEndedIterator<Item = Cow<'_, str>> {
|
|
match self.live_output.as_ref() {
|
|
Some(output) => Either::Left(output.lines()),
|
|
None => Either::Right(self.aggregated_output.lines().map(Cow::Borrowed)),
|
|
}
|
|
}
|
|
|
|
/// Returns lines for the expanded transcript, including any storage-level omission marker.
|
|
pub(super) fn transcript_lines(&self) -> impl Iterator<Item = Cow<'_, str>> {
|
|
match self.live_output.as_ref() {
|
|
Some(output) => Either::Left(output.transcript_lines()),
|
|
None => Either::Right(self.aggregated_output.lines().map(Cow::Borrowed)),
|
|
}
|
|
}
|
|
}
|
|
|
|
#[derive(Debug)]
|
|
pub(crate) struct ExecCall {
|
|
pub(crate) call_id: String,
|
|
pub(crate) command: Vec<String>,
|
|
pub(crate) parsed: Vec<ParsedCommand>,
|
|
pub(crate) output: Option<CommandOutput>,
|
|
pub(crate) source: ExecCommandSource,
|
|
pub(crate) start_time: Option<Instant>,
|
|
pub(crate) duration: Option<Duration>,
|
|
pub(crate) interaction_input: Option<String>,
|
|
}
|
|
|
|
#[derive(Debug)]
|
|
pub(crate) struct ExecCell {
|
|
pub(crate) calls: Vec<ExecCall>,
|
|
animations_enabled: bool,
|
|
}
|
|
|
|
impl ExecCell {
|
|
pub(crate) fn new(call: ExecCall, animations_enabled: bool) -> Self {
|
|
Self {
|
|
calls: vec![call],
|
|
animations_enabled,
|
|
}
|
|
}
|
|
|
|
pub(crate) fn add_call(
|
|
&mut self,
|
|
call_id: String,
|
|
command: Vec<String>,
|
|
parsed: Vec<ParsedCommand>,
|
|
source: ExecCommandSource,
|
|
interaction_input: Option<String>,
|
|
) -> bool {
|
|
let call = ExecCall {
|
|
call_id,
|
|
command,
|
|
parsed,
|
|
output: None,
|
|
source,
|
|
start_time: Some(Instant::now()),
|
|
duration: None,
|
|
interaction_input,
|
|
};
|
|
let has_failed_call = self.calls.iter().any(|existing| {
|
|
existing
|
|
.output
|
|
.as_ref()
|
|
.is_some_and(|output| output.exit_code != 0)
|
|
});
|
|
if (self.calls.len() >= MAX_GROUPED_COMMANDS && !self.is_active())
|
|
|| (!Self::is_groupable_source(call.source) && !self.is_active())
|
|
|| (has_failed_call && !self.is_active())
|
|
{
|
|
return false;
|
|
}
|
|
|
|
let continues_exploration = Self::is_exploring_call(&call)
|
|
&& (self.is_exploring_cell()
|
|
|| self.calls.last().is_some_and(|existing| {
|
|
existing.duration.is_none() && Self::is_exploring_call(existing)
|
|
}))
|
|
&& (self.is_active()
|
|
|| self
|
|
.calls
|
|
.iter()
|
|
.all(|existing| Self::is_groupable_source(existing.source)));
|
|
let continues_compact_group = self.calls.iter().all(|existing| {
|
|
Self::is_groupable_source(existing.source)
|
|
&& existing.duration.is_some()
|
|
&& existing
|
|
.output
|
|
.as_ref()
|
|
.is_some_and(|output| output.exit_code == 0)
|
|
});
|
|
if continues_exploration || continues_compact_group {
|
|
self.calls.push(call);
|
|
true
|
|
} else {
|
|
false
|
|
}
|
|
}
|
|
|
|
/// Marks the most recently matching call as finished and returns whether a call was found.
|
|
///
|
|
/// Callers should treat `false` as a routing mismatch rather than silently ignoring it. The
|
|
/// chat widget uses that signal to avoid attaching an orphan `exec_end` event to an unrelated
|
|
/// active exploring cell, which would incorrectly collapse two transcript entries together.
|
|
pub(crate) fn complete_call(
|
|
&mut self,
|
|
call_id: &str,
|
|
output: CommandOutput,
|
|
duration: Duration,
|
|
) -> bool {
|
|
let Some(call) = self.calls.iter_mut().rev().find(|c| c.call_id == call_id) else {
|
|
return false;
|
|
};
|
|
call.output = Some(output);
|
|
call.duration = Some(duration);
|
|
call.start_time = None;
|
|
true
|
|
}
|
|
|
|
pub(crate) fn should_flush(&self) -> bool {
|
|
if self.calls.iter().any(|call| {
|
|
!Self::is_groupable_source(call.source)
|
|
|| call
|
|
.output
|
|
.as_ref()
|
|
.is_some_and(|output| output.exit_code != 0)
|
|
}) {
|
|
return !self.is_active();
|
|
}
|
|
|
|
if self.calls.len() >= MAX_GROUPED_COMMANDS {
|
|
return !self.is_active();
|
|
}
|
|
|
|
if self.calls.iter().all(|call| {
|
|
Self::is_groupable_source(call.source)
|
|
&& call.duration.is_some()
|
|
&& call
|
|
.output
|
|
.as_ref()
|
|
.is_some_and(|output| output.exit_code == 0)
|
|
}) {
|
|
return false;
|
|
}
|
|
|
|
!self.is_exploring_cell() && self.calls.iter().all(|c| c.duration.is_some())
|
|
}
|
|
|
|
pub(crate) fn mark_failed(&mut self) {
|
|
for call in self.calls.iter_mut() {
|
|
if call.duration.is_none() {
|
|
let elapsed = call
|
|
.start_time
|
|
.map(|st| st.elapsed())
|
|
.unwrap_or_else(|| Duration::from_millis(0));
|
|
call.start_time = None;
|
|
call.duration = Some(elapsed);
|
|
call.output
|
|
.get_or_insert_with(CommandOutput::default)
|
|
.exit_code = 1;
|
|
}
|
|
}
|
|
}
|
|
|
|
pub(crate) fn is_exploring_cell(&self) -> bool {
|
|
self.calls.iter().all(Self::is_exploring_call)
|
|
}
|
|
|
|
pub(crate) fn is_active(&self) -> bool {
|
|
self.calls.iter().any(|c| c.duration.is_none())
|
|
}
|
|
|
|
pub(crate) fn active_start_time(&self) -> Option<Instant> {
|
|
self.calls
|
|
.iter()
|
|
.find(|c| c.duration.is_none())
|
|
.and_then(|c| c.start_time)
|
|
}
|
|
|
|
pub(crate) fn animations_enabled(&self) -> bool {
|
|
self.animations_enabled
|
|
}
|
|
|
|
pub(crate) fn iter_calls(&self) -> impl Iterator<Item = &ExecCall> {
|
|
self.calls.iter()
|
|
}
|
|
|
|
pub(crate) fn append_output(&mut self, call_id: &str, chunk: &str) -> bool {
|
|
if chunk.is_empty() {
|
|
return false;
|
|
}
|
|
let Some(call) = self.calls.iter_mut().rev().find(|c| c.call_id == call_id) else {
|
|
return false;
|
|
};
|
|
let output = call.output.get_or_insert_with(CommandOutput::default);
|
|
output
|
|
.live_output
|
|
.get_or_insert_with(LiveCommandOutput::default)
|
|
.push_str(chunk);
|
|
true
|
|
}
|
|
|
|
pub(super) fn is_exploring_call(call: &ExecCall) -> bool {
|
|
!matches!(call.source, ExecCommandSource::UserShell)
|
|
&& !call.parsed.is_empty()
|
|
&& call.parsed.iter().all(|p| {
|
|
matches!(
|
|
p,
|
|
ParsedCommand::Read { .. }
|
|
| ParsedCommand::ListFiles { .. }
|
|
| ParsedCommand::Search { .. }
|
|
)
|
|
})
|
|
}
|
|
|
|
fn is_groupable_source(source: ExecCommandSource) -> bool {
|
|
matches!(
|
|
source,
|
|
ExecCommandSource::Agent | ExecCommandSource::UnifiedExecStartup
|
|
)
|
|
}
|
|
}
|
|
|
|
impl ExecCall {
|
|
pub(crate) fn is_user_shell_command(&self) -> bool {
|
|
matches!(self.source, ExecCommandSource::UserShell)
|
|
}
|
|
|
|
pub(crate) fn is_unified_exec_interaction(&self) -> bool {
|
|
matches!(self.source, ExecCommandSource::UnifiedExecInteraction)
|
|
}
|
|
}
|