Added some tests at least for the broadcast buffering.

Cargo.lock

@@ -17,6 +17,15 @@ version = "2.0.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "320119579fcad9c21884f5c4861d16174d0e06250625266f50fe6898340abefa"
 
+[[package]]
+name = "aho-corasick"
+version = "1.1.4"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "ddd31a130427c27518df266943a5308ed92d4b226cc639f5a8f1002816174301"
+dependencies = [
+ "memchr",
+]
+
 [[package]]
 name = "android_system_properties"
 version = "0.1.5"
@@ -172,6 +181,12 @@ version = "1.10.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "d71b6127be86fdcfddb610f7182ac57211d4b18a3e9c82eb2d17662f2227ad6a"
 
+[[package]]
+name = "cargo-husky"
+version = "1.5.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "7b02b629252fe8ef6460461409564e2c21d0c8e77e0944f3d189ff06c4e932ad"
+
 [[package]]
 name = "cc"
 version = "1.2.43"
@@ -858,6 +873,12 @@ version = "0.32.3"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "e629b9b98ef3dd8afe6ca2bd0f89306cec16d43d907889945bc5d6687f2f13c7"
 
+[[package]]
+name = "glob"
+version = "0.3.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "0cc23270f6e1808e30a928bdc84dea0b9b4136a8bc82338574f23baf47bbd280"
+
 [[package]]
 name = "hashbrown"
 version = "0.12.3"
@@ -1666,6 +1687,15 @@ dependencies = [
  "zerocopy",
 ]
 
+[[package]]
+name = "proc-macro-crate"
+version = "3.4.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "219cb19e96be00ab2e37d6e299658a0cfa83e52429179969b0f0121b4ac46983"
+dependencies = [
+ "toml_edit 0.23.7",
+]
+
 [[package]]
 name = "proc-macro2"
 version = "1.0.103"
@@ -1823,6 +1853,41 @@ dependencies = [
  "syn",
 ]
 
+[[package]]
+name = "regex"
+version = "1.12.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "843bc0191f75f3e22651ae5f1e72939ab2f72a4bc30fa80a066bd66edefc24d4"
+dependencies = [
+ "aho-corasick",
+ "memchr",
+ "regex-automata",
+ "regex-syntax",
+]
+
+[[package]]
+name = "regex-automata"
+version = "0.4.13"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "5276caf25ac86c8d810222b3dbb938e512c55c6831a10f3e6ed1c93b84041f1c"
+dependencies = [
+ "aho-corasick",
+ "memchr",
+ "regex-syntax",
+]
+
+[[package]]
+name = "regex-syntax"
+version = "0.8.8"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "7a2d987857b319362043e95f5353c0535c1f58eec5336fdfcf626430af7def58"
+
+[[package]]
+name = "relative-path"
+version = "1.9.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "ba39f3699c378cd8970968dcbff9c43159ea4cfbd88d43c00b22f2ef10a435d2"
+
 [[package]]
 name = "reqwest"
 version = "0.12.24"
