feat(elizacp): add chat TUI and deterministic mode

- Add ratatui-based chat TUI: `cargo run -p elizacp -- chat`
- Add `--deterministic` flag for reproducible responses (seed 22)
- Default to random seed for production use
- Require subcommand: `acp` for ACP agent, `chat` for TUI
- Add `elizacp()` helper to sacp-test for consistent test setup
- Update all test callers to use deterministic mode

Author: nikomatsakis

src/elizacp/Cargo.toml

@@ -32,6 +32,8 @@ tracing.workspace = true
 tracing-subscriber.workspace = true
 uuid.workspace = true
 sacp-tokio = { version = "10.0.0", path = "../sacp-tokio" }
+ratatui = "0.30.0"
+crossterm = "0.29.0"
 
 [dev-dependencies]
 expect-test.workspace = true

src/elizacp/src/chat.rs

@@ -0,0 +1,143 @@
+//! Simple TUI chat interface for Eliza.
+//!
+//! Run with: `cargo run -p elizacp -- chat`
+
+use crate::eliza::Eliza;
+use crossterm::{
+    ExecutableCommand,
+    event::{self, Event, KeyCode, KeyEventKind},
+    terminal::{EnterAlternateScreen, LeaveAlternateScreen, disable_raw_mode, enable_raw_mode},
+};
+use ratatui::{
+    prelude::*,
+    widgets::{Block, Borders, Paragraph, Wrap},
+};
+use std::io::{self, stdout};
+
+/// A single message in the chat history
+struct Message {
+    text: String,
+    is_user: bool,
+}
+
+/// Run the chat TUI
+pub fn run(deterministic: bool) -> anyhow::Result<()> {
+    // Setup terminal
+    stdout().execute(EnterAlternateScreen)?;
+    enable_raw_mode()?;
+
+    let mut terminal = Terminal::new(CrosstermBackend::new(stdout()))?;
+    terminal.clear()?;
+
+    let result = run_app(&mut terminal, deterministic);
+
+    // Restore terminal
+    disable_raw_mode()?;
+    stdout().execute(LeaveAlternateScreen)?;
+
+    result
+}
+
+fn run_app(
+    terminal: &mut Terminal<CrosstermBackend<io::Stdout>>,
+    deterministic: bool,
+) -> anyhow::Result<()> {
+    let mut eliza = if deterministic {
+        Eliza::new_deterministic()
+    } else {
+        Eliza::new()
+    };
+    let mut messages: Vec<Message> = vec![Message {
+        text: "Hello, I am Eliza. How can I help you today?".to_string(),
+        is_user: false,
+    }];
+    let mut input = String::new();
+
+    loop {
+        // Draw UI
+        terminal.draw(|frame| {
+            let area = frame.area();
+
+            // Split into messages area and input area
+            let chunks = Layout::default()
+                .direction(Direction::Vertical)
+                .constraints([Constraint::Min(3), Constraint::Length(3)])
+                .split(area);
+
+            // Messages area
+            let messages_text: String = messages
+                .iter()
+                .map(|m| {
+                    if m.is_user {
+                        format!("You: {}", m.text)
+                    } else {
+                        format!("Eliza: {}", m.text)
+                    }
+                })
+                .collect::<Vec<_>>()
+                .join("\n\n");
+
+            // Calculate scroll to show bottom of messages
+            let visible_height = chunks[0].height.saturating_sub(2) as usize; // -2 for borders
+            let line_count = messages_text.lines().count();
+            let scroll = line_count.saturating_sub(visible_height) as u16;
+
+            let messages_paragraph = Paragraph::new(messages_text)
+                .block(Block::default().borders(Borders::ALL).title("Chat"))
+                .wrap(Wrap { trim: false })
+                .scroll((scroll, 0));
+
+            frame.render_widget(messages_paragraph, chunks[0]);
+
+            // Input area
+            let input_paragraph = Paragraph::new(input.as_str()).block(
+                Block::default()
+                    .borders(Borders::ALL)
+                    .title("Type here (Enter to send, Esc to quit)"),
+            );
+
+            frame.render_widget(input_paragraph, chunks[1]);
+
+            // Position cursor at end of input
+            frame.set_cursor_position((chunks[1].x + input.len() as u16 + 1, chunks[1].y + 1));
+        })?;
+
+        // Handle input
+        if event::poll(std::time::Duration::from_millis(100))? {
+            if let Event::Key(key) = event::read()? {
+                if key.kind == KeyEventKind::Press {
+                    match key.code {
+                        KeyCode::Esc => break,
+                        KeyCode::Enter => {
+                            if !input.is_empty() {
+                                // Add user message
+                                messages.push(Message {
+                                    text: input.clone(),
+                                    is_user: true,
+                                });
+
+                                // Get Eliza's response
+                                let response = eliza.respond(&input);
+                                messages.push(Message {
+                                    text: response,
+                                    is_user: false,
+                                });
+
+                                input.clear();
+                            }
+                        }
+                        KeyCode::Backspace => {
+                            input.pop();
+                        }
+                        KeyCode::Char(c) => {
+                            input.push(c);
+                        }
+                        _ => {}
+                    }
+                }
+            }
+        }
+    }
+
+    Ok(())
+}

