feat(dashboard): added dashboard content and features (#7)

Co-authored-by: Sharang Parnerkar <parnerkarsharang@gmail.com>
Reviewed-on: #7

src/infrastructure/llm.rs

@@ -0,0 +1,324 @@
+use dioxus::prelude::*;
+
+#[cfg(feature = "server")]
+mod inner {
+    use serde::{Deserialize, Serialize};
+
+    /// A single message in the OpenAI-compatible chat format used by Ollama.
+    #[derive(Serialize)]
+    pub(super) struct ChatMessage {
+        pub role: String,
+        pub content: String,
+    }
+
+    /// Request body for Ollama's OpenAI-compatible chat completions endpoint.
+    #[derive(Serialize)]
+    pub(super) struct OllamaChatRequest {
+        pub model: String,
+        pub messages: Vec<ChatMessage>,
+        /// Disable streaming so we get a single JSON response.
+        pub stream: bool,
+    }
+
+    /// A single choice in the Ollama chat completions response.
+    #[derive(Deserialize)]
+    pub(super) struct ChatChoice {
+        pub message: ChatResponseMessage,
+    }
+
+    /// The assistant message returned inside a choice.
+    #[derive(Deserialize)]
+    pub(super) struct ChatResponseMessage {
+        pub content: String,
+    }
+
+    /// Top-level response from Ollama's `/v1/chat/completions` endpoint.
+    #[derive(Deserialize)]
+    pub(super) struct OllamaChatResponse {
+        pub choices: Vec<ChatChoice>,
+    }
+
+    /// Fetch the full text content of a webpage by downloading its HTML
+    /// and extracting the main article body, skipping navigation, headers,
+    /// footers, and sidebars.
+    ///
+    /// Uses a tiered extraction strategy:
+    /// 1. Try content within `<article>`, `<main>`, or `[role="main"]`
+    /// 2. Fall back to all `<p>` tags outside excluded containers
+    ///
+    /// # Arguments
+    ///
+    /// * `url` - The article URL to fetch
+    ///
+    /// # Returns
+    ///
+    /// The extracted text, or `None` if the fetch/parse fails.
+    /// Text is capped at 8000 characters to stay within LLM context limits.
+    pub(super) async fn fetch_article_text(url: &str) -> Option<String> {
+        let client = reqwest::Client::builder()
+            .timeout(std::time::Duration::from_secs(10))
+            .build()
+            .ok()?;
+
+        let resp = client
+            .get(url)
+            .header("User-Agent", "CERTifAI/1.0 (Article Summarizer)")
+            .send()
+            .await
+            .ok()?;
+
+        if !resp.status().is_success() {
+            return None;
+        }
+
+        let html = resp.text().await.ok()?;
+        let document = scraper::Html::parse_document(&html);
+
+        // Strategy 1: Extract from semantic article containers.
+        // Most news sites wrap the main content in <article>, <main>,
+        // or an element with role="main".
+        let article_selector = scraper::Selector::parse("article, main, [role='main']").ok()?;
+        let paragraph_sel = scraper::Selector::parse("p, h1, h2, h3, li").ok()?;
+
+        let mut text_parts: Vec<String> = Vec::with_capacity(64);
+
+        for container in document.select(&article_selector) {
+            for element in container.select(&paragraph_sel) {
+                collect_text_fragment(element, &mut text_parts);
+            }
+        }
+
+        // Strategy 2: If article containers yielded little text, fall back
+        // to all <p> tags that are NOT inside nav/header/footer/aside.
+        if joined_len(&text_parts) < 200 {
+            text_parts.clear();
+            let all_p = scraper::Selector::parse("p").ok()?;
+
+            // Tags whose descendants should be excluded from extraction
+            const EXCLUDED_TAGS: &[&str] = &["nav", "header", "footer", "aside", "script", "style"];
+
+            for element in document.select(&all_p) {
+                // Walk ancestors and skip if inside an excluded container.
+                // Checks tag names directly to avoid ego_tree version issues.
+                let inside_excluded = element.ancestors().any(|ancestor| {
+                    ancestor
+                        .value()
+                        .as_element()
+                        .is_some_and(|el| EXCLUDED_TAGS.contains(&el.name.local.as_ref()))
+                });
+                if !inside_excluded {
+                    collect_text_fragment(element, &mut text_parts);
+                }
+            }
+        }
+
+        let full_text = text_parts.join("\n\n");
+        if full_text.len() < 100 {
+            return None;
+        }
+
+        // Cap at 8000 chars to stay within reasonable LLM context
+        let truncated: String = full_text.chars().take(8000).collect();
+        Some(truncated)
+    }
+
+    /// Extract text from an HTML element and append it to the parts list
+    /// if it meets a minimum length threshold.
+    fn collect_text_fragment(element: scraper::ElementRef<'_>, parts: &mut Vec<String>) {
+        let text: String = element.text().collect::<Vec<_>>().join(" ");
+        let trimmed = text.trim().to_string();
+        // Skip very short fragments (nav items, buttons, etc.)
+        if trimmed.len() >= 30 {
+            parts.push(trimmed);
+        }
+    }
+
+    /// Sum the total character length of all collected text parts.
+    fn joined_len(parts: &[String]) -> usize {
+        parts.iter().map(|s| s.len()).sum()
+    }
+}
+
+/// Summarize an article using a local Ollama instance.
+///
+/// First attempts to fetch the full article text from the provided URL.
+/// If that fails (paywall, timeout, etc.), falls back to the search snippet.
+/// This mirrors how Perplexity fetches and reads source pages before answering.
+///
+/// # Arguments
+///
+/// * `snippet` - The search result snippet (fallback content)
+/// * `article_url` - The original article URL to fetch full text from
+/// * `ollama_url` - Base URL of the Ollama instance (e.g. "http://localhost:11434")
+/// * `model` - The Ollama model ID to use (e.g. "llama3.1:8b")
+///
+/// # Returns
+///
+/// A summary string generated by the LLM, or a `ServerFnError` on failure
+///
+/// # Errors
+///
+/// Returns `ServerFnError` if the Ollama request fails or response parsing fails
+#[server(endpoint = "/api/summarize")]
+pub async fn summarize_article(
+    snippet: String,
+    article_url: String,
+    ollama_url: String,
+    model: String,
+) -> Result<String, ServerFnError> {
+    dotenvy::dotenv().ok();
+    use inner::{fetch_article_text, ChatMessage, OllamaChatRequest, OllamaChatResponse};
+
+    // Fall back to env var or default if the URL is empty
+    let base_url = if ollama_url.is_empty() {
+        std::env::var("OLLAMA_URL").unwrap_or_else(|_| "http://localhost:11434".into())
+    } else {
+        ollama_url
+    };
+
+    // Fall back to env var or default if the model is empty
+    let model = if model.is_empty() {
+        std::env::var("OLLAMA_MODEL").unwrap_or_else(|_| "llama3.1:8b".into())
+    } else {
+        model
+    };
+
+    // Try to fetch the full article; fall back to the search snippet
+    let article_text = fetch_article_text(&article_url).await.unwrap_or(snippet);
+
+    let request_body = OllamaChatRequest {
+        model,
+        stream: false,
+        messages: vec![ChatMessage {
+            role: "user".into(),
+            content: format!(
+                "You are a news summarizer. Summarize the following article text \
+                 in 2-3 concise paragraphs. Focus only on the key points and \
+                 implications. Do NOT comment on the source, the date, the URL, \
+                 the formatting, or whether the content seems complete or not. \
+                 Just summarize whatever content is provided.\n\n\
+                 {article_text}"
+            ),
+        }],
+    };
+
+    let url = format!("{}/v1/chat/completions", base_url.trim_end_matches('/'));
+    let client = reqwest::Client::new();
+    let resp = client
+        .post(&url)
+        .header("content-type", "application/json")
+        .json(&request_body)
+        .send()
+        .await
+        .map_err(|e| ServerFnError::new(format!("Ollama request failed: {e}")))?;
+
+    if !resp.status().is_success() {
+        let status = resp.status();
+        let body = resp.text().await.unwrap_or_default();
+        return Err(ServerFnError::new(format!(
+            "Ollama returned {status}: {body}"
+        )));
+    }
+
+    let body: OllamaChatResponse = resp
+        .json()
+        .await
+        .map_err(|e| ServerFnError::new(format!("Failed to parse Ollama response: {e}")))?;
+
+    body.choices
+        .first()
+        .map(|choice| choice.message.content.clone())
+        .ok_or_else(|| ServerFnError::new("Empty response from Ollama"))
+}
+
+/// A lightweight chat message for the follow-up conversation.
+/// Uses simple String role ("system"/"user"/"assistant") for Ollama compatibility.
+#[derive(Debug, Clone, PartialEq, serde::Serialize, serde::Deserialize)]
+pub struct FollowUpMessage {
+    pub role: String,
+    pub content: String,
+}
+
+/// Send a follow-up question about an article using a local Ollama instance.
+///
+/// Accepts the full conversation history (system context + prior turns) and
+/// returns the assistant's next response. The system message should contain
+/// the article text and summary so the LLM has full context.
+///
+/// # Arguments
+///
+/// * `messages` - The conversation history including system context
+/// * `ollama_url` - Base URL of the Ollama instance
+/// * `model` - The Ollama model ID to use
+///
+/// # Returns
+///
+/// The assistant's response text, or a `ServerFnError` on failure
+///
+/// # Errors
+///
+/// Returns `ServerFnError` if the Ollama request fails or response parsing fails
+#[server(endpoint = "/api/chat")]
+pub async fn chat_followup(
+    messages: Vec<FollowUpMessage>,
+    ollama_url: String,
+    model: String,
+) -> Result<String, ServerFnError> {
+    dotenvy::dotenv().ok();
+    use inner::{ChatMessage, OllamaChatRequest, OllamaChatResponse};
+
+    let base_url = if ollama_url.is_empty() {
+        std::env::var("OLLAMA_URL").unwrap_or_else(|_| "http://localhost:11434".into())
+    } else {
+        ollama_url
+    };
+
+    let model = if model.is_empty() {
+        std::env::var("OLLAMA_MODEL").unwrap_or_else(|_| "llama3.1:8b".into())
+    } else {
+        model
+    };
+
+    // Convert FollowUpMessage to inner ChatMessage for the request
+    let chat_messages: Vec<ChatMessage> = messages
+        .into_iter()
+        .map(|m| ChatMessage {
+            role: m.role,
+            content: m.content,
+        })
+        .collect();
+
+    let request_body = OllamaChatRequest {
+        model,
+        stream: false,
+        messages: chat_messages,
+    };
+
+    let url = format!("{}/v1/chat/completions", base_url.trim_end_matches('/'));
+    let client = reqwest::Client::new();
+    let resp = client
+        .post(&url)
+        .header("content-type", "application/json")
+        .json(&request_body)
+        .send()
+        .await
+        .map_err(|e| ServerFnError::new(format!("Ollama request failed: {e}")))?;
+
+    if !resp.status().is_success() {
+        let status = resp.status();
+        let body = resp.text().await.unwrap_or_default();
+        return Err(ServerFnError::new(format!(
+            "Ollama returned {status}: {body}"
+        )));
+    }
+
+    let body: OllamaChatResponse = resp
+        .json()
+        .await
+        .map_err(|e| ServerFnError::new(format!("Failed to parse Ollama response: {e}")))?;
+
+    body.choices
+        .first()
+        .map(|choice| choice.message.content.clone())
+        .ok_or_else(|| ServerFnError::new("Empty response from Ollama"))
+}