@@ -1899,6 +1964,7 @@ name = "robotnik"
 version = "0.1.0"
 dependencies = [
  "better-panic",
+ "cargo-husky",
  "clap",
  "color-eyre",
  "config",
@@ -1907,6 +1973,9 @@ dependencies = [
  "genai",
  "human-panic",
  "irc",
+ "rstest",
+ "serde",
+ "serde_json",
  "tokio",
  "tracing",
  "tracing-subscriber",
@@ -1924,6 +1993,36 @@ dependencies = [
  "serde_derive",
 ]
 
+[[package]]
+name = "rstest"
+version = "0.24.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "03e905296805ab93e13c1ec3a03f4b6c4f35e9498a3d5fa96dc626d22c03cd89"
+dependencies = [
+ "futures-timer",
+ "futures-util",
+ "rstest_macros",
+ "rustc_version",
+]
+
+[[package]]
+name = "rstest_macros"
+version = "0.24.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "ef0053bbffce09062bee4bcc499b0fbe7a57b879f1efe088d6d8d4c7adcdef9b"
+dependencies = [
+ "cfg-if",
+ "glob",
+ "proc-macro-crate",
+ "proc-macro2",
+ "quote",
+ "regex",
+ "relative-path",
+ "rustc_version",
+ "syn",
+ "unicode-ident",
+]
+
 [[package]]
 name = "rust-ini"
 version = "0.21.3"
@@ -1946,6 +2045,15 @@ version = "2.1.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "357703d41365b4b27c590e3ed91eabb1b663f07c4c084095e60cbed4362dff0d"
 
+[[package]]
+name = "rustc_version"
+version = "0.4.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "cfcb3a22ef46e85b45de6ee7e79d063319ebb6594faafcf1c225ea92ab6e9b92"
+dependencies = [
+ "semver",
+]
+
 [[package]]
 name = "rustix"
 version = "1.1.2"
@@ -2068,6 +2176,12 @@ dependencies = [
  "libc",
 ]
 
+[[package]]
+name = "semver"
+version = "1.0.27"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "d767eb0aabc880b29956c35734170f26ed551a859dbd361d140cdbeca61ab1e2"
+
 [[package]]
 name = "serde"
 version = "1.0.228"
@@ -2487,7 +2601,7 @@ dependencies = [
  "serde",
  "serde_spanned 0.6.9",
  "toml_datetime 0.6.11",
- "toml_edit",
+ "toml_edit 0.19.15",
 ]
 
 [[package]]
@@ -2535,6 +2649,18 @@ dependencies = [
  "winnow 0.5.40",
 ]
 
+[[package]]
+name = "toml_edit"
+version = "0.23.7"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "6485ef6d0d9b5d0ec17244ff7eb05310113c3f316f2d14200d4de56b3cb98f8d"
+dependencies = [
+ "indexmap 2.12.0",
+ "toml_datetime 0.7.3",
+ "toml_parser",
+ "winnow 0.7.13",
+]
+
 [[package]]
 name = "toml_parser"
 version = "1.0.4"

Cargo.toml

@@ -4,24 +4,46 @@ version = "0.1.0"
 edition = "2024"
 
 [dependencies]
-# TODO: make this a dev and/or debug dependency later.
 better-panic = "0.3.0"
-clap = { version = "4.5", features = [ "derive" ] }
 color-eyre = "0.6.3"
-config = { version = "0.15", features = [ "toml" ] }
 directories = "6.0"
 futures = "0.3"
 human-panic = "2.0"
 genai = "0.4.3"
 irc = "1.1"
-tokio = { version = "1", features = [ "macros", "rt-multi-thread" ] }
+serde_json = "1.0"
 tracing = "0.1"
 tracing-subscriber = "0.3"
 
+  [dependencies.clap]
+  version = "4.5"
+  features = [ "derive" ]
+
+  [dependencies.config]
+  version = "0.15"
+  features = [ "toml" ]
+
+  [dependencies.serde]
+  version = "1.0"
+  features = [ "derive" ]
+
+  [dependencies.tokio]
+  version = "1"
+  features = [ "io-util", "macros", "net", "rt-multi-thread", "sync" ]
+
+[dev-dependencies]
+rstest = "0.24"
+
+  [dev-dependencies.cargo-husky]
+  version = "1"
+  features = [
+  "run-cargo-check",
+  "run-cargo-clippy",
+]
+
 [profile.release]
 strip = true
-opt-level = "z"   # Optimize for size
+opt-level = "z"
-lto = true        # Link-time optimization
+lto = true
 codegen-units = 1
-# Comment this if unwinding is needed.  Compiling without release works too. 
 panic = "abort"

rustfmt.toml

@@ -3,5 +3,5 @@ style_edition = "2024"
 comment_width = 100
 format_code_in_doc_comments = true
 imports_granularity = "Crate"
-imports_layout = "Vertical"
+imports_layout = "HorizontalVertical"
 wrap_comments = true

src/chat.rs

@@ -1,24 +1,10 @@
-use color_eyre::{
+use color_eyre::{Result, eyre::WrapErr};
-    Result,
-    eyre::{
-        OptionExt,
-        WrapErr,
-    },
-};
 // Lots of namespace confusion potential
 use crate::qna::LLMHandle;
 use config::Config as MainConfig;
 use futures::StreamExt;
-use irc::client::prelude::{
+use irc::client::prelude::{Client as IRCClient, Command, Config as IRCConfig};
-    Client as IRCClient,
+use tracing::{Level, event, instrument};
-    Command,
-    Config as IRCConfig,
-};
-use tracing::{
-    Level,
-    event,
-    instrument,
-};
 
 #[derive(Debug)]
 pub struct Chat {
@@ -73,7 +59,9 @@ impl Chat {
                 // Make it all one line.
                 msg.retain(|c| c != '\n' && c != '\r');
                 msg.truncate(500);
-                client.send_privmsg(&channel, msg).wrap_err("Could not send to {channel}")?;
+                client
+                    .send_privmsg(&channel, msg)
+                    .wrap_err("Could not send to {channel}")?;
             }
         }
 

src/commands.rs

@@ -1,8 +1,5 @@
 use color_eyre::Result;
-use std::path::{
+use std::path::{Path, PathBuf};
-    Path,
-    PathBuf,
-};
 
 #[derive(Clone, Debug)]
 pub struct Root {
@@ -16,7 +13,7 @@ impl Root {
         }
     }
 
-    pub fn run_command(cmd_string: impl AsRef<str>) -> Result<()> {
+    pub fn run_command(_cmd_string: impl AsRef<str>) -> Result<()> {
         todo!();
     }
 }

src/event.rs

@@ -0,0 +1,14 @@
+use serde::{Deserialize, Serialize};
+
+#[derive(Deserialize, Serialize)]
+pub struct Event {
+    message: String,
+}
+
+impl Event {
+    pub fn new(msg: impl Into<String>) -> Self {
+        Self {
+            message: msg.into(),
+        }
+    }
+}

src/event_manager.rs

@@ -0,0 +1,275 @@
+use std::{collections::VecDeque, path::Path, sync::Arc};
+
+use color_eyre::Result;
+use tokio::{
+    io::AsyncWriteExt,
+    net::{UnixListener, UnixStream},
+    sync::{RwLock, broadcast},
+};
+use tracing::{error, info};
+
+use crate::event::Event;
+
+// Hard coding for now.  Maybe make this a parameter to new.
+const EVENT_BUF_MAX: usize = 1000;
+
+// Manager for communication with plugins.
+pub struct EventManager {
+    announce: broadcast::Sender<String>, // Everything broadcasts here.
+    events: Arc<RwLock<VecDeque<String>>>, // Ring buffer.
+}
+
+impl EventManager {
+    pub fn new() -> Result<Self> {
+        let (announce, _) = broadcast::channel(100);
+
+        Ok(Self {
+            announce,
+            events: Arc::new(RwLock::new(VecDeque::<String>::new())),
+        })
+    }
+
+    pub async fn broadcast(&self, event: &Event) -> Result<()> {
+        let msg = serde_json::to_string(event)? + "\n";
+
+        let mut events = self.events.write().await;
+
+        if events.len() >= EVENT_BUF_MAX {
+            events.pop_front();
+        }
+
+        events.push_back(msg.clone());
+        drop(events);
+
+        let _ = self.announce.send(msg);
+
+        Ok(())
+    }
+
+    pub async fn start_listening(self: Arc<Self>, path: impl AsRef<Path>) {
+        let listener = UnixListener::bind(path).unwrap();
+
+        loop {
+            match listener.accept().await {
+                Ok((stream, _addr)) => {
+                    info!("New broadcast subscriber");
+                    // Spawn a new stream for the plugin.  The loop
+                    // runs recursively from there.
+                    let broadcaster = Arc::clone(&self);
+                    tokio::spawn(async move {
+                        // send events.
+                        let _ = broadcaster.send_events(stream).await;
+                    });
+                }
+                Err(e) => error!("Accept error: {e}"),
+            }
+        }
+    }
+
+    async fn send_events(&self, stream: UnixStream) -> Result<()> {
+        let mut writer = stream;
+
+        // Take care of history.
+        let events = self.events.read().await;
+        for event in events.iter() {
+            writer.write_all(event.as_bytes()).await?;
+        }
+        drop(events);
+
+        // Now just broadcast the new events.
+        let mut rx = self.announce.subscribe();
+        while let Ok(event) = rx.recv().await {
+            if writer.write_all(event.as_bytes()).await.is_err() {
+                // *click*
+                break;
+            }
+        }
+
+        Ok(())
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use rstest::rstest;
+
+    #[tokio::test]
+    async fn test_new_event_manager_has_empty_buffer() {
+        let manager = EventManager::new().unwrap();
+        let events = manager.events.read().await;
+        assert_eq!(events.len(), 0);
+    }
+
+    #[tokio::test]
+    async fn test_broadcast_adds_event_to_buffer() {
+        let manager = EventManager::new().unwrap();
+        let event = Event::new("test message");
+
+        manager.broadcast(&event).await.unwrap();
+
+        let events = manager.events.read().await;
+        assert_eq!(events.len(), 1);
+        assert!(events[0].contains("test message"));
+        assert!(events[0].ends_with('\n'));
+    }
+
+    #[tokio::test]
+    async fn test_broadcast_serializes_event_as_json() {
+        let manager = EventManager::new().unwrap();
+        let event = Event::new("hello world");
+
+        manager.broadcast(&event).await.unwrap();
+
+        let events = manager.events.read().await;
+        let stored = &events[0];
+
+        // Should be valid JSON
+        let parsed: serde_json::Value = serde_json::from_str(stored.trim()).unwrap();
+        assert_eq!(parsed["message"], "hello world");
+    }
+
+    #[rstest]
+    #[case(1)]
+    #[case(10)]
+    #[case(100)]
+    #[case(999)]
+    #[tokio::test]
+    async fn test_buffer_holds_events_below_max(#[case] count: usize) {
+        let manager = EventManager::new().unwrap();
+
+        for i in 0..count {
+            let event = Event::new(format!("event {}", i));
+            manager.broadcast(&event).await.unwrap();
+        }
+
+        let events = manager.events.read().await;
+        assert_eq!(events.len(), count);
+    }
+
+    #[tokio::test]
+    async fn test_buffer_at_exactly_max_capacity() {
+        let manager = EventManager::new().unwrap();
+
+        // Fill to exactly EVENT_BUF_MAX (1000)
+        for i in 0..EVENT_BUF_MAX {
+            let event = Event::new(format!("event {}", i));
+            manager.broadcast(&event).await.unwrap();
+        }
+
+        let events = manager.events.read().await;
+        assert_eq!(events.len(), EVENT_BUF_MAX);
+        assert!(events[0].contains("event 0"));
+        assert!(events[EVENT_BUF_MAX - 1].contains("event 999"));
+    }
+
+    #[rstest]
+    #[case(1)]
+    #[case(10)]
+    #[case(100)]
+    #[case(500)]
+    #[tokio::test]
+    async fn test_buffer_overflow_evicts_oldest_fifo(#[case] overflow: usize) {
+        let manager = EventManager::new().unwrap();
+        let total = EVENT_BUF_MAX + overflow;
+
+        // Broadcast more events than buffer can hold
+        for i in 0..total {
+            let event = Event::new(format!("event {}", i));
+            manager.broadcast(&event).await.unwrap();
+        }
+
+        let events = manager.events.read().await;
+
+        // Buffer should still be at max capacity
+        assert_eq!(events.len(), EVENT_BUF_MAX);
+
+        // Oldest events (0 through overflow-1) should be evicted
+        // Buffer should contain events [overflow..total)
+        let first_event = &events[0];
+        let last_event = &events[EVENT_BUF_MAX - 1];
+
+        assert!(first_event.contains(&format!("event {}", overflow)));
+        assert!(last_event.contains(&format!("event {}", total - 1)));
+
+        // Verify the evicted events are NOT in the buffer
+        let buffer_string = events.iter().cloned().collect::<String>();
+        assert!(!buffer_string.contains(r#""message":"event 0""#));
+    }
+
+    #[tokio::test]
+    async fn test_multiple_broadcasts_maintain_order() {
+        let manager = EventManager::new().unwrap();
+        let messages = vec!["first", "second", "third", "fourth", "fifth"];
+
+        for msg in &messages {
+            let event = Event::new(*msg);
+            manager.broadcast(&event).await.unwrap();
+        }
+
+        let events = manager.events.read().await;
+        assert_eq!(events.len(), messages.len());
+
+        for (i, expected) in messages.iter().enumerate() {
+            assert!(events[i].contains(expected));
+        }
+    }
+
+    #[tokio::test]
+    async fn test_buffer_wraparound_maintains_newest_events() {
+        let manager = EventManager::new().unwrap();
+
+        // Fill buffer completely
+        for i in 0..EVENT_BUF_MAX {
+            let event = Event::new(format!("old {}", i));
+            manager.broadcast(&event).await.unwrap();
+        }
+
+        // Add 5 more events
+        for i in 0..5 {
+            let event = Event::new(format!("new {}", i));
+            manager.broadcast(&event).await.unwrap();
+        }
+
+        let events = manager.events.read().await;
+        assert_eq!(events.len(), EVENT_BUF_MAX);
+
+        // First 5 old events should be gone
+        let buffer_string = events.iter().cloned().collect::<String>();
+        assert!(!buffer_string.contains(r#""message":"old 0""#));
+        assert!(!buffer_string.contains(r#""message":"old 4""#));
+
+        // But old 5 should still be there (now at the front)
+        assert!(events[0].contains("old 5"));
+
+        // New events should be at the end
+        assert!(events[EVENT_BUF_MAX - 5].contains("new 0"));
+        assert!(events[EVENT_BUF_MAX - 1].contains("new 4"));
+    }
+
+    #[tokio::test]
+    async fn test_concurrent_broadcasts_all_stored() {
+        let manager = Arc::new(EventManager::new().unwrap());
+        let mut handles = vec![];
+
+        // Spawn 10 concurrent tasks, each broadcasting 10 events
+        for task_id in 0..10 {
+            let manager_clone = Arc::clone(&manager);
+            let handle = tokio::spawn(async move {
+                for i in 0..10 {
+                    let event = Event::new(format!("task {} event {}", task_id, i));
+                    manager_clone.broadcast(&event).await.unwrap();
+                }
+            });
+            handles.push(handle);
+        }
+
+        // Wait for all tasks to complete
+        for handle in handles {
+            handle.await.unwrap();
+        }
+
+        let events = manager.events.read().await;
+        assert_eq!(events.len(), 100);
+    }
+}

src/ipc.rs

@@ -0,0 +1,26 @@
+// Provides an IPC socket to communicate with other processes.
+
+use std::path::Path;
+
+use color_eyre::Result;
+use tokio::net::UnixListener;
+
+pub struct IPC {
+    listener: UnixListener,
+}
+
+impl IPC {
+    pub fn new(path: impl AsRef<Path>) -> Result<Self> {
+        let listener = UnixListener::bind(path)?;
+        Ok(Self { listener })
+    }
+
+    pub async fn run(&self) -> Result<()> {
+        loop {
+            match self.listener.accept().await {
+                Ok((_stream, _addr)) => {}
+                Err(e) => return Err(e.into()),
+            }
+        }
+    }
+}

src/main.rs

@@ -1,17 +1,14 @@
-use color_eyre::{
+use color_eyre::{Result, eyre::WrapErr};
-    Result,
-    eyre::WrapErr,
-};
 use human_panic::setup_panic;
-use std::os::unix::fs;
+use std::{os::unix::fs, sync::Arc};
-use tracing::{
+use tracing::{Level, info};
-    Level,
-    info,
-};
 use tracing_subscriber::FmtSubscriber;
 
+use crate::event_manager::EventManager;
+
 mod chat;
-mod commands;
+mod event;
+mod event_manager;
 mod qna;
 mod setup;
 
@@ -47,18 +44,17 @@ async fn main() -> Result<()> {
     }
 
     // Setup root path for commands.
-    let cmd_root = if let Ok(command_path) = config.get_string("command-path") {
+    // let cmd_root = if let Ok(command_path) = config.get_string("command-path") {
-        Some(commands::Root::new(command_path))
+    //     Some(commands::Root::new(command_path))
-    } else {
+    // } else {
-        None
+    //     None
-    };
+    // };
 
     let handle = qna::LLMHandle::new(
         config.get_string("api-key").wrap_err("API missing.")?,
         config
             .get_string("base-url")
             .wrap_err("base-url missing.")?,
-        cmd_root,
         config
             .get_string("model")
             .wrap_err("model string missing.")?,
@@ -67,9 +63,23 @@ async fn main() -> Result<()> {
             .unwrap_or_else(|_| DEFAULT_INSTRUCT.to_string()),
     )
     .wrap_err("Couldn't initialize LLM handle.")?;
+
+    let ev_manager = Arc::new(EventManager::new()?);
+    let ev_manager_clone = Arc::clone(&ev_manager);
+    ev_manager_clone
+        .broadcast(&event::Event::new("Starting..."))
+        .await?;
+
     let mut c = chat::new(&config, &handle).await?;
 
-    c.run().await.unwrap();
+    tokio::select! {
+        _ = ev_manager_clone.start_listening("/tmp/robo.sock") => {
+            // Event listener ended
+        }
+        result = c.run() => {
+            result.unwrap();
+        }
+    }
 
     Ok(())
 }

src/qna.rs

@@ -1,19 +1,10 @@
-use crate::commands;
 use color_eyre::Result;
 use futures::StreamExt;
 use genai::{
     Client,
     ModelIden,
-    chat::{
+    chat::{ChatMessage, ChatRequest, ChatStreamEvent, StreamChunk},
-        ChatMessage,
+    resolver::{AuthData, AuthResolver},
-        ChatRequest,
-        ChatStreamEvent,
-        StreamChunk,
-    },
-    resolver::{
-        AuthData,
-        AuthResolver,
-    },
 };
 use tracing::info;
 
@@ -23,7 +14,6 @@ use tracing::info;
 pub struct LLMHandle {
     chat_request: ChatRequest,
     client: Client,
-    cmd_root: Option<commands::Root>,
     model: String,
 }
 
@@ -31,7 +21,6 @@ impl LLMHandle {
     pub fn new(
         api_key: String,
         _base_url: impl AsRef<str>,
-        cmd_root: Option<commands::Root>,
         model: impl Into<String>,
         system_role: String,
     ) -> Result<LLMHandle> {
@@ -51,7 +40,6 @@ impl LLMHandle {
         Ok(LLMHandle {
             client,
             chat_request,
-            cmd_root,
             model: model.into(),
         })
     }

src/setup.rs

@@ -1,15 +1,9 @@
 use clap::Parser;
-use color_eyre::{
+use color_eyre::{Result, eyre::WrapErr};
-    Result,
-    eyre::WrapErr,
-};
 use config::Config;
 use directories::ProjectDirs;
 use std::path::PathBuf;
-use tracing::{
+use tracing::{info, instrument};
-    info,
-    instrument,
-};
 
 // TODO: use [clap(long, short, help_heading = Some(section))]
 #[derive(Clone, Debug, Parser)]