From 7c0c15e921a65878cdb3420ea66b8e90b8255eb9 Mon Sep 17 00:00:00 2001
From: JayanAXHF <sunil.chdry@gmail.com>
Date: Sat, 14 Mar 2026 17:57:42 +0530
Subject: [PATCH 1/3] feat(preview pane): Add a small issue list preview when
 in issue conversation

fix: render placeholder in create issue mode for convo preview
---
 src/ui/components/issue_convo_preview.rs | 322 +++++++++++++++++++++--
 src/ui/components/issue_create.rs        |   6 +
 src/ui/components/issue_list.rs          | 200 +++++++++++---
 src/ui/mod.rs                            |   6 +-
 4 files changed, 471 insertions(+), 63 deletions(-)

diff --git a/src/ui/components/issue_convo_preview.rs b/src/ui/components/issue_convo_preview.rs
index 2aa7b73..8fd95fc 100644
--- a/src/ui/components/issue_convo_preview.rs
+++ b/src/ui/components/issue_convo_preview.rs
@@ -1,73 +1,116 @@
 use async_trait::async_trait;
+use crossterm::event;
 use rat_widget::{
-    event::{HandleEvent, Regular},
-    focus::{FocusBuilder, FocusFlag, HasFocus},
+    event::{HandleEvent, Regular, ct_event},
+    focus::{FocusBuilder, FocusFlag, HasFocus, Navigation},
     paragraph::ParagraphState,
 };
 use ratatui::{
     buffer::Buffer,
     layout::Rect,
-    widgets::{Block, Borders, StatefulWidget, Widget},
+    style::{Color, Modifier, Style},
+    text::Span,
+    widgets::{
+        self, Block, Borders, List as TuiList, ListItem, ListState as TuiListState, Padding,
+        StatefulWidget, Widget,
+    },
 };
 use std::sync::{Arc, RwLock};
+use textwrap::wrap;
 
 use crate::{
     errors::AppError,
     ui::{
         Action,
-        components::{Component, help::HelpElementKind, issue_conversation::render_markdown},
+        components::{
+            Component,
+            help::HelpElementKind,
+            issue_conversation::render_markdown,
+            issue_detail::IssuePreviewSeed,
+            issue_list::{MainScreen, build_issue_list_item, build_issue_list_lines},
+        },
+        issue_data::{IssueId, UiIssuePool},
         layout::Layout,
         utils::get_border_style,
     },
 };
 
 pub const HELP: &[HelpElementKind] = &[
-    crate::help_text!("Issue Conversation Help"),
-    crate::help_keybind!("Up/Down", "select issue body/comment entry"),
-    crate::help_keybind!("PageUp/PageDown/Home/End", "scroll message body pane"),
-    crate::help_keybind!("t", "toggle timeline events"),
-    crate::help_keybind!("f", "toggle fullscreen body view"),
-    crate::help_keybind!("C", "close selected issue"),
-    crate::help_keybind!("l", "copy link to selected message"),
-    crate::help_keybind!("Enter (popup)", "confirm close reason"),
-    crate::help_keybind!("Ctrl+P", "toggle comment input/preview"),
-    crate::help_keybind!("e", "edit selected comment in external editor"),
-    crate::help_keybind!("r", "add reaction to selected comment"),
-    crate::help_keybind!("R", "remove reaction from selected comment"),
-    crate::help_keybind!("Ctrl+Enter / Alt+Enter", "send comment"),
-    crate::help_keybind!("Esc", "exit fullscreen / return to issue list"),
+    crate::help_text!("Issue Conversation Preview Help"),
+    crate::help_text!("* marks the issue currently open in details"),
+    crate::help_keybind!("Up/Down", "select nearby issue"),
+    crate::help_keybind!("Enter", "open selected issue"),
+    crate::help_keybind!("Tab", "move focus forward"),
+    crate::help_keybind!("Shift+Tab / Esc", "move focus back"),
 ];
 
