feat: enhance proposal generation and synthesis handling; remove revision functionality

Author: gitcoder89431

crates/agentic-core/src/orchestrator.rs

@@ -28,31 +28,26 @@ You MUST generate EXACTLY 3 proposals about this query: "{query}"
 }
 "#;
 
-const REVISE_PROMPT: &str = r#"You are an expert prompt engineer. A user wants to revise a prompt proposal.
 
-Original Proposal: "{proposal}"
-User's Revision: "{revision}"
-
-Your task is to integrate the user's revision into the original proposal to create a new, single, improved prompt.
-The new prompt should be self-contained and ready to use.
-
-Format your response as a JSON object with a single key "proposal" which is a string.
-Example:
-{
-  "proposal": "This is the new, revised prompt."
+#[derive(Deserialize, Debug)]
+struct ProposalObject {
+    context: String,
+    question: String,
 }
-"#;
 
 #[derive(Deserialize, Debug)]
-struct ProposalsResponse {
-    proposals: Vec<String>,
+#[serde(untagged)]
+enum ProposalItem {
+    StringFormat(String),
+    ObjectFormat(ProposalObject),
 }
 
 #[derive(Deserialize, Debug)]
-struct ReviseResponse {
-    proposal: String,
+struct ProposalsResponse {
+    proposals: Vec<ProposalItem>,
 }
 
+
 pub async fn generate_proposals(
     query: &str,
     endpoint: &str,
@@ -72,7 +67,19 @@ pub async fn generate_proposals(
     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),
+            Ok(response) => {
+                let proposals = response
+                    .proposals
+                    .into_iter()
+                    .map(|item| match item {
+                        ProposalItem::StringFormat(s) => s,
+                        ProposalItem::ObjectFormat(obj) => {
+                            format!("{} - {}", obj.context, obj.question)
+                        }
+                    })
+                    .collect();
+                Ok(proposals)
+            }
             Err(e) => {
                 // Debug: Write the JSON we tried to parse
                 std::fs::write("/tmp/debug_json.txt", json_str).ok();
@@ -91,25 +98,3 @@ pub async fn generate_proposals(
     }
 }
 
-pub async fn revise_proposal(
-    proposal: &str,
-    revision: &str,
-    endpoint: &str,
-    model: &str,
-) -> Result<String, anyhow::Error> {
-    let prompt = REVISE_PROMPT
-        .replace("{proposal}", proposal)
-        .replace("{revision}", revision);
-    let response_str = call_local_model(endpoint, model, &prompt).await?;
-
-    // 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::<ReviseResponse>(json_str) {
-            Ok(response) => Ok(response.proposal),
-            Err(e) => Err(anyhow::anyhow!("Failed to parse revision JSON: {}", e)),
-        }
-    } else {
-        Err(anyhow::anyhow!("No JSON object found in model response"))
-    }
-}

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

@@ -32,7 +32,6 @@ pub enum AppMode {
     SelectingLocalModel,
     SelectingCloudModel,
     Orchestrating,
-    Revising,
     Complete,
     CoachingTip,
     // TODO: Add About mode
@@ -65,7 +64,6 @@ pub enum ValidationMessage {
 #[derive(Debug)]
 pub enum AgentMessage {
     ProposalsGenerated(Result<Vec<String>, anyhow::Error>),
-    RevisedProposalGenerated(Result<String, anyhow::Error>),
     CloudSynthesisComplete(Result<AtomicNote, CloudError>),
 }
 
@@ -122,6 +120,7 @@ pub struct App {
     models_per_page: usize,
     proposals: Vec<String>,
     current_proposal_index: usize,
+    original_user_query: String, // Store the user's original query for metadata
     final_prompt: String,
     cloud_response: Option<AtomicNote>,
     synthesis_scroll: u16,
@@ -150,6 +149,7 @@ impl App {
             models_per_page: 10, // Show 10 models per page
             proposals: Vec::new(),
             current_proposal_index: 0,
+            original_user_query: String::new(),
             final_prompt: String::new(),
             cloud_response: None,
             synthesis_scroll: 0,
@@ -238,8 +238,11 @@ impl App {
 
         frame.render_widget(proposals_paragraph, chunks[1]);
 
-        // Footer with controls
-        let footer_text = "[Enter] Synthesize | [E]dit Selected | [ESC] Cancel";
+        // Footer with controls - dynamic based on synthesis status
+        let footer_text = match self.agent_status {
+            AgentStatus::Searching => "⏳ Synthesizing... | [ESC] Cancel",
+            _ => "[Enter] Synthesize | [ESC] Cancel",
+        };
         let footer = Paragraph::new(footer_text)
             .alignment(Alignment::Center)
             .style(self.theme.ratatui_style(Element::Inactive));
@@ -457,16 +460,31 @@ impl App {
                 frame.render_widget(Clear, modal_area);
                 self.render_coaching_tip_modal(frame, modal_area);
             } else if self.mode == AppMode::Complete {
+                // Center the synthesis content for better visual balance
                 let content = if let Some(note) = &self.cloud_response {
                     // Clean display - only show the synthesis content, hide system metadata
                     Paragraph::new(note.body_text.as_str())
                         .style(self.theme.ratatui_style(Element::Text))
+                        .alignment(ratatui::prelude::Alignment::Center)
                 } else {
                     // This case should ideally not be reached if mode is Complete
                     Paragraph::new("Waiting for synthesis...")
                         .style(self.theme.ratatui_style(Element::Text))
+                        .alignment(ratatui::prelude::Alignment::Center)
                 };
 
+                // Create a centered area for the synthesis (70% width, centered vertically)
+                let main_area = app_chunks[1];
+                let synthesis_width = (main_area.width * 70 / 100).max(40).min(main_area.width);
+                let synthesis_height = 10; // Fixed height for the synthesis box
+                
+                let synthesis_area = Rect::new(
+                    main_area.x + (main_area.width.saturating_sub(synthesis_width)) / 2,
+                    main_area.y + (main_area.height.saturating_sub(synthesis_height)) / 2,
+                    synthesis_width,
+                    synthesis_height,
+                );
+
                 let block = Block::default()
                     .title(" Synthesis Complete ")
                     .borders(Borders::ALL)
@@ -477,7 +495,7 @@ impl App {
                     .wrap(Wrap { trim: true })
                     .scroll((self.synthesis_scroll, 0));
 
-                frame.render_widget(paragraph, app_chunks[1]);
+                frame.render_widget(paragraph, synthesis_area);
             } else {
                 render_chat(
                     frame,
@@ -604,19 +622,6 @@ impl App {
                 self.mode = AppMode::CoachingTip;
                 self.agent_status = AgentStatus::Ready;
             }
-            AgentMessage::RevisedProposalGenerated(Ok(proposal)) => {
-                self.proposals[self.current_proposal_index] = proposal;
-                self.mode = AppMode::Orchestrating;
-                self.agent_status = AgentStatus::Ready;
-            }
-            AgentMessage::RevisedProposalGenerated(Err(_e)) => {
-                self.coaching_tip = (
-                    "Local Model Error".to_string(),
-                    "The local model failed to revise the proposal. Check if it is running and configured correctly.".to_string(),
-                );
-                self.mode = AppMode::CoachingTip;
-                self.agent_status = AgentStatus::Ready;
-            }
             AgentMessage::CloudSynthesisComplete(Ok(response)) => {
                 self.cloud_response = Some(response);
                 self.mode = AppMode::Complete;
@@ -883,39 +888,22 @@ impl App {
                             }
                             KeyCode::Enter => {
                                 // Synthesize - send proposal to cloud for synthesis
-                                if let Some(proposal) =
-                                    self.proposals.get(self.current_proposal_index)
-                                {
-                                    self.final_prompt = proposal.clone();
-                                    self.handle_cloud_synthesis();
+                                // Rate limiting: only allow if not already processing
+                                if self.agent_status != AgentStatus::Searching {
+                                    if let Some(proposal) =
+                                        self.proposals.get(self.current_proposal_index)
+                                    {
+                                        self.final_prompt = proposal.clone();
+                                        self.handle_cloud_synthesis();
+                                    }
                                 }
                             }
-                            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 {
-                            KeyCode::Enter => {
-                                self.handle_revision();
-                            }
-                            KeyCode::Esc => {
-                                self.mode = AppMode::Orchestrating;
-                                self.edit_buffer.clear();
-                            }
-                            KeyCode::Backspace => {
-                                self.edit_buffer.pop();
-                            }
-                            KeyCode::Char(c) => {
-                                self.edit_buffer.push(c);
+                                self.original_user_query.clear();
                             }
                             _ => {}
                         },
@@ -927,6 +915,7 @@ impl App {
                                 self.final_prompt.clear();
                                 self.proposals.clear();
                                 self.current_proposal_index = 0;
+                                self.original_user_query.clear();
                                 self.cloud_response = None;
                                 self.synthesis_scroll = 0;
                                 self.agent_status = AgentStatus::Ready;
@@ -937,6 +926,7 @@ impl App {
                                 self.final_prompt.clear();
                                 self.proposals.clear();
                                 self.current_proposal_index = 0;
+                                self.original_user_query.clear();
                                 self.cloud_response = None;
                                 self.synthesis_scroll = 0;
                                 self.agent_status = AgentStatus::Ready;
@@ -980,6 +970,9 @@ impl App {
             self.handle_slash_command(&message);
         } else {
             // Handle regular chat message
+            // Store the original user query for metadata
+            self.original_user_query = message.clone();
+            
             self.agent_status = AgentStatus::Orchestrating;
             let settings = self.settings.clone();
             let tx = self.agent_tx.clone();
@@ -998,31 +991,18 @@ impl App {
         self.edit_buffer.clear();
     }
 
-    fn handle_revision(&mut self) {
-        let revision = self.edit_buffer.trim().to_string();
-        if let Some(current_proposal) = self.proposals.get(self.current_proposal_index).cloned() {
-            self.agent_status = AgentStatus::Orchestrating;
-            let settings = self.settings.clone();
-            let tx = self.agent_tx.clone();
-            tokio::spawn(async move {
-                let result = orchestrator::revise_proposal(
-                    &current_proposal,
-                    &revision,
-                    &settings.endpoint,
-                    &settings.local_model,
-                )
-                .await;
-                let _ = tx.send(AgentMessage::RevisedProposalGenerated(result));
-            });
-        }
-        self.edit_buffer.clear();
-    }
 
     fn save_synthesis(&self) {
         if let Some(note) = &self.cloud_response {
-            // Generate markdown content with v0.1.0 metadata structure
-            let timestamp = chrono::Utc::now().format("%Y-%m-%d_%H-%M-%S").to_string();
-            let filename = format!("synthesis_{}.md", timestamp);
+            // Generate meaningful filename from query and metadata
+            let timestamp = chrono::Utc::now();
+            let date_part = timestamp.format("%Y-%m-%d").to_string();
+            
+            // Extract keywords from original user query for filename
+            let keywords = self.extract_filename_keywords(&self.original_user_query, &note.header_tags);
+            let time_suffix = timestamp.format("-%H%M").to_string(); // Add time for uniqueness
+            
+            let filename = format!("{}-{}{}.md", date_part, keywords, time_suffix);
 
             // Get the selected proposal text
             let proposal_text = if !self.proposals.is_empty()
@@ -1044,7 +1024,7 @@ impl App {
                 } else {
                     &self.settings.cloud_model
                 },
-                self.final_prompt.replace("\"", "\\\""),
+                self.original_user_query.replace("\"", "\\\""),
                 clean_proposal.replace("\"", "\\\""),
                 note.header_tags.iter().map(|tag| format!("\"{}\"", tag)).collect::<Vec<_>>().join(", "),
                 note.header_tags.join(" • "),
@@ -1229,4 +1209,55 @@ impl App {
         let target_page = self.selected_model_index / self.models_per_page;
         self.current_page = target_page;
     }
+
+    fn extract_filename_keywords(&self, query: &str, meta_tags: &[String]) -> String {
+        // Common words to filter out
+        let stop_words = [
+            "the", "a", "an", "and", "or", "but", "in", "on", "at", "to", "for", "of", "with",
+            "by", "is", "are", "was", "were", "be", "been", "have", "has", "had", "do", "does",
+            "did", "will", "would", "could", "should", "can", "what", "where", "when", "why",
+            "how", "who", "which", "that", "this", "these", "those", "i", "you", "he", "she",
+            "it", "we", "they", "me", "him", "her", "us", "them", "my", "your", "his", "her",
+            "its", "our", "their"
+        ];
+
+        // Extract meaningful words from query
+        let query_words: Vec<String> = query
+            .to_lowercase()
+            .split_whitespace()
+            .filter_map(|word| {
+                // Clean up punctuation
+                let clean_word = word.trim_matches(|c: char| !c.is_alphanumeric());
+                
+                // Filter out stop words and short words
+                if clean_word.len() >= 3 && !stop_words.contains(&clean_word) {
+                    Some(clean_word.to_string())
+                } else {
+                    None
+                }
+            })
+            .take(3) // Limit to 3 keywords from query
+            .collect();
+
+        // If we got good keywords from query, use them
+        if query_words.len() >= 2 {
+            query_words.join("-")
+        } else {
+            // Fallback to first meta tag if query didn't provide enough keywords
+            if let Some(first_tag) = meta_tags.first() {
+                first_tag
+                    .to_lowercase()
+                    .replace(' ', "-")
+                    .chars()
+                    .filter(|c| c.is_alphanumeric() || *c == '-')
+                    .collect::<String>()
+                    .trim_matches('-')
+                    .to_string()
+            } else {
+                // Final fallback
+                "synthesis".to_string()
+            }
+        }
+    }
+
 }