Implement chat and markdown views, enhance status bar, and add workflow panel

- Added `chat.rs` for rendering chat messages with timestamps and roles. - Introduced `markdown.rs` for rendering markdown content with styling. - Created `status.rs` to display the application status bar with session and message counts. - Developed `workflow.rs` to show the current workflow status, including tool calls and active jobs. - Established a `theme.rs` for centralized color management across the UI. - Updated `mod.rs` to include new modules and manage rendering logic.
2026-07-11 13:16:10 +07:00
parent 7cb4ae6708
commit cc03bd79b6
131 changed files with 10994 additions and 0 deletions
@@ -0,0 +1,46 @@
+use rusqlite::{Connection, params};
+use anyhow::Result;
+
+pub fn store_blob(conn: &Connection, session_id: &str, blob_key: &str, data: &[u8], mime_type: Option<&str>) -> Result<()> {
+    let created_at = chrono::Utc::now().timestamp_millis();
+    conn.execute(
+        "INSERT OR REPLACE INTO blobs (session_id, blob_key, data, mime_type, created_at) VALUES (?1, ?2, ?3, ?4, ?5)",
+        params![session_id, blob_key, data, mime_type, created_at],
+    )?;
+    Ok(())
+}
+
+pub fn retrieve_blob(conn: &Connection, session_id: &str, blob_key: &str) -> Result<Option<Vec<u8>>> {
+    let result = conn.query_row(
+        "SELECT data FROM blobs WHERE session_id = ?1 AND blob_key = ?2",
+        params![session_id, blob_key],
+        |row| row.get(0),
+    );
+    match result {
+        Ok(data) => Ok(Some(data)),
+        Err(rusqlite::Error::QueryReturnedNoRows) => Ok(None),
+        Err(e) => Err(e.into()),
+    }
+}
+
+pub fn delete_blob(conn: &Connection, session_id: &str, blob_key: &str) -> Result<bool> {
+    let rows = conn.execute(
+        "DELETE FROM blobs WHERE session_id = ?1 AND blob_key = ?2",
+        params![session_id, blob_key],
+    )?;
+    Ok(rows > 0)
+}
+
+pub fn list_blob_keys(conn: &Connection, session_id: &str) -> Result<Vec<String>> {
+    let mut stmt = conn.prepare(
+        "SELECT blob_key FROM blobs WHERE session_id = ?1 ORDER BY created_at ASC"
+    )?;
+    let rows = stmt.query_map(params![session_id], |row| {
+        row.get::<_, String>(0)
+    })?;
+    let mut keys = Vec::new();
+    for row in rows {
+        keys.push(row?);
+    }
+    Ok(keys)
+}
@@ -0,0 +1,4 @@
+pub mod blobs;
+pub mod query;
+pub mod schema;
+pub mod summary;
@@ -0,0 +1,68 @@
+use rusqlite::{Connection, params};
+use anyhow::Result;
+use crate::dto::chat::message::{ChatMessage, Role};
+
+pub fn insert_message(conn: &Connection, session_id: &str, msg: &ChatMessage) -> Result<i64> {
+    let content = msg.content.as_deref();
+    let tool_call_id = msg.tool_call_id.as_deref();
+    let tool_name = msg.name.as_deref();
+    let tool_arguments = msg.tool_calls.as_ref().map(|calls| {
+        serde_json::to_string(calls).unwrap_or_default()
+    });
+    let created_at = chrono::Utc::now().timestamp_millis();
+    let role_str = match msg.role {
+        Role::User => "user",
+        Role::Assistant => "assistant",
+        Role::System => "system",
+        Role::Tool => "tool",
+    };
+    conn.execute(
+        "INSERT INTO messages (session_id, role, content, tool_call_id, tool_name, tool_arguments, created_at) VALUES (?1, ?2, ?3, ?4, ?5, ?6, ?7)",
+        params![session_id, role_str, content, tool_call_id, tool_name, tool_arguments, created_at],
+    )?;
+    Ok(conn.last_insert_rowid())
+}
+
+pub fn query_messages(conn: &Connection, session_id: &str, limit: usize, offset: usize) -> Result<Vec<ChatMessage>> {
+    let mut stmt = conn.prepare(
+        "SELECT role, content, tool_call_id, tool_name, tool_arguments FROM messages WHERE session_id = ?1 ORDER BY id ASC LIMIT ?2 OFFSET ?3"
+    )?;
+    let rows = stmt.query_map(params![session_id, limit as i64, offset as i64], |row| {
+        let role_str: String = row.get(0)?;
+        let content: Option<String> = row.get(1)?;
+        let tool_call_id: Option<String> = row.get(2)?;
+        let tool_name: Option<String> = row.get(3)?;
+        let tool_arguments: Option<String> = row.get(4)?;
+        let role = match role_str.as_str() {
+            "user" => Role::User,
+            "assistant" => Role::Assistant,
+            "system" => Role::System,
+            "tool" => Role::Tool,
+            _ => Role::User,
+        };
+        let tool_calls = tool_arguments.and_then(|args| {
+            serde_json::from_str(&args).ok()
+        });
+        Ok(ChatMessage {
+            role,
+            content,
+            tool_calls,
+            tool_call_id,
+            name: tool_name,
+        })
+    })?;
+    let mut messages = Vec::new();
+    for row in rows {
+        messages.push(row?);
+    }
+    Ok(messages)
+}
+
+pub fn count_messages(conn: &Connection, session_id: &str) -> Result<i64> {
+    let count: i64 = conn.query_row(
+        "SELECT COUNT(*) FROM messages WHERE session_id = ?1",
+        params![session_id],
+        |row| row.get(0),
+    )?;
+    Ok(count)
+}
@@ -0,0 +1,47 @@
+use rusqlite::Connection;
+use anyhow::Result;
+
+pub fn init_schema(conn: &Connection) -> Result<()> {
+    conn.execute_batch(
+        "
+        CREATE TABLE IF NOT EXISTS messages (
+            id INTEGER PRIMARY KEY AUTOINCREMENT,
+            session_id TEXT NOT NULL,
+            role TEXT NOT NULL,
+            content TEXT,
+            tool_call_id TEXT,
+            tool_name TEXT,
+            tool_arguments TEXT,
+            created_at INTEGER NOT NULL,
+            FOREIGN KEY (session_id) REFERENCES archives(session_id)
+        );
+
+        CREATE TABLE IF NOT EXISTS archives (
+            id INTEGER PRIMARY KEY AUTOINCREMENT,
+            session_id TEXT NOT NULL UNIQUE,
+            title TEXT,
+            model TEXT,
+            created_at INTEGER NOT NULL,
+            updated_at INTEGER NOT NULL,
+            message_count INTEGER DEFAULT 0,
+            token_count INTEGER DEFAULT 0,
+            summary TEXT
+        );
+
+        CREATE INDEX IF NOT EXISTS idx_messages_session_id ON messages(session_id);
+        CREATE INDEX IF NOT EXISTS idx_messages_created_at ON messages(created_at);
+        CREATE INDEX IF NOT EXISTS idx_archives_created_at ON archives(created_at);
+
+        CREATE TABLE IF NOT EXISTS blobs (
+            id INTEGER PRIMARY KEY AUTOINCREMENT,
+            session_id TEXT NOT NULL,
+            blob_key TEXT NOT NULL,
+            data BLOB NOT NULL,
+            mime_type TEXT,
+            created_at INTEGER NOT NULL,
+            UNIQUE(session_id, blob_key)
+        );
+        "
+    )?;
+    Ok(())
+}
@@ -0,0 +1,40 @@
+use serde::{Deserialize, Serialize};
+
+#[derive(Debug, Clone, Serialize, Deserialize)]
+pub struct SummaryRecord {
+    pub session_id: String,
+    pub title: String,
+    pub model: String,
+    pub message_count: usize,
+    pub token_count: usize,
+    pub summary: String,
+    pub created_at: i64,
+    pub updated_at: i64,
+}
+
+impl SummaryRecord {
+    pub fn new(session_id: String, title: String, model: String) -> Self {
+        let now = chrono::Utc::now().timestamp_millis();
+        SummaryRecord {
+            session_id,
+            title,
+            model,
+            message_count: 0,
+            token_count: 0,
+            summary: String::new(),
+            created_at: now,
+            updated_at: now,
+        }
+    }
+
+    pub fn update_summary(&mut self, summary: String) {
+        self.summary = summary;
+        self.updated_at = chrono::Utc::now().timestamp_millis();
+    }
+
+    pub fn increment_counts(&mut self, messages: usize, tokens: usize) {
+        self.message_count += messages;
+        self.token_count += tokens;
+        self.updated_at = chrono::Utc::now().timestamp_millis();
+    }
+}