Publish harness and TUI open-source

initial sync from the monorepo

crates/codegen/xai-grok-pager/src/slash/commands/expand.rs

@@ -0,0 +1,113 @@
+//! `/expand` -- re-print the last collapsed block, fully expanded (minimal mode).
+//!
+//! In the scrollback-native minimal mode (`grok --minimal`) finalized blocks are
+//! printed once into the terminal's native scrollback, with reasoning collapsed
+//! and large tool output truncated (design decision K9). Committed terminal text
+//! can't be mutated, so "expanding" one is an honest re-print of the same block
+//! in full below the conversation (K10). `/expand` is the slash-command twin of
+//! the `Ctrl+E` chord; both walk backwards through the most-recently committed
+//! folded blocks.
+
+use crate::app::actions::Action;
+use crate::slash::command::{CommandExecCtx, CommandResult, SlashCommand};
+
+/// Re-print the last collapsed/truncated block, fully expanded (minimal mode).
+pub struct ExpandCommand;
+
+impl SlashCommand for ExpandCommand {
+    fn name(&self) -> &str {
+        "expand"
+    }
+
+    fn description(&self) -> &str {
+        "Re-print the last collapsed block, fully expanded (minimal mode)"
+    }
+
+    fn session_scoped(&self) -> bool {
+        true
+    }
+
+    fn usage(&self) -> &str {
+        "/expand"
+    }
+
+    fn run(&self, ctx: &mut CommandExecCtx, _args: &str) -> CommandResult {
+        // Expansion is meaningful only in minimal mode — the full-TUI scrollback
+        // pane folds/unfolds blocks in place (the `e` / `Ctrl+E` chords) and has
+        // no print-once committed history to re-print.
+        if !ctx.screen_mode.is_minimal() {
+            return CommandResult::Message(
+                "/expand is only available in minimal mode (--minimal)".to_string(),
+            );
+        }
+        if ctx.session_id.is_none() {
+            return CommandResult::Error("No active session".to_string());
+        }
+        CommandResult::Action(Action::MinimalExpandLast)
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use crate::acp::model_state::ModelState;
+    use crate::app::bundle::BundleState;
+    use crate::settings::PagerLocalSnapshot;
+
+    static DEFAULT_BUNDLE_STATE: BundleState = BundleState {
+        has_cache: false,
+        version: String::new(),
+        personas: Vec::new(),
+        roles: Vec::new(),
+        agents: Vec::new(),
+        skills: Vec::new(),
+        persona_details: Vec::new(),
+        role_details: Vec::new(),
+    };
+
+    fn ctx<'a>(
+        models: &'a ModelState,
+        session_id: Option<&'a agent_client_protocol::SessionId>,
+        screen_mode: crate::app::ScreenMode,
+    ) -> CommandExecCtx<'a> {
+        CommandExecCtx {
+            models,
+            session_id,
+            bundle_state: &DEFAULT_BUNDLE_STATE,
+            screen_mode,
+            pager_state: PagerLocalSnapshot::default(),
+        }
+    }
+
+    #[test]
+    fn minimal_with_session_dispatches_expand_action() {
+        let models = ModelState::default();
+        let sid = agent_client_protocol::SessionId::from("s1".to_string());
+        let mut c = ctx(&models, Some(&sid), crate::app::ScreenMode::Minimal);
+        assert!(matches!(
+            ExpandCommand.run(&mut c, ""),
+            CommandResult::Action(Action::MinimalExpandLast)
+        ));
+    }
+
+    #[test]
+    fn non_minimal_returns_message() {
+        let models = ModelState::default();
+        let sid = agent_client_protocol::SessionId::from("s1".to_string());
+        let mut c = ctx(&models, Some(&sid), crate::app::ScreenMode::Fullscreen);
+        match ExpandCommand.run(&mut c, "") {
+            CommandResult::Message(msg) => assert!(msg.contains("minimal")),
+            other => panic!("expected Message, got {other:?}"),
+        }
+    }
+
+    #[test]
+    fn minimal_without_session_errors() {
+        let models = ModelState::default();
+        let mut c = ctx(&models, None, crate::app::ScreenMode::Minimal);
+        match ExpandCommand.run(&mut c, "") {
+            CommandResult::Error(msg) => assert!(msg.contains("No active session")),
+            other => panic!("expected Error, got {other:?}"),
+        }
+    }
+}