repl: Add inlay repl output display, skip empty lines on execution, and gutter execution display

crates/editor/src/display_map/inlay_map.rs

@@ -325,6 +325,33 @@ impl<'a> Iterator for InlayChunks<'a> {
                     }),
                     InlayId::Hint(_) => self.highlight_styles.inlay_hint,
                     InlayId::DebuggerValue(_) => self.highlight_styles.inlay_hint,
+                    InlayId::ReplResult(_) => {
+                        let text = inlay.text().to_string();
+                        renderer = Some(ChunkRenderer {
+                            id: ChunkRendererId::Inlay(inlay.id),
+                            render: Arc::new(move |cx| {
+                                let colors = cx.theme().colors();
+                                div()
+                                    .flex()
+                                    .flex_row()
+                                    .items_center()
+                                    .child(div().w_4())
+                                    .child(
+                                        div()
+                                            .px_1()
+                                            .rounded_sm()
+                                            .bg(colors.surface_background)
+                                            .text_color(colors.text_muted)
+                                            .text_xs()
+                                            .child(text.trim().to_string()),
+                                    )
+                                    .into_any_element()
+                            }),
+                            constrain_width: false,
+                            measured_width: None,
+                        });
+                        self.highlight_styles.inlay_hint
+                    }
                     InlayId::Color(_) => {
                         if let InlayContent::Color(color) = inlay.content {
                             renderer = Some(ChunkRenderer {

crates/editor/src/inlays.rs

@@ -104,6 +104,14 @@ impl Inlay {
         }
     }
 
+    pub fn repl_result<T: Into<Rope>>(id: usize, position: Anchor, text: T) -> Self {
+        Self {
+            id: InlayId::ReplResult(id),
+            position,
+            content: InlayContent::Text(text.into()),
+        }
+    }
+
     pub fn text(&self) -> &Rope {
         static COLOR_TEXT: OnceLock<Rope> = OnceLock::new();
         match &self.content {

crates/project/src/project.rs

@@ -413,6 +413,7 @@ pub enum InlayId {
     // LSP
     Hint(usize),
     Color(usize),
+    ReplResult(usize),
 }
 
 impl InlayId {
@@ -422,6 +423,7 @@ impl InlayId {
             Self::DebuggerValue(id) => *id,
             Self::Hint(id) => *id,
             Self::Color(id) => *id,
+            Self::ReplResult(id) => *id,
         }
     }
 }

crates/repl/src/outputs.rs

@@ -34,7 +34,7 @@
 //! interpreting and displaying various types of Jupyter output.
 
 use editor::{Editor, MultiBuffer};
-use gpui::{AnyElement, ClipboardItem, Entity, Render, WeakEntity};
+use gpui::{AnyElement, ClipboardItem, Entity, EventEmitter, Render, WeakEntity};
 use language::Buffer;
 use runtimelib::{ExecutionState, JupyterMessageContent, MimeBundle, MimeType};
 use ui::{
@@ -58,6 +58,9 @@ pub(crate) mod user_error;
 use user_error::ErrorView;
 use workspace::Workspace;
 
+use crate::repl_settings::ReplSettings;
+use settings::Settings;
+
 /// When deciding what to render from a collection of mediatypes, we need to rank them in order of importance
 fn rank_mime_type(mimetype: &MimeType) -> usize {
     match mimetype {
@@ -389,6 +392,9 @@ pub enum ExecutionStatus {
     Restarting,
 }
 
+pub struct ExecutionViewFinishedEmpty;
+pub struct ExecutionViewFinishedSmall(pub String);
+
 /// An ExecutionView shows the outputs of an execution.
 /// It can hold zero or more outputs, which the user
 /// sees as "the output" for a single execution.
@@ -399,6 +405,9 @@ pub struct ExecutionView {
     pub status: ExecutionStatus,
 }
 
+impl EventEmitter<ExecutionViewFinishedEmpty> for ExecutionView {}
+impl EventEmitter<ExecutionViewFinishedSmall> for ExecutionView {}
+
 impl ExecutionView {
     pub fn new(
         status: ExecutionStatus,
@@ -475,7 +484,16 @@ impl ExecutionView {
                     ExecutionState::Busy => {
                         self.status = ExecutionStatus::Executing;
                     }
-                    ExecutionState::Idle => self.status = ExecutionStatus::Finished,
+                    ExecutionState::Idle => {
+                        self.status = ExecutionStatus::Finished;
+                        if self.outputs.is_empty() {
+                            cx.emit(ExecutionViewFinishedEmpty);
+                        } else if ReplSettings::get_global(cx).inline_output {
+                            if let Some(small_text) = self.get_small_inline_output(cx) {
+                                cx.emit(ExecutionViewFinishedSmall(small_text));
+                            }
+                        }
+                    }
                     ExecutionState::Unknown => self.status = ExecutionStatus::Unknown,
                     ExecutionState::Starting => self.status = ExecutionStatus::ConnectingToKernel,
                     ExecutionState::Restarting => self.status = ExecutionStatus::Restarting,
@@ -527,6 +545,35 @@ impl ExecutionView {
         }
     }
 
+    /// Check if the output is a single small plain text that can be shown inline.
+    /// Returns the text if it's suitable for inline display (single line, short enough).
+    fn get_small_inline_output(&self, cx: &App) -> Option<String> {
+        // Only consider single outputs
+        if self.outputs.len() != 1 {
+            return None;
+        }
+
+        let output = self.outputs.first()?;
+
+        // Only Plain outputs can be inlined
+        let content = match output {
+            Output::Plain { content, .. } => content,
+            _ => return None,
+        };
+
+        let text = content.read(cx).full_text();
+        let trimmed = text.trim();
+
+        let max_length = ReplSettings::get_global(cx).inline_output_max_length;
+
+        // Must be a single line and within the configured max length
+        if trimmed.contains('\n') || trimmed.len() > max_length {
+            return None;
+        }
+
+        Some(trimmed.to_string())
+    }
+
     fn apply_terminal_text(
         &mut self,
         text: &str,

crates/repl/src/repl_editor.rs

@@ -433,6 +433,36 @@ fn runnable_ranges(
     }
 
     let snippet_range = cell_range(buffer, range.start.row, range.end.row);
+
+    // Check if the snippet range is entirely blank, if so, skip forward to find code
+    let is_blank =
+        (snippet_range.start.row..=snippet_range.end.row).all(|row| buffer.is_line_blank(row));
+
+    if is_blank {
+        // Search forward for the next non-blank line
+        let max_row = buffer.max_point().row;
+        let mut next_row = snippet_range.end.row + 1;
+        while next_row <= max_row && buffer.is_line_blank(next_row) {
+            next_row += 1;
+        }
+
+        if next_row <= max_row {
+            // Found a non-blank line, find the extent of this cell
+            let next_snippet_range = cell_range(buffer, next_row, next_row);
+            let start_language = buffer.language_at(next_snippet_range.start);
+            let end_language = buffer.language_at(next_snippet_range.end);
+
+            if start_language
+                .zip(end_language)
+                .is_some_and(|(start, end)| start == end)
+            {
+                return (vec![next_snippet_range], None);
+            }
+        }
+
+        return (Vec::new(), None);
+    }
+
     let start_language = buffer.language_at(snippet_range.start);
     let end_language = buffer.language_at(snippet_range.end);
 
@@ -821,4 +851,76 @@ mod tests {
             },]
         );
     }
+
+    #[gpui::test]
+    fn test_skip_blank_lines_to_next_cell(cx: &mut App) {
+        let test_language = Arc::new(Language::new(
+            LanguageConfig {
+                name: "TestLang".into(),
+                line_comments: vec!["# ".into()],
+                ..Default::default()
+            },
+            None,
+        ));
+
+        let buffer = cx.new(|cx| {
+            Buffer::local(
+                indoc! { r#"
+                    print(1 + 1)
+
+                    print(2 + 2)
+                "# },
+                cx,
+            )
+            .with_language(test_language.clone(), cx)
+        });
+        let snapshot = buffer.read(cx).snapshot();
+
+        // Selection on blank line should skip to next non-blank cell
+        let (snippets, _) = runnable_ranges(&snapshot, Point::new(1, 0)..Point::new(1, 0), cx);
+        let snippets = snippets
+            .into_iter()
+            .map(|range| snapshot.text_for_range(range).collect::<String>())
+            .collect::<Vec<_>>();
+        assert_eq!(snippets, vec!["print(2 + 2)"]);
+
+        // Multiple blank lines should also skip forward
+        let buffer = cx.new(|cx| {
+            Buffer::local(
+                indoc! { r#"
+                    print(1 + 1)
+
+
+
+                    print(2 + 2)
+                "# },
+                cx,
+            )
+            .with_language(test_language.clone(), cx)
+        });
+        let snapshot = buffer.read(cx).snapshot();
+
+        let (snippets, _) = runnable_ranges(&snapshot, Point::new(2, 0)..Point::new(2, 0), cx);
+        let snippets = snippets
+            .into_iter()
+            .map(|range| snapshot.text_for_range(range).collect::<String>())
+            .collect::<Vec<_>>();
+        assert_eq!(snippets, vec!["print(2 + 2)"]);
+
+        // Blank lines at end of file should return nothing
+        let buffer = cx.new(|cx| {
+            Buffer::local(
+                indoc! { r#"
+                    print(1 + 1)
+
+                "# },
+                cx,
+            )
+            .with_language(test_language, cx)
+        });
+        let snapshot = buffer.read(cx).snapshot();
+
+        let (snippets, _) = runnable_ranges(&snapshot, Point::new(1, 0)..Point::new(1, 0), cx);
+        assert!(snippets.is_empty());
+    }
 }

crates/repl/src/repl_settings.rs

@@ -13,6 +13,15 @@ pub struct ReplSettings {
     ///
     /// Default: 128
     pub max_columns: usize,
+    /// Whether to show small single-line outputs inline instead of in a block.
+    ///
+    /// Default: true
+    pub inline_output: bool,
+    /// Maximum number of characters for an output to be shown inline.
+    /// Only applies when `inline_output` is true.
+    ///
+    /// Default: 50
+    pub inline_output_max_length: usize,
 }
 
 impl Settings for ReplSettings {
@@ -22,6 +31,8 @@ impl Settings for ReplSettings {
         Self {
             max_lines: repl.max_lines.unwrap(),
             max_columns: repl.max_columns.unwrap(),
+            inline_output: repl.inline_output.unwrap_or(true),
+            inline_output_max_length: repl.inline_output_max_length.unwrap_or(50),
         }
     }
 }