feat: add Synthesize Knowledge modal for proposal selection and interaction

Author: gitcoder89431

crates/agentic-core/src/orchestrator.rs

@@ -1,21 +1,27 @@
 use crate::models::call_local_model;
 use serde::Deserialize;
 
-const ORCHESTRATOR_PROMPT: &str = r#"You are an expert prompt engineer. Your task is to help a user craft the perfect prompt for a powerful AI model.
-The user has provided the following query: "{query}"
+const ORCHESTRATOR_PROMPT: &str = r#"You are Ruixen, an inquisitive AI partner. Your job is to analyze the user's request and deconstruct it into three distinct lines of inquiry.
 
-Analyze the user's query and generate three distinct proposals for a better prompt.
-Each proposal should be a self-contained, ready-to-use prompt.
-Use the 5W method (What, Who, When, Where, How) to explore different angles of the user's request.
-Rank the proposals by your internal confidence, from least confident to most confident.
+**Your Persona and Tone:**
+- Your tone should be that of a collaborative partner.
+- Each proposal should have a context statement followed by a curious question.
+- Use phrases like "I wonder..." or "I'm wondering if..." for questions.
 
-Format your response as a JSON object with a single key "proposals" which is an array of three strings.
-Example:
+**The Query to Explore:**
+"{query}"
+
+**Output Format:**
+Generate exactly 3 proposals. Each proposal should be 2 sentences: a context statement followed by a curious question. Use a dash to separate them like this pattern:
+
+"Context statement here - I wonder about this question?"
+
+Your response must be valid JSON:
 {
   "proposals": [
-    "Proposal 1 (least confident)",
-    "Proposal 2 (medium confident)",
-    "Proposal 3 (most confident)"
+    "First context statement - I wonder about this?",
+    "Second context statement - I'm wondering if that?",
+    "Third context statement - I wonder about something else?"
   ]
 }
 "#;
@@ -51,17 +57,28 @@ pub async fn generate_proposals(
     model: &str,
 ) -> Result<Vec<String>, anyhow::Error> {
     let prompt = ORCHESTRATOR_PROMPT.replace("{query}", query);
+    
+    // Debug: Write the prompt to a file so we can see what's being sent
+    std::fs::write("/tmp/debug_prompt.txt", &prompt).ok();
+    
     let response_str = call_local_model(endpoint, model, &prompt).await?;
+    
+    // Debug: Write the response to a file so we can see what came back
+    std::fs::write("/tmp/debug_response.txt", &response_str).ok();
 
     // Attempt to find the start of the JSON object
     if let Some(json_start) = response_str.find("{") {
         let json_str = &response_str[json_start..];
         match serde_json::from_str::<ProposalsResponse>(json_str) {
             Ok(response) => Ok(response.proposals),
-            Err(e) => Err(anyhow::anyhow!("Failed to parse proposals JSON: {}", e)),
+            Err(e) => {
+                // Debug: Write the JSON we tried to parse
+                std::fs::write("/tmp/debug_json.txt", json_str).ok();
+                Err(anyhow::anyhow!("Failed to parse proposals JSON: {} | JSON: {}", e, json_str))
+            },
         }
     } else {
-        Err(anyhow::anyhow!("No JSON object found in model response"))
+        Err(anyhow::anyhow!("No JSON object found in model response: {}", response_str))
     }
 }
 

crates/agentic-tui/src/ui/app.rs

@@ -146,6 +146,100 @@ impl App {
         }
     }
 