src/elizacp/src/eliza.rs

@@ -603,10 +603,14 @@ impl ElizaResponses {
 }
 
 impl Eliza {
-    /// Create a new Eliza instance with classic patterns.
-    /// Uses a fixed seed for deterministic testing.
+    /// Create a new Eliza instance with a random seed.
     pub fn new() -> Self {
-        Self::with_seed(42)
+        Self::with_seed(rand::random())
+    }
+
+    /// Create a new Eliza instance with a fixed seed for deterministic behavior.
+    pub fn new_deterministic() -> Self {
+        Self::with_seed(22)
     }
 
     /// Create a new Eliza instance with a specific seed.
@@ -1294,77 +1298,77 @@ mod tests {
 
     #[test]
     fn test_greeting() {
-        let mut eliza = Eliza::new();
+        let mut eliza = Eliza::new_deterministic();
         let response = eliza.respond("Hello");
         expect!["How do you do?"].assert_eq(&response);
     }
 
     #[test]
     fn test_how_are_you() {
-        let mut eliza = Eliza::new();
+        let mut eliza = Eliza::new_deterministic();
         let response = eliza.respond("How are you?");
         expect!["I'm ok. Describe yourself."].assert_eq(&response);
     }
 
     #[test]
     fn test_goodbye() {
-        let mut eliza = Eliza::new();
+        let mut eliza = Eliza::new_deterministic();
         let response = eliza.respond("Goodbye");
         expect!["My secretary will send you a bill."].assert_eq(&response);
     }
 
     #[test]
     fn test_family() {
-        let mut eliza = Eliza::new();
+        let mut eliza = Eliza::new_deterministic();
         let response = eliza.respond("I want to talk about my mother");
         expect!["Tell me something about my family."].assert_eq(&response);
     }
 
     #[test]
     fn test_mood() {
-        let mut eliza = Eliza::new();
+        let mut eliza = Eliza::new_deterministic();
         let response = eliza.respond("I am feeling depressed");
         expect!["Are you depressed often?"].assert_eq(&response);
     }
 
     #[test]
     fn test_fear() {
-        let mut eliza = Eliza::new();
+        let mut eliza = Eliza::new_deterministic();
         let response = eliza.respond("I am afraid of spiders");
         expect!["Why do you say you are afraid of spiders?"].assert_eq(&response);
     }
 
     #[test]
     fn test_computer() {
-        let mut eliza = Eliza::new();
+        let mut eliza = Eliza::new_deterministic();
         let response = eliza.respond("I spend too much time on the computer");
         expect!["You have your mind on computer, it seems."].assert_eq(&response);
     }
 
     #[test]
     fn test_question_deflection() {
-        let mut eliza = Eliza::new();
+        let mut eliza = Eliza::new_deterministic();
         let response = eliza.respond("Why do you ask so many questions?");
         expect!["What do you think?"].assert_eq(&response);
     }
 
     #[test]
     fn test_can_you() {
-        let mut eliza = Eliza::new();
+        let mut eliza = Eliza::new_deterministic();
         let response = eliza.respond("Can you help me?");
         expect!["Of course I can."].assert_eq(&response);
     }
 
     #[test]
     fn test_reflection() {
-        let eliza = Eliza::new();
+        let eliza = Eliza::new_deterministic();
         let reflected = eliza.reflect("I am happy");
         expect!["you are happy"].assert_eq(&reflected);
     }
 
     #[test]
     fn test_rotation() {
-        let mut eliza = Eliza::new();
+        let mut eliza = Eliza::new_deterministic();
 
         // First greeting
         let r1 = eliza.respond("hi");
@@ -1401,21 +1405,21 @@ mod tests {
 
     #[test]
     fn test_abuse() {
-        let mut eliza = Eliza::new();
+        let mut eliza = Eliza::new_deterministic();
         let response = eliza.respond("You idiot");
         expect!["Please try to be less abusive."].assert_eq(&response);
     }
 
     #[test]
     fn test_short_input() {
-        let mut eliza = Eliza::new();
+        let mut eliza = Eliza::new_deterministic();
         let response = eliza.respond("ok");
         expect!["Can you elaborate on that?"].assert_eq(&response);
     }
 
     #[test]
     fn test_desire_with_object() {
-        let mut eliza = Eliza::new();
+        let mut eliza = Eliza::new_deterministic();
         // "want" is the keyword, "a new car" is the object
         // Response template is "Why do you {} {}?" -> "Why do you want a new car?"
         let response = eliza.respond("I want a new car");
@@ -1424,7 +1428,7 @@ mod tests {
 
     #[test]
     fn test_rust_borrow_checker() {
-        let mut eliza = Eliza::new();
+        let mut eliza = Eliza::new_deterministic();
         let r1 = eliza.respond("I'm struggling with the borrow checker");
         expect!["The borrow checker sees what you cannot."].assert_eq(&r1);
 
@@ -1436,35 +1440,35 @@ mod tests {
 
     #[test]
     fn test_rust_cargo() {
-        let mut eliza = Eliza::new();
+        let mut eliza = Eliza::new_deterministic();
         let response = eliza.respond("cargo build is failing");
         expect!["Cargo carries the weight so you don't have to."].assert_eq(&response);
     }
 
     #[test]
     fn test_rust_clippy() {
-        let mut eliza = Eliza::new();
+        let mut eliza = Eliza::new_deterministic();
         let response = eliza.respond("clippy is complaining again");
         expect!["Clippy only wants what's best for you."].assert_eq(&response);
     }
 
     #[test]
     fn test_rust_ferris() {
-        let mut eliza = Eliza::new();
+        let mut eliza = Eliza::new_deterministic();
         let response = eliza.respond("I love ferris");
         expect!["Isn't Ferris just the cutest? I love them."].assert_eq(&response);
     }
 
     #[test]
     fn test_rust_async() {
-        let mut eliza = Eliza::new();
+        let mut eliza = Eliza::new_deterministic();
         let response = eliza.respond("async is confusing me");
         expect!["Have you tried `.await`ing your problems?"].assert_eq(&response);
     }
 
     #[test]
     fn test_rust_general() {
-        let mut eliza = Eliza::new();
+        let mut eliza = Eliza::new_deterministic();
         let response = eliza.respond("I'm learning rust");
         expect!["Rust is not just a language, it's a journey."].assert_eq(&response);
     }

src/elizacp/src/lib.rs

@@ -1,3 +1,4 @@
+pub mod chat;
 pub mod eliza;
 
 use anyhow::Result;
@@ -24,25 +25,26 @@ struct SessionData {
 #[derive(Clone)]
 pub struct ElizaAgent {
     sessions: Arc<Mutex<HashMap<SessionId, SessionData>>>,
+    deterministic: bool,
 }
 
 impl ElizaAgent {
-    pub fn new() -> Self {
+    pub fn new(deterministic: bool) -> Self {
         Self {
             sessions: Arc::new(Mutex::new(HashMap::new())),
+            deterministic,
         }
     }
 
     fn create_session(&self, session_id: &SessionId, mcp_servers: Vec<McpServer>) {
         let mcp_server_count = mcp_servers.len();
+        let eliza = if self.deterministic {
+            Eliza::new_deterministic()
+        } else {
+            Eliza::new()
+        };
         let mut sessions = self.sessions.lock().unwrap();
-        sessions.insert(
-            session_id.clone(),
-            SessionData {
-                eliza: Eliza::new(),
-                mcp_servers,
-            },
-        );
+        sessions.insert(session_id.clone(), SessionData { eliza, mcp_servers });
         tracing::info!(
             "Created session: {} with {} MCP servers",
             session_id,