feat: display errors on cli (#123)

Co-authored-by: Tushar Mathur <tusharmath@gmail.com>

Author: laststylebender14

crates/forge_main/src/lib.rs

@@ -5,4 +5,4 @@ pub mod status;
 
 pub use console::CONSOLE;
 pub use input::UserInput;
-pub use status::{StatusDisplay, StatusKind};
+pub use status::StatusDisplay;

crates/forge_main/src/main.rs

@@ -1,8 +1,7 @@
 use anyhow::Result;
-use chrono::Local;
 use clap::Parser;
 use forge_domain::{ChatRequest, ChatResponse, ModelId};
-use forge_main::{StatusDisplay, StatusKind, UserInput, CONSOLE};
+use forge_main::{StatusDisplay, UserInput, CONSOLE};
 use forge_server::API;
 use tokio_stream::StreamExt;
 
@@ -13,10 +12,6 @@ struct Cli {
     verbose: bool,
 }
 
-fn get_timestamp() -> String {
-    Local::now().format("%H:%M:%S%.3f").to_string()
-}
-
 #[tokio::main]
 async fn main() -> Result<()> {
     let cli = Cli::parse();
@@ -49,75 +44,62 @@ async fn main() -> Result<()> {
             conversation_id: current_conversation_id,
         };
 
-        let mut stream = api
-            .chat(chat)
-            .await
-            .map_err(|e| anyhow::anyhow!("Failed to start chat stream: {}", e))?;
-
-        while let Some(message) = stream.next().await {
-            let message = message.map_err(|e| anyhow::anyhow!("Stream error: {}", e))?;
-            match message {
-                ChatResponse::Text(text) => {
-                    CONSOLE.write(&text)?;
-                }
-                ChatResponse::ToolCallDetected(_) => {}
-                ChatResponse::ToolCallArgPart(arg) => {
-                    if cli.verbose {
-                        CONSOLE.write(&arg)?;
-                    }
-                }
-                ChatResponse::ToolCallStart(tool_call_full) => {
-                    let tool_name = tool_call_full.name.as_str();
-                    let status = StatusDisplay {
-                        kind: StatusKind::Execute,
-                        message: tool_name,
-                        timestamp: Some(get_timestamp()),
-                        error_details: None,
-                    };
-                    CONSOLE.newline()?;
-                    CONSOLE.writeln(status.format())?;
-                }
-                ChatResponse::ToolCallEnd(tool_result) => {
-                    if cli.verbose {
-                        CONSOLE.writeln(tool_result.to_string())?;
-                    }
-                    let tool_name = tool_result.name.as_str();
-                    let status = if tool_result.is_error {
-                        StatusDisplay {
-                            kind: StatusKind::Failed,
-                            message: tool_name,
-                            timestamp: Some(get_timestamp()),
-                            error_details: Some("error"),
-                        }
-                    } else {
-                        StatusDisplay {
-                            kind: StatusKind::Success,
-                            message: tool_name,
-                            timestamp: Some(get_timestamp()),
-                            error_details: None,
+        match api.chat(chat).await {
+            Ok(mut stream) => {
+                while let Some(message) = stream.next().await {
+                    match message {
+                        Ok(message) => match message {
+                            ChatResponse::Text(text) => {
+                                CONSOLE.write(&text)?;
+                            }
+                            ChatResponse::ToolCallDetected(_) => {}
+                            ChatResponse::ToolCallArgPart(arg) => {
+                                if cli.verbose {
+                                    CONSOLE.write(&arg)?;
+                                }
+                            }
+                            ChatResponse::ToolCallStart(tool_call_full) => {
+                                let tool_name = tool_call_full.name.as_str();
+                                CONSOLE.newline()?;
+                                CONSOLE.writeln(StatusDisplay::execute(tool_name).format())?;
+                            }
+                            ChatResponse::ToolCallEnd(tool_result) => {
+                                if cli.verbose {
+                                    CONSOLE.writeln(tool_result.to_string())?;
+                                }
+                                let tool_name = tool_result.name.as_str();
+                                let status = if tool_result.is_error {
+                                    StatusDisplay::failed(tool_name)
+                                } else {
+                                    StatusDisplay::success(tool_name)
+                                };
+                                CONSOLE.write(status.format())?;
+                            }
+                            ChatResponse::ConversationStarted(conversation_id) => {
+                                current_conversation_id = Some(conversation_id);
+                            }
+                            ChatResponse::ModifyContext(_) => {}
+                            ChatResponse::Complete => {}
+                            ChatResponse::Error(err) => {
+                                CONSOLE.writeln(StatusDisplay::failed(err.to_string()).format())?;
+                            }
+                            ChatResponse::PartialTitle(_) => {}
+                            ChatResponse::CompleteTitle(title) => {
+                                CONSOLE.writeln(StatusDisplay::title(title).format())?;
+                            }
+                            ChatResponse::FinishReason(_) => {}
+                        },
+                        Err(err) => {
+                            CONSOLE.writeln(StatusDisplay::failed(err.to_string()).format())?;
                         }
-                    };
-                    CONSOLE.write(status.format())?;
-                }
-                ChatResponse::ConversationStarted(conversation_id) => {
-                    current_conversation_id = Some(conversation_id);
-                }
-                ChatResponse::ModifyContext(_) => {}
-                ChatResponse::Complete => {}
-                ChatResponse::Error(err) => {
-                    return Err(anyhow::anyhow!("Chat error: {:?}", err));
-                }
-                ChatResponse::PartialTitle(_) => {}
-                ChatResponse::CompleteTitle(title) => {
-                    let status = StatusDisplay {
-                        kind: StatusKind::Title,
-                        message: &title,
-                        timestamp: Some(get_timestamp()),
-                        error_details: None,
-                    };
-                    CONSOLE.writeln(status.format())?;
+                    }
                 }
-                ChatResponse::FinishReason(_) => {}
+            }
+            Err(err) => {
+                CONSOLE.writeln(
+                    StatusDisplay::failed_with(err.to_string(), "Failed to establish chat stream")
+                        .format(),
+                )?;
             }
         }
 

crates/forge_main/src/status.rs

@@ -1,55 +1,102 @@
 use colored::Colorize;
 
-pub enum StatusKind {
+#[derive(Clone)]
+enum Kind {
     Execute,
     Success,
     Failed,
     Title,
 }
 
-impl StatusKind {
+impl Kind {
     fn icon(&self) -> &'static str {
         match self {
-            StatusKind::Execute => "⚙",
-            StatusKind::Success => "✓",
-            StatusKind::Failed => "✗",
-            StatusKind::Title => "◆",
+            Kind::Execute => "⚙",
+            Kind::Success => "✓",
+            Kind::Failed => "✗",
+            Kind::Title => "◆",
         }
     }
 
     fn label(&self) -> &'static str {
         match self {
-            StatusKind::Execute => "EXECUTE",
-            StatusKind::Success => "SUCCESS",
-            StatusKind::Failed => "FAILED",
-            StatusKind::Title => "TITLE",
+            Kind::Execute => "EXECUTE",
+            Kind::Success => "SUCCESS",
+            Kind::Failed => "FAILED",
+            Kind::Title => "TITLE",
         }
     }
 }
 
-pub struct StatusDisplay<'a> {
-    pub kind: StatusKind,
-    pub message: &'a str,
-    pub timestamp: Option<String>,
-    pub error_details: Option<&'a str>,
+#[derive(Clone)]
+pub struct StatusDisplay {
+    kind: Kind,
+    message: String,
+    error_details: Option<String>,
 }
 
-impl StatusDisplay<'_> {
+impl StatusDisplay {
+    /// Create a status for executing a tool
+    pub fn execute(message: impl Into<String>) -> Self {
+        Self {
+            kind: Kind::Execute,
+            message: message.into(),
+            error_details: None,
+        }
+    }
+
+    /// Create a success status
+    pub fn success(message: impl Into<String>) -> Self {
+        Self {
+            kind: Kind::Success,
+            message: message.into(),
+            error_details: None,
+        }
+    }
+
+    /// Create a failure status
+    pub fn failed(message: impl Into<String>) -> Self {
+        Self {
+            kind: Kind::Failed,
+            message: message.into(),
+            error_details: None,
+        }
+    }
+
+    /// Create a failure status with additional details
+    pub fn failed_with(message: impl Into<String>, details: impl Into<String>) -> Self {
+        Self {
+            kind: Kind::Failed,
+            message: message.into(),
+            error_details: Some(details.into()),
+        }
+    }
+
+    /// Create a title status
+    pub fn title(message: impl Into<String>) -> Self {
+        Self {
+            kind: Kind::Title,
+            message: message.into(),
+            error_details: None,
+        }
+    }
+
     pub fn format(&self) -> String {
         let (icon, label, message) = match self.kind {
-            StatusKind::Execute => (
+            Kind::Execute => (
                 self.icon().cyan(),
                 self.label().bold().cyan(),
                 format!("{} ...", self.message.bold().cyan()),
             ),
-            StatusKind::Success => (
+            Kind::Success => (
                 self.icon().green(),
                 self.label().bold().green(),
                 self.message.bold().green().to_string(),
             ),
-            StatusKind::Failed => {
+            Kind::Failed => {
                 let error_suffix = self
                     .error_details
+                    .as_ref()
                     .map(|e| format!(" ({})", e))
                     .unwrap_or_default();
                 (
@@ -58,25 +105,22 @@ impl StatusDisplay<'_> {
                     format!("{}{}", self.message.bold().red(), error_suffix.red()),
                 )
             }
-            StatusKind::Title => (
+            Kind::Title => (
                 self.icon().blue(),
                 self.label().bold().blue(),
                 self.message.bold().blue().to_string(),
             ),
         };
 
-        if let Some(timestamp) = &self.timestamp {
-            format!(
-                "{} {} {} {} {}",
-                timestamp.dimmed(),
-                icon,
-                label,
-                "▶".bold(),
-                message
-            )
-        } else {
-            format!("{} {} {} {}", icon, label, "▶".bold(), message)
-        }
+        let timestamp = chrono::Local::now().format("%H:%M:%S%.3f").to_string();
+        format!(
+            "{} {} {} {} {}",
+            timestamp.dimmed(),
+            icon,
+            label,
+            "▶".bold(),
+            message
+        )
     }
 
     fn icon(&self) -> &'static str {

crates/forge_server/src/prompts/coding/system.md

@@ -35,7 +35,7 @@ Critical Rules:
 4. Always provide clear and concise explanations for your actions.
 5. Always return raw text with original special characters.
 6. Confirm with the user before deleting existing tests if they are failing.
-7. Always run tests to validate your changes before asking the user for feedback.
+7. Always validate your changes by running tests.
 8. Always execute shell commands in non-interactive mode to ensure fail-fast behavior, preventing any user input prompts or execution delays.
 9. Leverage your tools to take feedback from the user and improve your responses.
 

crates/forge_server/src/prompts/title/system.md

@@ -1,27 +1,43 @@
-You are Code-Forge's Title Generation Expert. Your task is to analyze content and generate precise, impactful titles that capture the essence of the material.
-
-Input Format:
-Content will be provided within <content> XML tags.
-
-Requirements:
-1. Maximum 10 words
-2. Capture core message or functionality
-3. Use clear, technical language
-4. Avoid unnecessary words or marketing language
-5. Return ONLY the title, without any tags or explanations
-
-Analysis Process:
-1. Identify main technical concepts
-2. Extract key functionality or purpose
-3. Determine target audience
-4. Synthesize into concise title
-
-Example:
-input:
-<content>
-A function that processes log files, extracts error messages, and generates daily reports.
-</content>
-output:
-Log Processing Pipeline for Automated Error Report Generation
-
-Note: Focus on technical accuracy and clarity. Respond with ONLY the title text.
+You are Code-Forge's Title Generation Expert, tasked with analyzing technical content and generating precise, impactful titles that capture the essence of the material. Your goal is to create titles that are clear, informative, and tailored for a technical audience.
+
+Please follow these steps to generate an appropriate title:
+
+1. Analyze the content carefully, identifying the main technical concepts, key functionality, and purpose.
+2. Determine the likely target audience for this content.
+3. Synthesize your analysis into a concise title that meets the following requirements:
+   - Between 5 and 10 words in length
+   - Captures the core message or functionality
+   - Uses clear, technical language
+   - Avoids unnecessary words or marketing language
+
+Before providing your final title, wrap your thought process in <title_generation_process> tags. Follow these steps:
+
+1. List the main technical concepts you've identified.
+2. Describe the key functionality or purpose of the content.
+3. Specify the likely target audience.
+4. Generate 3-5 potential titles that meet the requirements.
+5. For each potential title, count the number of words by listing each word with a number (e.g., 1. Title 2. Word 3. Count).
+6. Evaluate each title based on how well it captures the core message and uses appropriate technical language.
+7. Select the best title and explain your choice.
+
+After your analysis, provide only the final title without any additional explanation or tags.
+
+Example output structure:
+
+<title_generation_process>
+
+1. Main technical concepts: [List identified concepts]
+2. Key functionality: [Describe the primary function]
+3. Target audience: [Specify the likely audience]
+4. Potential titles:
+   - Title 1: [List with word count]
+   - Title 2: [List with word count]
+   - Title 3: [List with word count]
+5. Evaluation: [Brief evaluation of each title]
+6. Selected title: [Explain your choice]
+
+</title_generation_process>
+
+[Your final title here, between 5-10 words]
+
+Remember, the final output should only contain the title itself, without any formatting or explanation.