+    fn render_synthesize_modal(&self, frame: &mut ratatui::Frame, area: Rect) {
+        use ratatui::{
+            prelude::Alignment,
+            text::{Line, Span},
+            widgets::Paragraph,
+        };
+
+        let block = Block::default()
+            .title(" Synthesize Knowledge ")
+            .borders(Borders::ALL)
+            .style(self.theme.ratatui_style(Element::Active));
+
+        let inner_area = block.inner(area);
+        frame.render_widget(block, area);
+
+        if self.proposals.is_empty() {
+            let loading = Paragraph::new("Generating proposals...")
+                .alignment(Alignment::Center)
+                .style(self.theme.ratatui_style(Element::Info));
+            frame.render_widget(loading, inner_area);
+            return;
+        }
+
+        // Header text
+        let header = Paragraph::new("Ruixen has a few lines of inquiry. Select the best one to pursue:")
+            .alignment(Alignment::Left)
+            .style(self.theme.ratatui_style(Element::Text))
+            .wrap(Wrap { trim: true });
+
+        // Split area: header + proposals + footer
+        let chunks = Layout::default()
+            .direction(Direction::Vertical)
+            .constraints([
+                Constraint::Length(3), // Header
+                Constraint::Min(6),    // Proposals (flexible)
+                Constraint::Length(3), // Footer
+            ])
+            .split(inner_area);
+
+        frame.render_widget(header, chunks[0]);
+
+        // Render proposals
+        let proposal_lines: Vec<Line> = self
+            .proposals
+            .iter()
+            .enumerate()
+            .flat_map(|(i, proposal)| {
+                let is_selected = i == self.current_proposal_index;
+                let prefix = if is_selected { "> " } else { "  " };
+                let number = format!("{}. ", i + 1);
+                
+                // Split proposal into sentences (max 2) and wrap
+                let sentences: Vec<&str> = proposal
+                    .split(". ")
+                    .take(2)
+                    .collect();
+                
+                let proposal_text = if sentences.len() > 1 {
+                    format!("{} {}", sentences[0], sentences.get(1).unwrap_or(&""))
+                } else {
+                    proposal.clone()
+                };
+
+                let style = if is_selected {
+                    self.theme.ratatui_style(Element::Accent)
+                } else {
+                    self.theme.ratatui_style(Element::Text)
+                };
+
+                vec![
+                    Line::from(vec![
+                        Span::styled(format!("{}{}", prefix, number), style),
+                        Span::styled(proposal_text, style),
+                    ]),
+                    Line::from(""), // Empty line between proposals
+                ]
+            })
+            .collect();
+
+        let proposals_paragraph = Paragraph::new(proposal_lines)
+            .style(self.theme.ratatui_style(Element::Text))
+            .wrap(Wrap { trim: true });
+
+        frame.render_widget(proposals_paragraph, chunks[1]);
+
+        // Footer with controls
+        let footer_text = "[Enter] Synthesize | [E]dit Selected | [ESC] Cancel";
+        let footer = Paragraph::new(footer_text)
+            .alignment(Alignment::Center)
+            .style(self.theme.ratatui_style(Element::Inactive));
+
+        frame.render_widget(footer, chunks[2]);
+    }
+
     pub async fn run(&mut self, terminal: &mut Terminal<CrosstermBackend<Stdout>>) -> Result<()> {
         while !self.should_quit {
             self.draw(terminal)?;
@@ -283,15 +377,22 @@ impl App {
                     );
                 }
             } else if self.mode == AppMode::Orchestrating {
-                if let Some(proposal) = self.proposals.get(self.current_proposal_index) {
-                    let block = Block::default()
-                        .title("Proposal Stone")
-                        .borders(Borders::ALL);
-                    let paragraph = Paragraph::new(proposal.as_str())
-                        .block(block)
-                        .wrap(Wrap { trim: true });
-                    frame.render_widget(paragraph, app_chunks[1]);
-                }
+                // Render the Synthesize Knowledge modal
+                let size = frame.size();
+                let modal_width = (((size.width as f32) * 0.8).round() as u16)
+                    .clamp(50, 80)
+                    .min(size.width);
+                let modal_height = (((size.height as f32) * 0.6).round() as u16)
+                    .clamp(15, 25)
+                    .min(size.height);
+                let modal_area = Rect::new(
+                    (size.width.saturating_sub(modal_width)) / 2,
+                    (size.height.saturating_sub(modal_height)) / 2,
+                    modal_width,
+                    modal_height,
+                );
+                frame.render_widget(Clear, modal_area);
+                self.render_synthesize_modal(frame, modal_area);
             } else if self.mode == AppMode::Complete {
                 let block = Block::default().title("Final Prompt").borders(Borders::ALL);
                 let paragraph = Paragraph::new(self.final_prompt.as_str())
@@ -417,7 +518,6 @@ impl App {
                 self.agent_status = AgentStatus::Ready;
             }
             AgentMessage::ProposalsGenerated(Err(_e)) => {
-                // TODO: Set error state and display to user
                 self.agent_status = AgentStatus::Ready;
             }
             AgentMessage::RevisedProposalGenerated(Ok(proposal)) => {
@@ -659,24 +759,36 @@ impl App {
                             _ => {}
                         },
                         AppMode::Orchestrating => match key.code {
-                            KeyCode::Char('s') => {
+                            KeyCode::Up => {
+                                if self.current_proposal_index > 0 {
+                                    self.current_proposal_index -= 1;
+                                }
+                            }
+                            KeyCode::Down => {
+                                if self.current_proposal_index + 1 < self.proposals.len() {
+                                    self.current_proposal_index += 1;
+                                }
+                            }
+                            KeyCode::Enter => {
+                                // Synthesize - use selected proposal
                                 if let Some(proposal) =
                                     self.proposals.get(self.current_proposal_index)
                                 {
                                     self.final_prompt = proposal.clone();
                                     self.mode = AppMode::Complete;
                                 }
                             }
-                            KeyCode::Char('r') => {
-                                if !self.proposals.is_empty() {
-                                    self.current_proposal_index =
-                                        (self.current_proposal_index + 1) % self.proposals.len();
-                                }
-                            }
                             KeyCode::Char('e') => {
+                                // Edit selected proposal
                                 self.mode = AppMode::Revising;
                                 self.edit_buffer.clear();
                             }
+                            KeyCode::Esc => {
+                                // Cancel and return to normal mode
+                                self.mode = AppMode::Normal;
+                                self.proposals.clear();
+                                self.current_proposal_index = 0;
+                            }
                             _ => {}
                         },
                         AppMode::Revising => match key.code {