-#[derive(Default)]
 pub struct IssueConvoPreview {
     action_tx: Option<tokio::sync::mpsc::Sender<Action>>,
+    issue_pool: Arc<RwLock<UiIssuePool>>,
     body: Option<Arc<str>>,
+    issue_ids: Vec<IssueId>,
+    open_number: Option<u64>,
+    selected_number: Option<u64>,
+    screen: MainScreen,
     area: Rect,
     paragraph_state: ParagraphState,
+    list_state: TuiListState,
     index: usize,
     focus: FocusFlag,
 }
 
 impl IssueConvoPreview {
-    pub fn new() -> Self {
-        Self::default()
+    pub fn new(issue_pool: Arc<RwLock<UiIssuePool>>) -> Self {
+        Self {
+            action_tx: None,
+            issue_pool,
+            body: None,
+            issue_ids: Vec::new(),
+            open_number: None,
+            selected_number: None,
+            screen: MainScreen::List,
+            area: Rect::default(),
+            paragraph_state: ParagraphState::default(),
+            list_state: TuiListState::default(),
+            index: 0,
+            focus: FocusFlag::new().with_name("issue_convo_preview"),
+        }
     }
 
     pub fn render(&mut self, area: Layout, buf: &mut Buffer) {
+        self.area = area.mini_convo_preview;
+        match self.screen {
+            MainScreen::List => self.render_body_preview(area.mini_convo_preview, buf),
+            MainScreen::Details => self.render_issue_list_preview(area.mini_convo_preview, buf),
+            MainScreen::CreateIssue => {
+                let para = widgets::Paragraph::new("No preview available in fullscreen mode")
+                    .block(
+                        Block::default()
+                            .borders(Borders::LEFT | Borders::BOTTOM)
+                            .title(format!("[{}] Issue Conversation", self.index))
+                            .merge_borders(ratatui::symbols::merge::MergeStrategy::Exact)
+                            .border_style(get_border_style(&self.paragraph_state)),
+                    );
+                para.render(area.mini_convo_preview, buf);
+            }
+            MainScreen::DetailsFullscreen => {}
+        }
+    }
+
+    fn render_body_preview(&mut self, area: Rect, buf: &mut Buffer) {
         let block_template = Block::default()
             .borders(Borders::LEFT | Borders::BOTTOM)
             .border_style(get_border_style(&self.paragraph_state));
 
-        self.area = area.mini_convo_preview;
         let Some(ref body) = self.body else {
             let para =
                 ratatui::widgets::Paragraph::new("Select an issue to preview the conversation")
                     .block(
                         block_template
-                            .title(format!("[{}] Issue Conversation]", self.index))
+                            .title(format!("[{}] Issue Conversation", self.index))
                             .merge_borders(ratatui::symbols::merge::MergeStrategy::Exact),
                     );
-            para.render(area.mini_convo_preview, buf);
+            para.render(area, buf);
             return;
         };
         let rendered = render_markdown(body, area.width.saturating_sub(2).into(), 2).lines;
@@ -201,11 +244,61 @@ impl Component for IssueConvoPreview {
     async fn handle_event(&mut self, event: Action) -> Result<(), AppError> {
         match event {
             Action::AppEvent(ref event) => {
-                self.paragraph_state.handle(event, Regular);
+                if self.screen == MainScreen::List {
+                    self.paragraph_state.handle(event, Regular);
+                } else if self.screen == MainScreen::Details && self.paragraph_state.is_focused() {
+                    match event {
+                        ct_event!(keycode press Up) => {
+                            self.list_state.select_previous();
+                            self.selected_number = self.selected_issue_id().map(|issue_id| {
+                                let pool =
+                                    self.issue_pool.read().expect("issue pool lock poisoned");
+                                pool.get_issue(issue_id).number
+                            });
+                        }
+                        ct_event!(keycode press Down) => {
+                            self.list_state.select_next();
+                            self.selected_number = self.selected_issue_id().map(|issue_id| {
+                                let pool =
+                                    self.issue_pool.read().expect("issue pool lock poisoned");
+                                pool.get_issue(issue_id).number
+                            });
+                        }
+                        ct_event!(keycode press Enter) => {
+                            self.open_selected_issue().await?;
+                        }
+                        ct_event!(keycode press Tab) => {
+                            if let Some(action_tx) = self.action_tx.as_ref() {
+                                action_tx.send(Action::ForceFocusChange).await?;
+                            }
+                        }
+                        ct_event!(keycode press SHIFT-BackTab) | ct_event!(keycode press Esc) => {
+                            if let Some(action_tx) = self.action_tx.as_ref() {
+                                action_tx.send(Action::ForceFocusChangeRev).await?;
+                            }
+                        }
+                        _ => {}
+                    }
+                }
             }
             Action::ChangeIssueBodyPreview(body) => {
                 self.body = Some(body);
             }
+            Action::IssueListPreviewUpdated {
+                issue_ids,
+                selected_number,
+            } => {
+                self.issue_ids = issue_ids;
+                self.open_number = Some(selected_number);
+                self.selected_number = Some(selected_number);
+                self.sync_selected_issue();
+            }
+            Action::ChangeIssueScreen(screen) => {
+                self.screen = screen;
+                if screen != MainScreen::Details {
+                    self.paragraph_state.focus.set(false);
+                }
+            }
             _ => {}
         }
         Ok(())
@@ -228,6 +321,25 @@ impl Component for IssueConvoPreview {
             let _ = action_tx.try_send(Action::SetHelp(HELP));
         }
     }
+
+    fn capture_focus_event(&self, event: &event::Event) -> bool {
+        if self.screen != MainScreen::Details || !self.paragraph_state.is_focused() {
+            return false;
+        }
+
+        match event {
+            event::Event::Key(key) => matches!(
+                key.code,
+                event::KeyCode::Up
+                    | event::KeyCode::Down
+                    | event::KeyCode::Enter
+                    | event::KeyCode::Tab
+                    | event::KeyCode::BackTab
+                    | event::KeyCode::Esc
+            ),
+            _ => false,
+        }
+    }
 }
 
 impl HasFocus for IssueConvoPreview {
@@ -244,4 +356,164 @@ impl HasFocus for IssueConvoPreview {
     fn area(&self) -> Rect {
         self.area
     }
+
+    fn navigable(&self) -> Navigation {
+        if self.screen == MainScreen::Details {
+            Navigation::Regular
+        } else {
+            Navigation::None
+        }
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use crate::ui::testing::{DummyDataConfig, dummy_ui_data_with};
+    use octocrab::models::Label;
+    use ratatui::{buffer::Buffer, layout::Rect};
+    use tokio::sync::mpsc;
+
+    fn buffer_text(buf: &Buffer) -> String {
+        let area = buf.area;
+        (area.top()..area.bottom())
+            .map(|y| {
+                (area.left()..area.right())
+                    .map(|x| buf[(x, y)].symbol())
+                    .collect::<String>()
+            })
+            .collect::<Vec<_>>()
+            .join("\n")
+    }
+
+    #[test]
+    fn renders_body_preview_in_list_mode() {
+        let data = dummy_ui_data_with(DummyDataConfig {
+            issue_count: 3,
+            ..DummyDataConfig::default()
+        });
+        let pool = Arc::new(RwLock::new(data.pool));
+        let mut preview = IssueConvoPreview::new(pool);
+        preview.body = Some(Arc::<str>::from("hello from preview body"));
+
+        let mut buf = Buffer::empty(Rect::new(0, 0, 80, 24));
+        preview.render(Layout::fullscreen(Rect::new(0, 0, 80, 24)), &mut buf);
+
+        let text = buffer_text(&buf);
+        assert!(text.contains("Issue Body"));
+        assert!(text.contains("hello from preview body"));
+    }
+
+    #[test]
+    fn renders_nearby_issues_in_details_mode() {
+        let data = dummy_ui_data_with(DummyDataConfig {
+            issue_count: 4,
+            ..DummyDataConfig::default()
+        });
+        let selected_id = data.issue_ids[1];
+        let open_number = data.issue_numbers[1];
+        let selected_number = data.issue_numbers[2];
+        let pool = Arc::new(RwLock::new(data.pool));
+        let mut preview = IssueConvoPreview::new(pool);
+        preview.screen = MainScreen::Details;
+        preview.issue_ids = data.issue_ids.clone();
+        preview.open_number = Some(open_number);
+        preview.selected_number = Some(selected_number);
+        preview.sync_selected_issue();
+
+        let mut buf = Buffer::empty(Rect::new(0, 0, 80, 24));
+        preview.render(Layout::fullscreen(Rect::new(0, 0, 80, 24)), &mut buf);
+
+        let text = buffer_text(&buf);
+        assert!(text.contains("Nearby Issues"));
+        assert!(text.contains(&format!("#{open_number}")));
+        assert!(text.contains(&format!("#{selected_number}")));
+
+        let pool = preview.issue_pool.read().expect("issue pool lock poisoned");
+        let open_title = pool.resolve_str(pool.get_issue(selected_id).title);
+        let selected_title = pool.resolve_str(pool.get_issue(data.issue_ids[2]).title);
+        assert!(text.contains(&format!("* {open_title}")));
+        assert!(!text.contains(&format!("* {selected_title}")));
+    }
+
+    #[test]
+    fn renders_nothing_in_fullscreen_mode() {
+        let data = dummy_ui_data_with(DummyDataConfig::default());
+        let pool = Arc::new(RwLock::new(data.pool));
+        let mut preview = IssueConvoPreview::new(pool);
+        preview.screen = MainScreen::DetailsFullscreen;
+
+        let mut buf = Buffer::empty(Rect::new(0, 0, 80, 24));
+        preview.render(Layout::fullscreen(Rect::new(0, 0, 80, 24)), &mut buf);
+
+        let text = buffer_text(&buf);
+        assert!(text.trim().is_empty());
+    }
+
+    #[tokio::test]
+    async fn opens_selected_issue_from_preview() {
+        let data = dummy_ui_data_with(DummyDataConfig {
+            issue_count: 4,
+            ..DummyDataConfig::default()
+        });
+        let selected_id = data.issue_ids[1];
+        let selected_number = data.issue_numbers[1];
+        let expected_author = data
+            .preview_seeds
+            .get(&selected_id)
+            .expect("preview seed should exist")
+            .author
+            .clone();
+        let expected_labels: Vec<Label> = {
+            let issue = data.pool.get_issue(selected_id);
+            issue.labels.clone()
+        };
+        let pool = Arc::new(RwLock::new(data.pool));
+        let mut preview = IssueConvoPreview::new(pool);
+        let (tx, mut rx) = mpsc::channel(8);
+        preview.register_action_tx(tx);
+        preview.screen = MainScreen::Details;
+        preview.issue_ids = data.issue_ids.clone();
+        preview.selected_number = Some(selected_number);
+        preview.sync_selected_issue();
+
+        preview
+            .open_selected_issue()
+            .await
+            .expect("open should succeed");
+
+        match rx.recv().await.expect("selected issue action") {
+            Action::SelectedIssue { number, labels } => {
+                assert_eq!(number, selected_number);
+                assert_eq!(labels, expected_labels);
+            }
+            other => panic!("unexpected action: {other:?}"),
+        }
+
+        match rx.recv().await.expect("selected issue preview action") {
+            Action::SelectedIssuePreview { seed } => {
+                assert_eq!(seed.number, selected_number);
+                assert_eq!(seed.author, expected_author);
+            }
+            other => panic!("unexpected action: {other:?}"),
+        }
+
+        match rx.recv().await.expect("preview refresh action") {
+            Action::IssueListPreviewUpdated {
+                issue_ids,
+                selected_number: number,
+            } => {
+                assert_eq!(number, selected_number);
+                assert_eq!(issue_ids, data.issue_ids);
+            }
+            other => panic!("unexpected action: {other:?}"),
+        }
+
+        match rx.recv().await.expect("enter details action") {
+            Action::EnterIssueDetails { seed } => {
+                assert_eq!(seed.number, selected_number);
+            }
+            other => panic!("unexpected action: {other:?}"),
+        }
+    }
 }
diff --git a/src/ui/components/issue_create.rs b/src/ui/components/issue_create.rs
index a8b6818..33a6522 100644
--- a/src/ui/components/issue_create.rs
+++ b/src/ui/components/issue_create.rs
@@ -259,6 +259,12 @@ impl IssueCreate {
         let _ = action_tx
             .send(Action::SelectedIssuePreview { seed: preview_seed })
             .await;
+        let _ = action_tx
+            .send(Action::IssueListPreviewUpdated {
+                issue_ids: vec![issue_id],
+                selected_number: number,
+            })
+            .await;
         let _ = action_tx
             .send(Action::EnterIssueDetails {
                 seed: conversation_seed,
diff --git a/src/ui/components/issue_list.rs b/src/ui/components/issue_list.rs
index d624e86..93bce71 100644
--- a/src/ui/components/issue_list.rs
+++ b/src/ui/components/issue_list.rs
@@ -53,6 +53,7 @@ use tokio_util::sync::CancellationToken;
 use tracing::trace;
 
 pub static LOADED_ISSUE_COUNT: AtomicU32 = AtomicU32::new(0);
+const DETAILS_PREVIEW_WINDOW_SIZE: usize = 5;
 pub const HELP: &[HelpElementKind] = &[
     crate::help_text!("Issue List Help"),
     crate::help_keybind!("Up/Down", "navigate issues"),
@@ -176,6 +177,23 @@ pub enum MainScreen {
 }
 
 impl<'a> IssueList<'a> {
+    async fn send_issue_list_preview_for_number(&self, number: u64) -> Result<(), AppError> {
+        let issue_ids = {
+            let pool = self.issue_pool.read().expect("issue pool lock poisoned");
+            build_details_preview_issue_ids(&self.issues, &pool, number).unwrap_or_default()
+        };
+
+        if let Some(action_tx) = self.action_tx.as_ref() {
+            action_tx
+                .send(Action::IssueListPreviewUpdated {
+                    issue_ids,
+                    selected_number: number,
+                })
+                .await?;
+        }
+        Ok(())
+    }
+
     pub async fn new(
         handler: IssueHandler<'a>,
         owner: String,
@@ -493,13 +511,14 @@ impl<'a> IssueList<'a> {
             })
         } {
             self.close_bookmark_popup();
-            if let Some(action_tx) = self.action_tx.as_ref() {
+            if let Some(action_tx) = self.action_tx.clone() {
                 action_tx
                     .send(Action::SelectedIssue { number, labels })
                     .await?;
                 action_tx
                     .send(Action::SelectedIssuePreview { seed: preview_seed })
                     .await?;
+                self.send_issue_list_preview_for_number(number).await?;
                 action_tx
                     .send(Action::EnterIssueDetails {
                         seed: conversation_seed,
@@ -763,44 +782,92 @@ impl<'a> IssueList<'a> {
         pool: &UiIssuePool,
     ) -> ListItem<'static> {
         let issue = pool.get_issue(issue.0);
-        let options = Options::with_termwidth();
-        let body_text = pool
-            .resolve_opt_str(issue.body)
-            .unwrap_or("No desc provided");
-        let body_preview = build_issue_body_preview(body_text, options);
-
         let bookmarked = bookmarks.is_bookmarked(&self.owner, &self.repo, issue.number);
+        build_issue_list_item(issue, pool, bookmarked, true)
+    }
+}
+
+pub(crate) fn build_details_preview_issue_ids(
+    issues: &[IssueListItem],
+    pool: &UiIssuePool,
+    selected_number: u64,
+) -> Option<Vec<IssueId>> {
+    let selected_idx = issues
+        .iter()
+        .position(|item| pool.get_issue(item.0).number == selected_number)?;
+    let half_window = DETAILS_PREVIEW_WINDOW_SIZE / 2;
+    let start = selected_idx.saturating_sub(half_window);
+    let end = (start + DETAILS_PREVIEW_WINDOW_SIZE).min(issues.len());
+    let start = end.saturating_sub(DETAILS_PREVIEW_WINDOW_SIZE);
+    Some(issues[start..end].iter().map(|item| item.0).collect())
+}
+
+pub(crate) fn build_issue_list_item(
+    issue: &UiIssue,
+    pool: &UiIssuePool,
+    bookmarked: bool,
+    show_bookmark: bool,
+) -> ListItem<'static> {
+    ListItem::new(build_issue_list_lines(
+        issue,
+        pool,
+        bookmarked,
+        show_bookmark,
+    ))
+}
+
+pub(crate) fn build_issue_list_lines(
+    issue: &UiIssue,
+    pool: &UiIssuePool,
+    bookmarked: bool,
+    show_bookmark: bool,
+) -> Vec<Line<'static>> {
+    let body_text = pool
+        .resolve_opt_str(issue.body)
+        .unwrap_or("No desc provided");
+    let body_preview = build_issue_body_preview(body_text, Options::with_termwidth());
+    let title = pool.resolve_str(issue.title);
+    let author = pool.author_login(issue.author);
+    let created_at = pool.resolve_str(issue.created_at_full);
+
+    let title_line = if show_bookmark {
         let bookmark_symbol = if bookmarked { " b " } else { "   " };
-        let title = pool.resolve_str(issue.title);
-        let author = pool.author_login(issue.author);
-        let created_at = pool.resolve_str(issue.created_at_full);
-
-        let lines = vec![
-            line![
-                span!(bookmark_symbol).style(if bookmarked {
-                    Style::new().reversed()
+        line![
+            span!(bookmark_symbol).style(if bookmarked {
+                Style::new().reversed()
+            } else {
+                Style::new()
+            }),
+            span!(title.to_string()),
+            " ",
+            span!("#{}", issue.number).dim(),
+        ]
+    } else {
+        line![
+            span!(title.to_string()),
+            " ",
+            span!("#{}", issue.number).dim(),
+        ]
+    };
+
+    let metadata_spacing = if show_bookmark { "  " } else { " " };
+    let body_indent = if show_bookmark { "   " } else { "" };
+
+    vec![
+        title_line,
+        line![
+            span!(symbols::shade::FULL).style({
+                if matches!(issue.state, IssueState::Open) {
+                    Style::new().green()
                 } else {
-                    Style::new()
-                }),
-                span!(title.to_string()),
-                " ",
-                span!("#{}", issue.number).dim(),
-            ],
-            line![
-                span!(symbols::shade::FULL).style({
-                    if matches!(issue.state, IssueState::Open) {
-                        Style::new().green()
-                    } else {
-                        Style::new().magenta()
-                    }
-                }),
-                "  ",
-                span!(format!("Opened by {author} at {created_at}")).dim(),
-            ],
-            line!["   ", span!(body_preview).style(Style::new().dim())],
-        ];
-        ListItem::new(lines)
-    }
+                    Style::new().magenta()
+                }
+            }),
+            metadata_spacing,
+            span!(format!("Opened by {author} at {created_at}")).dim(),
+        ],
+        line![body_indent, span!(body_preview).style(Style::new().dim())],
+    ]
 }
 
 pub(crate) fn build_issue_body_preview(body_text: &str, options: Options<'_>) -> String {
@@ -1094,6 +1161,8 @@ impl Component for IssueList<'_> {
                             let issue = pool.get_issue(self.issues[selected].0);
                             IssueConversationSeed::from_ui_issue(issue, &pool)
                         };
+                        self.send_issue_list_preview_for_number(conversation_seed.number)
+                            .await?;
                         self.action_tx
                             .as_ref()
                             .ok_or_else(|| {
@@ -1322,13 +1391,24 @@ impl Component for IssueList<'_> {
                 let number = issue_number;
                 self.close_bookmark_popup();
 
-                if let Some(action_tx) = self.action_tx.as_ref() {
+                if let Some(action_tx) = self.action_tx.clone() {
                     action_tx
                         .send(Action::SelectedIssue { number, labels })
                         .await?;
                     action_tx
                         .send(Action::SelectedIssuePreview { seed: preview_seed })
                         .await?;
+                    let issue_ids = {
+                        let pool = self.issue_pool.read().expect("issue pool lock poisoned");
+                        build_details_preview_issue_ids(&self.issues, &pool, number)
+                            .unwrap_or_else(|| vec![issue_id])
+                    };
+                    action_tx
+                        .send(Action::IssueListPreviewUpdated {
+                            issue_ids,
+                            selected_number: number,
+                        })
+                        .await?;
                     action_tx
                         .send(Action::EnterIssueDetails {
                             seed: conversation_seed,
@@ -1416,3 +1496,49 @@ impl HasFocus for IssueList<'_> {
         }
     }
 }
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use crate::ui::testing::{DummyDataConfig, dummy_ui_data_with};
+
+    #[test]
+    fn preview_window_centers_on_selected_issue_when_available() {
+        let data = dummy_ui_data_with(DummyDataConfig {
+            issue_count: 7,
+            ..DummyDataConfig::default()
+        });
+        let issues = data
+            .issue_ids
+            .iter()
+            .copied()
+            .map(IssueListItem)
+            .collect::<Vec<_>>();
+
+        let selected_number = data.issue_numbers[3];
+        let issue_ids = build_details_preview_issue_ids(&issues, &data.pool, selected_number)
+            .expect("preview window should exist");
+        let numbers = issue_ids
+            .iter()
+            .map(|issue_id| data.pool.get_issue(*issue_id).number)
+            .collect::<Vec<_>>();
+
+        assert_eq!(numbers, data.issue_numbers[1..6].to_vec());
+    }
+
+    #[test]
+    fn preview_window_returns_none_for_missing_issue() {
+        let data = dummy_ui_data_with(DummyDataConfig {
+            issue_count: 3,
+            ..DummyDataConfig::default()
+        });
+        let issues = data
+            .issue_ids
+            .iter()
+            .copied()
+            .map(IssueListItem)
+            .collect::<Vec<_>>();
+
+        assert!(build_details_preview_issue_ids(&issues, &data.pool, 999_999).is_none());
+    }
+}
diff --git a/src/ui/mod.rs b/src/ui/mod.rs
index 6a7eabe..b49a5f7 100644
--- a/src/ui/mod.rs
+++ b/src/ui/mod.rs
@@ -191,7 +191,7 @@ impl App {
         let issue_pool = Arc::new(RwLock::new(UiIssuePool::default()));
         let mut issue_conversation = IssueConversation::new(state.clone(), issue_pool.clone());
         let mut issue_create = IssueCreate::new(state.clone(), issue_pool.clone());
-        let mut issue_convo_preview = IssueConvoPreview::new();
+        let mut issue_convo_preview = IssueConvoPreview::new(issue_pool.clone());
         let bookmarks = Arc::new(RwLock::new(read_bookmarks()));
         let issue_handler = GITHUB_CLIENT
             .get()
@@ -670,6 +670,10 @@ pub enum Action {
         seed: IssueConversationSeed,
     },
     ChangeIssueBodyPreview(Arc<str>),
+    IssueListPreviewUpdated {
+        issue_ids: Vec<IssueId>,
+        selected_number: u64,
+    },
     IssueCommentsLoaded {
         number: u64,
         comments: Vec<CommentView>,

From a23dbf1e3cfb650777ee5e0fc3b16d465d8a7708 Mon Sep 17 00:00:00 2001
From: JayanAXHF <sunil.chdry@gmail.com>
Date: Sun, 15 Mar 2026 00:16:38 +0530
Subject: [PATCH 2/3] fix(md): fixed checklist rendering

test(markdown): add UI tests for fixed list rendering
---
 src/ui/components/issue_conversation.rs       | 112 ++++++++++++++++--
 tests/markdown_checklists.rs                  |  80 +++++++++++++
 ..._keeps_checked_and_unchecked_prefixes.snap |  17 +++
 ...down_preview_renders_ascii_checklists.snap |  18 +++
 ...preview_wraps_checklist_continuations.snap |  18 +++
 5 files changed, 234 insertions(+), 11 deletions(-)
 create mode 100644 tests/markdown_checklists.rs
 create mode 100644 tests/snapshots/markdown_checklists__markdown_preview_keeps_checked_and_unchecked_prefixes.snap
 create mode 100644 tests/snapshots/markdown_checklists__markdown_preview_renders_ascii_checklists.snap
 create mode 100644 tests/snapshots/markdown_checklists__markdown_preview_wraps_checklist_continuations.snap

diff --git a/src/ui/components/issue_conversation.rs b/src/ui/components/issue_conversation.rs
index fe6c038..2a99288 100644
--- a/src/ui/components/issue_conversation.rs
+++ b/src/ui/components/issue_conversation.rs
@@ -2497,11 +2497,56 @@ struct MarkdownRenderer {
     in_code_block: bool,
     code_block_lang: Option<String>,
     code_block_buf: String,
-    list_prefix: Option<String>,
+    item_prefix: Option<ListPrefix>,
     pending_space: bool,
     active_link_url: Option<String>,
 }
 
+#[derive(Debug, Clone)]
+struct ListPrefix {
+    first_line: String,
+    continuation: String,
+    first_line_pending: bool,
+}
+
+impl ListPrefix {
+    fn bullet() -> Self {
+        Self::new("• ".to_string())
+    }
+
+    fn task(checked: bool) -> Self {
+        let prefix = if checked { "[x] " } else { "[ ] " };
+        Self::new(prefix.to_string())
+    }
+
+    fn new(first_line: String) -> Self {
+        let continuation = " ".repeat(display_width(&first_line));
+        Self {
+            first_line,
+            continuation,
+            first_line_pending: true,
+        }
+    }
+
+    fn current_text(&self) -> &str {
+        if self.first_line_pending {
+            &self.first_line
+        } else {
+            &self.continuation
+        }
+    }
+
+    fn current_width(&self) -> usize {
+        display_width(self.current_text())
+    }
+
+    fn take_for_line(&mut self) -> String {
+        let prefix = self.current_text().to_string();
+        self.first_line_pending = false;
+        prefix
+    }
+}
+
 #[derive(Clone, Copy)]
 struct AdmonitionStyle {
     marker: &'static str,
@@ -2564,7 +2609,7 @@ impl MarkdownRenderer {
             in_code_block: false,
             code_block_lang: None,
             code_block_buf: String::new(),
-            list_prefix: None,
+            item_prefix: None,
             pending_space: false,
             active_link_url: None,
         }
@@ -2604,7 +2649,7 @@ impl MarkdownRenderer {
             }
             Tag::Item => {
                 self.flush_line();
-                self.list_prefix = Some("• ".to_string());
+                self.item_prefix = Some(ListPrefix::bullet());
             }
             _ => {}
         }
@@ -2644,7 +2689,7 @@ impl MarkdownRenderer {
             }
             TagEnd::Item => {
                 self.flush_line();
-                self.list_prefix = None;
+                self.item_prefix = None;
             }
             TagEnd::Paragraph => {
                 self.flush_line();
@@ -2716,8 +2761,8 @@ impl MarkdownRenderer {
 
     fn task_list_marker(&mut self, checked: bool) {
         self.ensure_admonition_header();
-        let marker = if checked { "[x] " } else { "[ ] " };
-        self.push_text(marker, self.current_style);
+        self.item_prefix = Some(ListPrefix::task(checked));
+        self.pending_space = false;
     }
 
     fn rule(&mut self) {
@@ -2923,9 +2968,10 @@ impl MarkdownRenderer {
                 .unwrap_or_else(|| Style::new().fg(Color::DarkGray));
             self.current_line.push(Span::styled("│ ", border_style));
         }
-        if let Some(prefix) = &self.list_prefix {
-            self.current_width += display_width(prefix);
-            self.current_line.push(Span::raw(prefix.clone()));
+        if let Some(prefix) = self.item_prefix.as_mut() {
+            let prefix = prefix.take_for_line();
+            self.current_width += display_width(&prefix);
+            self.current_line.push(Span::raw(prefix));
         }
     }
 
@@ -2934,8 +2980,8 @@ impl MarkdownRenderer {
         if self.in_block_quote {
             width += 2;
         }
-        if let Some(prefix) = &self.list_prefix {
-            width += display_width(prefix);
+        if let Some(prefix) = &self.item_prefix {
+            width += prefix.current_width();
         }
         width
     }
@@ -3090,6 +3136,19 @@ mod tests {
             .collect()
     }
 
+    fn all_line_text(rendered: &super::MarkdownRender) -> Vec<String> {
+        rendered
+            .lines
+            .iter()
+            .map(|line| {
+                line.spans
+                    .iter()
+                    .map(|span| span.content.as_ref())
+                    .collect()
+            })
+            .collect()
+    }
+
     #[test]
     fn extracts_link_segments_with_urls() {
         let rendered = render_markdown("Go to [ratatui docs](https://github.com/ratatui/).", 80, 0);
@@ -3122,4 +3181,35 @@ mod tests {
                 .all(|link| !link.label.starts_with(' ') && !link.label.ends_with(' '))
         );
     }
+
+    #[test]
+    fn renders_unchecked_checklist_without_bullet_prefix() {
+        let rendered = render_markdown("- [ ] todo", 80, 0);
+
+        assert_eq!(all_line_text(&rendered), vec!["[ ] todo"]);
+    }
+
+    #[test]
+    fn renders_checked_checklist_without_bullet_prefix() {
+        let rendered = render_markdown("- [x] done", 80, 0);
+
+        assert_eq!(all_line_text(&rendered), vec!["[x] done"]);
+    }
+
+    #[test]
+    fn wraps_checklist_items_with_aligned_continuation() {
+        let rendered = render_markdown("- [ ] hello world", 10, 0);
+
+        assert_eq!(all_line_text(&rendered), vec!["[ ] hello", "    world"]);
+    }
+
+    #[test]
+    fn keeps_bullets_for_non_task_list_items() {
+        let rendered = render_markdown("- bullet\n- [x] done\n- [ ] todo", 80, 0);
+
+        assert_eq!(
+            all_line_text(&rendered),
+            vec!["• bullet", "[x] done", "[ ] todo"]
+        );
+    }
 }
diff --git a/tests/markdown_checklists.rs b/tests/markdown_checklists.rs
new file mode 100644
index 0000000..bf58375
--- /dev/null
+++ b/tests/markdown_checklists.rs
@@ -0,0 +1,80 @@
+mod support;
+
+use crate::support::buffer_to_string;
+use crossterm::event::{Event, KeyCode, KeyEvent, KeyModifiers};
+use futures::executor::block_on;
+use gitv_tui::ui::components::{Component, issue_create::IssueCreate};
+use gitv_tui::ui::issue_data::UiIssuePool;
+use gitv_tui::ui::{Action, AppState};
+use insta::assert_snapshot;
+use ratatui::buffer::Buffer;
+use ratatui::layout::Rect;
+use std::sync::{Arc, RwLock};
+use tokio::sync::mpsc;
+
+fn render_issue_create_preview(body: &str, width: u16, height: u16) -> String {
+    let area = Rect::new(0, 0, width, height);
+    let layout = gitv_tui::ui::layout::Layout::fullscreen(area);
+    let mut buf = Buffer::empty(area);
+    let issue_pool = Arc::new(RwLock::new(UiIssuePool::default()));
+    let mut issue_create = IssueCreate::new(
+        AppState::new("repo".to_string(), "owner".to_string(), "user".to_string()),
+        issue_pool,
+    );
+    let (tx, _rx) = mpsc::channel(8);
+    issue_create.register_action_tx(tx);
+
+    block_on(async {
+        issue_create
+            .handle_event(Action::EnterIssueCreate)
+            .await
+            .expect("enter issue create should succeed");
+        issue_create
+            .handle_event(Action::AppEvent(Event::Paste(body.to_string())))
+            .await
+            .expect("pasting markdown body should succeed");
+        issue_create
+            .handle_event(Action::AppEvent(Event::Key(KeyEvent::new(
+                KeyCode::Char('p'),
+                KeyModifiers::CONTROL,
+            ))))
+            .await
+            .expect("toggling preview should succeed");
+    });
+
+    issue_create.render(layout, &mut buf);
+    buffer_to_string(&buf)
+}
+
+#[test]
+fn markdown_preview_renders_ascii_checklists() {
+    let result = render_issue_create_preview(
+        "## Tasks\n\n- [ ] write docs\n- [x] add tests\n- plain bullet",
+        44,
+        16,
+    );
+
+    assert_snapshot!(result);
+}
+
+#[test]
+fn markdown_preview_wraps_checklist_continuations() {
+    let result = render_issue_create_preview(
+        "- [ ] a very long checklist item that should wrap onto the next rendered line",
+        34,
+        14,
+    );
+
+    assert_snapshot!(result);
+}
+
+#[test]
+fn markdown_preview_keeps_checked_and_unchecked_prefixes() {
+    let result = render_issue_create_preview(
+        "- [x] completed task\n- [ ] pending task\n- [x] reviewed",
+        38,
+        14,
+    );
+
+    assert_snapshot!(result);
+}
diff --git a/tests/snapshots/markdown_checklists__markdown_preview_keeps_checked_and_unchecked_prefixes.snap b/tests/snapshots/markdown_checklists__markdown_preview_keeps_checked_and_unchecked_prefixes.snap
new file mode 100644
index 0000000..c118d08
--- /dev/null
+++ b/tests/snapshots/markdown_checklists__markdown_preview_keeps_checked_and_unchecked_prefixes.snap
@@ -0,0 +1,17 @@
+---
+source: tests/markdown_checklists.rs
+expression: result
+---
+╭[0] Title───────────────────────────╮
+│                                    │
+╰────────────────────────────────────╯
+╭Labels (comma-separated)────────────╮
+│                                    │
+╰────────────────────────────────────╯
+╭Assignees (comma-separated)─────────╮
+│                                    │
+╰────────────────────────────────────╯
+Preview (Ctrl+P: Edit | Ctrl+Enter: Cr
+   [x] completed task                 
+   [ ] pending task                   
+   [x] reviewed
diff --git a/tests/snapshots/markdown_checklists__markdown_preview_renders_ascii_checklists.snap b/tests/snapshots/markdown_checklists__markdown_preview_renders_ascii_checklists.snap
new file mode 100644
index 0000000..a20ae0a
--- /dev/null
+++ b/tests/snapshots/markdown_checklists__markdown_preview_renders_ascii_checklists.snap
@@ -0,0 +1,18 @@
+---
+source: tests/markdown_checklists.rs
+expression: result
+---
+╭[0] Title─────────────────────────────────╮
+│                                          │
+╰──────────────────────────────────────────╯
+╭Labels (comma-separated)──────────────────╮
+│                                          │
+╰──────────────────────────────────────────╯
+╭Assignees (comma-separated)───────────────╮
+│                                          │
+╰──────────────────────────────────────────╯
+Preview (Ctrl+P: Edit | Ctrl+Enter: Create)─
+   Tasks                                    
+   [ ] write docs                           
+   [x] add tests                            
+   • plain bullet
diff --git a/tests/snapshots/markdown_checklists__markdown_preview_wraps_checklist_continuations.snap b/tests/snapshots/markdown_checklists__markdown_preview_wraps_checklist_continuations.snap
new file mode 100644
index 0000000..169588d
--- /dev/null
+++ b/tests/snapshots/markdown_checklists__markdown_preview_wraps_checklist_continuations.snap
@@ -0,0 +1,18 @@
+---
+source: tests/markdown_checklists.rs
+expression: result
+---
+╭[0] Title───────────────────────╮
+│                                │
+╰────────────────────────────────╯
+╭Labels (comma-separated)────────╮
+│                                │
+╰────────────────────────────────╯
+╭Assignees (comma-separated)─────╮
+│                                │
+╰────────────────────────────────╯
+Preview (Ctrl+P: Edit | Ctrl+Enter
+   [ ] a very long checklist      
+       item that should wrap      
+       onto the next rendered     
+       line

From 57f3aa670f0e6a481daadb2a2457055dc7c6b679 Mon Sep 17 00:00:00 2001
From: Jayan Sunil <73993003+JayanAXHF@users.noreply.github.com>
Date: Fri, 20 Mar 2026 18:10:25 +0530
Subject: [PATCH 3/3] chore: release

---
 CHANGELOG.md                      | 17 +++++++++++++++++
 Cargo.lock                        |  4 ++--
 Cargo.toml                        |  4 ++--
 crates/ratatui-toaster/Cargo.toml |  2 +-
 4 files changed, 22 insertions(+), 5 deletions(-)

diff --git a/CHANGELOG.md b/CHANGELOG.md
index a35e738..379fd7b 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -6,6 +6,23 @@ The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.0.0/),
 and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
 
 ## [Unreleased]
+
+## [0.3.5](https://github.com/JayanAXHF/gitv/compare/gitv-tui-v0.3.4...gitv-tui-v0.3.5) - 2026-03-20
+
+### <!-- 0 -->Features
+
+- *(preview pane)* Add a small issue list preview when in issue conversation
+- *(style)* Revamp the entire UI to have less borders and distractions
+
+### <!-- 1 -->Bug Fixes
+
+- *(md)* fixed checklist rendering
+
+### <!-- 10 -->Other
+
+- cleanup fix(changelog): streamline changelog config in release-plz.toml
+- Add dependabot.yml
+- bump flake.lock, fix nitpick in drv, add .envrc
 ## [0.3.4] - 2026-03-08
 
 ### Bug Fixes
diff --git a/Cargo.lock b/Cargo.lock
index 0bb4c30..827907b 100644
--- a/Cargo.lock
+++ b/Cargo.lock
@@ -1464,7 +1464,7 @@ dependencies = [
 
 [[package]]
 name = "gitv-tui"
-version = "0.3.4"
+version = "0.3.5"
 dependencies = [
  "anyhow",
  "async-trait",
@@ -4010,7 +4010,7 @@ dependencies = [
 
 [[package]]
 name = "ratatui-toaster"
-version = "0.1.1"
+version = "0.1.2"
 dependencies = [
  "anyhow",
  "ratatui",
diff --git a/Cargo.toml b/Cargo.toml
index 3fe292d..3405148 100644
--- a/Cargo.toml
+++ b/Cargo.toml
@@ -1,6 +1,6 @@
 [package]
 name = "gitv-tui"
-version = "0.3.4"
+version = "0.3.5"
 edition = "2024"
 build = "build.rs"
 description = "A terminal-based GitHub client built with Rust and Ratatui."
@@ -39,7 +39,7 @@ rat-cursor = "2.0.0"
 rat-widget = "3.2.1"
 ratatui = {version = "0.30.0", features = ["unstable-widget-ref"] }
 ratatui-macros = "0.7.0"
-ratatui-toaster = { path = "crates/ratatui-toaster", version = "0.1.1", features = ["tokio"] }
+ratatui-toaster = { path = "crates/ratatui-toaster", version = "0.1.2", features = ["tokio"] }
 termprofile = { version = "0.2.0", features = ["convert", "ratatui"] }
 textwrap = { version = "0.16.2", features = ["terminal_size"] }
 thiserror = "2.0.18"
diff --git a/crates/ratatui-toaster/Cargo.toml b/crates/ratatui-toaster/Cargo.toml
index c3a7f41..3864fa8 100644
--- a/crates/ratatui-toaster/Cargo.toml
+++ b/crates/ratatui-toaster/Cargo.toml
@@ -1,7 +1,7 @@
 [package]
 name = "ratatui-toaster"
 description = "An extremely lightweight toast engine for ratatui"
-version = "0.1.1"
+version = "0.1.2"
 edition = "2024"
 authors = ["JayanAXHF <sunil.chdry@gmail.com>"]
 license = "Unlicense OR MIT"