927cddd864
Convert F2-F5 screens to ScreenView trait with tick() method. Each screen owns its view state (scroll, selection, expanded). State persists across screen switches. - ThalamusScreen: owns sampling_selected, scroll - ConsciousScreen: owns scroll, selected, expanded - SubconsciousScreen: owns selected, log_view, scroll - UnconsciousScreen: owns scroll Removed from App: Screen enum, debug_scroll, debug_selected, debug_expanded, agent_selected, agent_log_view, sampling_selected, set_screen(), per-screen key handling, draw dispatch. App now only draws the interact (F1) screen. Overlay screens are drawn by the event loop via ScreenView::tick. F-key routing and screen instantiation to be wired in event_loop next. InteractScreen (state-driven, reading from agent entries) is the next step — will eliminate the input display race condition. Co-Authored-By: Kent Overstreet <kent.overstreet@linux.dev>
526 lines
19 KiB
Rust
526 lines
19 KiB
Rust
// event_loop.rs — TUI event loop
|
|
//
|
|
// Drives the terminal, renders the UI, dispatches user input and
|
|
// hotkey actions to the Mind via a channel. Reads shared state
|
|
// (agent, active tools) directly for rendering.
|
|
|
|
use anyhow::Result;
|
|
use ratatui::crossterm::event::{Event, EventStream, KeyEventKind};
|
|
use futures::StreamExt;
|
|
use std::sync::Arc;
|
|
use std::time::Duration;
|
|
use tokio::sync::Mutex;
|
|
|
|
use crate::agent::Agent;
|
|
use crate::agent::api::ApiClient;
|
|
use crate::mind::MindCommand;
|
|
use crate::user::{self as tui, HotkeyAction};
|
|
use crate::user::ui_channel::{self, UiMessage};
|
|
|
|
// ── Slash commands ─────────────────────────────────────────────
|
|
|
|
type CmdHandler = for<'a> fn(
|
|
&'a crate::mind::Mind,
|
|
&'a tokio::sync::mpsc::UnboundedSender<MindCommand>,
|
|
&'a ui_channel::UiSender,
|
|
&'a str,
|
|
);
|
|
|
|
struct SlashCommand {
|
|
name: &'static str,
|
|
help: &'static str,
|
|
handler: CmdHandler,
|
|
}
|
|
|
|
fn commands() -> Vec<SlashCommand> { vec![
|
|
SlashCommand { name: "/quit", help: "Exit consciousness",
|
|
handler: |_, _, _, _| {} },
|
|
SlashCommand { name: "/new", help: "Start fresh session (saves current)",
|
|
handler: |_, tx, _, _| { let _ = tx.send(MindCommand::NewSession); } },
|
|
SlashCommand { name: "/save", help: "Save session to disk",
|
|
handler: |_, _, ui, _| { let _ = ui.send(UiMessage::Info("Conversation is saved automatically.".into())); } },
|
|
SlashCommand { name: "/retry", help: "Re-run last turn",
|
|
handler: |m, tx, ui, _| {
|
|
let agent = m.agent.clone();
|
|
let mind_tx = tx.clone();
|
|
let ui_tx = ui.clone();
|
|
let mut tw = m.turn_watch();
|
|
tokio::spawn(async move {
|
|
let _ = tw.wait_for(|&active| !active).await;
|
|
cmd_retry_inner(&agent, &mind_tx, &ui_tx).await;
|
|
});
|
|
} },
|
|
SlashCommand { name: "/model", help: "Show/switch model (/model <name>)",
|
|
handler: |m, _, ui, arg| {
|
|
if arg.is_empty() {
|
|
if let Ok(ag) = m.agent.try_lock() {
|
|
let _ = ui.send(UiMessage::Info(format!("Current model: {}", ag.model())));
|
|
let names = ag.app_config.model_names();
|
|
if !names.is_empty() {
|
|
let _ = ui.send(UiMessage::Info(format!("Available: {}", names.join(", "))));
|
|
}
|
|
} else {
|
|
let _ = ui.send(UiMessage::Info("(busy)".into()));
|
|
}
|
|
} else {
|
|
let agent = m.agent.clone();
|
|
let ui_tx = ui.clone();
|
|
let name = arg.to_string();
|
|
tokio::spawn(async move { cmd_switch_model(&agent, &name, &ui_tx).await; });
|
|
}
|
|
} },
|
|
SlashCommand { name: "/score", help: "Score memory importance",
|
|
handler: |_, tx, _, _| { let _ = tx.send(MindCommand::Score); } },
|
|
SlashCommand { name: "/dmn", help: "Show DMN state",
|
|
handler: |m, _, ui, _| {
|
|
let s = m.shared.lock().unwrap();
|
|
let _ = ui.send(UiMessage::Info(format!("DMN: {:?} ({}/{})", s.dmn, s.dmn_turns, s.max_dmn_turns)));
|
|
} },
|
|
SlashCommand { name: "/sleep", help: "Put DMN to sleep",
|
|
handler: |m, _, ui, _| {
|
|
let mut s = m.shared.lock().unwrap();
|
|
s.dmn = crate::mind::dmn::State::Resting { since: std::time::Instant::now() };
|
|
s.dmn_turns = 0;
|
|
let _ = ui.send(UiMessage::Info("DMN sleeping.".into()));
|
|
} },
|
|
SlashCommand { name: "/wake", help: "Wake DMN to foraging",
|
|
handler: |m, _, ui, _| {
|
|
let mut s = m.shared.lock().unwrap();
|
|
if matches!(s.dmn, crate::mind::dmn::State::Off) { crate::mind::dmn::set_off(false); }
|
|
s.dmn = crate::mind::dmn::State::Foraging;
|
|
s.dmn_turns = 0;
|
|
let _ = ui.send(UiMessage::Info("DMN foraging.".into()));
|
|
} },
|
|
SlashCommand { name: "/pause", help: "Full stop — no autonomous ticks (Ctrl+P)",
|
|
handler: |m, _, ui, _| {
|
|
let mut s = m.shared.lock().unwrap();
|
|
s.dmn = crate::mind::dmn::State::Paused;
|
|
s.dmn_turns = 0;
|
|
let _ = ui.send(UiMessage::Info("DMN paused.".into()));
|
|
} },
|
|
SlashCommand { name: "/help", help: "Show this help",
|
|
handler: |_, _, ui, _| { send_help(ui); } },
|
|
]}
|
|
|
|
/// Top-level entry point — creates Mind and UI, wires them together.
|
|
pub async fn start(cli: crate::user::CliArgs) -> Result<()> {
|
|
let (config, _figment) = crate::config::load_session(&cli)?;
|
|
|
|
if config.app.debug {
|
|
unsafe { std::env::set_var("POC_DEBUG", "1") };
|
|
}
|
|
|
|
let (ui_tx, ui_rx) = ui_channel::channel();
|
|
let (turn_tx, turn_rx) = tokio::sync::mpsc::channel(1);
|
|
let (mind_tx, mind_rx) = tokio::sync::mpsc::unbounded_channel();
|
|
|
|
let mind = crate::mind::Mind::new(config, ui_tx.clone(), turn_tx);
|
|
|
|
let shared_context = mind.agent.lock().await.shared_context.clone();
|
|
let shared_active_tools = mind.agent.lock().await.active_tools.clone();
|
|
|
|
let mut result = Ok(());
|
|
tokio_scoped::scope(|s| {
|
|
// Mind event loop — init + run
|
|
s.spawn(async {
|
|
mind.init().await;
|
|
mind.run(mind_rx, turn_rx).await;
|
|
});
|
|
|
|
// UI event loop
|
|
s.spawn(async {
|
|
result = run(
|
|
tui::App::new(String::new(), shared_context, shared_active_tools),
|
|
&mind, mind_tx, ui_tx, ui_rx,
|
|
).await;
|
|
});
|
|
});
|
|
result
|
|
}
|
|
|
|
fn dispatch_command(input: &str) -> Option<SlashCommand> {
|
|
let cmd_name = input.split_whitespace().next()?;
|
|
commands().into_iter().find(|c| c.name == cmd_name)
|
|
}
|
|
|
|
fn send_help(ui_tx: &ui_channel::UiSender) {
|
|
for cmd in &commands() {
|
|
let _ = ui_tx.send(UiMessage::Info(format!(" {:12} {}", cmd.name, cmd.help)));
|
|
}
|
|
let _ = ui_tx.send(UiMessage::Info(String::new()));
|
|
let _ = ui_tx.send(UiMessage::Info(
|
|
"Keys: Tab=pane ^Up/Down=scroll PgUp/PgDn=scroll Mouse=click/scroll".into(),
|
|
));
|
|
let _ = ui_tx.send(UiMessage::Info(
|
|
" Alt+Enter=newline Esc=interrupt ^P=pause ^R=reasoning ^K=kill F10=context F2=agents".into(),
|
|
));
|
|
let _ = ui_tx.send(UiMessage::Info(
|
|
" Shift+click for native text selection (copy/paste)".into(),
|
|
));
|
|
}
|
|
|
|
async fn cmd_retry_inner(
|
|
agent: &Arc<Mutex<Agent>>,
|
|
mind_tx: &tokio::sync::mpsc::UnboundedSender<MindCommand>,
|
|
ui_tx: &ui_channel::UiSender,
|
|
) {
|
|
let mut agent_guard = agent.lock().await;
|
|
let entries = agent_guard.entries_mut();
|
|
let mut last_user_text = None;
|
|
while let Some(entry) = entries.last() {
|
|
if entry.message().role == crate::agent::api::types::Role::User {
|
|
last_user_text = Some(entries.pop().unwrap().message().content_text().to_string());
|
|
break;
|
|
}
|
|
entries.pop();
|
|
}
|
|
drop(agent_guard);
|
|
match last_user_text {
|
|
Some(text) => {
|
|
let preview_len = text.len().min(60);
|
|
let _ = ui_tx.send(UiMessage::Info(format!("(retrying: {}...)", &text[..preview_len])));
|
|
// Send as a Turn command — Mind will process it
|
|
let _ = mind_tx.send(MindCommand::Turn(text, crate::user::ui_channel::StreamTarget::Conversation));
|
|
}
|
|
None => {
|
|
let _ = ui_tx.send(UiMessage::Info("(nothing to retry)".into()));
|
|
}
|
|
}
|
|
}
|
|
|
|
fn hotkey_cycle_reasoning(mind: &crate::mind::Mind, ui_tx: &ui_channel::UiSender) {
|
|
if let Ok(mut ag) = mind.agent.try_lock() {
|
|
let next = match ag.reasoning_effort.as_str() {
|
|
"none" => "low",
|
|
"low" => "high",
|
|
_ => "none",
|
|
};
|
|
ag.reasoning_effort = next.to_string();
|
|
let label = match next {
|
|
"none" => "off (monologue hidden)",
|
|
"low" => "low (brief monologue)",
|
|
"high" => "high (full monologue)",
|
|
_ => next,
|
|
};
|
|
let _ = ui_tx.send(UiMessage::Info(format!("Reasoning: {} — ^R to cycle", label)));
|
|
} else {
|
|
let _ = ui_tx.send(UiMessage::Info(
|
|
"(agent busy — reasoning change takes effect next turn)".into(),
|
|
));
|
|
}
|
|
}
|
|
|
|
async fn hotkey_kill_processes(mind: &crate::mind::Mind, ui_tx: &ui_channel::UiSender) {
|
|
let active_tools = mind.agent.lock().await.active_tools.clone();
|
|
let mut tools = active_tools.lock().unwrap();
|
|
if tools.is_empty() {
|
|
let _ = ui_tx.send(UiMessage::Info("(no running tool calls)".into()));
|
|
} else {
|
|
for entry in tools.drain(..) {
|
|
let elapsed = entry.started.elapsed();
|
|
let _ = ui_tx.send(UiMessage::Info(format!(
|
|
" killing {} ({:.0}s): {}", entry.name, elapsed.as_secs_f64(), entry.detail,
|
|
)));
|
|
entry.handle.abort();
|
|
}
|
|
}
|
|
}
|
|
|
|
fn hotkey_cycle_autonomy(mind: &crate::mind::Mind, ui_tx: &ui_channel::UiSender) {
|
|
let mut s = mind.shared.lock().unwrap();
|
|
let label = match &s.dmn {
|
|
crate::mind::dmn::State::Engaged | crate::mind::dmn::State::Working | crate::mind::dmn::State::Foraging => {
|
|
s.dmn = crate::mind::dmn::State::Resting { since: std::time::Instant::now() };
|
|
"resting"
|
|
}
|
|
crate::mind::dmn::State::Resting { .. } => {
|
|
s.dmn = crate::mind::dmn::State::Paused;
|
|
"PAUSED"
|
|
}
|
|
crate::mind::dmn::State::Paused => {
|
|
crate::mind::dmn::set_off(true);
|
|
s.dmn = crate::mind::dmn::State::Off;
|
|
"OFF (persists across restarts)"
|
|
}
|
|
crate::mind::dmn::State::Off => {
|
|
crate::mind::dmn::set_off(false);
|
|
s.dmn = crate::mind::dmn::State::Foraging;
|
|
"foraging"
|
|
}
|
|
};
|
|
s.dmn_turns = 0;
|
|
drop(s);
|
|
let _ = ui_tx.send(UiMessage::Info(format!("DMN → {} (Ctrl+P to cycle)", label)));
|
|
}
|
|
|
|
fn hotkey_adjust_sampling(mind: &crate::mind::Mind, param: usize, delta: f32) {
|
|
if let Ok(mut ag) = mind.agent.try_lock() {
|
|
match param {
|
|
0 => ag.temperature = (ag.temperature + delta).clamp(0.0, 2.0),
|
|
1 => ag.top_p = (ag.top_p + delta).clamp(0.0, 1.0),
|
|
2 => ag.top_k = (ag.top_k as f32 + delta).max(0.0) as u32,
|
|
_ => {}
|
|
}
|
|
}
|
|
}
|
|
|
|
pub fn send_context_info(config: &crate::config::SessionConfig, ui_tx: &ui_channel::UiSender) {
|
|
let context_groups = crate::config::get().context_groups.clone();
|
|
let (instruction_files, memory_files) = crate::mind::identity::context_file_info(
|
|
&config.prompt_file,
|
|
config.app.memory_project.as_deref(),
|
|
&context_groups,
|
|
);
|
|
let _ = ui_tx.send(UiMessage::Info(format!(
|
|
" context: {}K chars ({} config, {} memory files)",
|
|
config.context_parts.iter().map(|(_, c)| c.len()).sum::<usize>() / 1024,
|
|
instruction_files.len(), memory_files.len(),
|
|
)));
|
|
}
|
|
|
|
pub async fn cmd_switch_model(
|
|
agent: &Arc<Mutex<Agent>>,
|
|
name: &str,
|
|
ui_tx: &ui_channel::UiSender,
|
|
) {
|
|
let resolved = {
|
|
let ag = agent.lock().await;
|
|
match ag.app_config.resolve_model(name) {
|
|
Ok(r) => r,
|
|
Err(e) => {
|
|
let _ = ui_tx.send(UiMessage::Info(format!("{}", e)));
|
|
return;
|
|
}
|
|
}
|
|
};
|
|
|
|
let new_client = ApiClient::new(&resolved.api_base, &resolved.api_key, &resolved.model_id);
|
|
let prompt_changed = {
|
|
let ag = agent.lock().await;
|
|
resolved.prompt_file != ag.prompt_file
|
|
};
|
|
|
|
let mut ag = agent.lock().await;
|
|
ag.swap_client(new_client);
|
|
|
|
if prompt_changed {
|
|
ag.prompt_file = resolved.prompt_file.clone();
|
|
ag.compact();
|
|
let _ = ui_tx.send(UiMessage::Info(format!(
|
|
"Switched to {} ({}) — prompt: {}, recompacted",
|
|
name, resolved.model_id, resolved.prompt_file,
|
|
)));
|
|
} else {
|
|
let _ = ui_tx.send(UiMessage::Info(format!(
|
|
"Switched to {} ({})", name, resolved.model_id,
|
|
)));
|
|
}
|
|
}
|
|
|
|
fn diff_mind_state(
|
|
cur: &crate::mind::MindState,
|
|
prev: &crate::mind::MindState,
|
|
ui_tx: &ui_channel::UiSender,
|
|
dirty: &mut bool,
|
|
) {
|
|
if cur.dmn.label() != prev.dmn.label() || cur.dmn_turns != prev.dmn_turns {
|
|
let _ = ui_tx.send(UiMessage::StatusUpdate(ui_channel::StatusInfo {
|
|
dmn_state: cur.dmn.label().to_string(),
|
|
dmn_turns: cur.dmn_turns,
|
|
dmn_max_turns: cur.max_dmn_turns,
|
|
prompt_tokens: 0, completion_tokens: 0,
|
|
model: String::new(), turn_tools: 0,
|
|
context_budget: String::new(),
|
|
}));
|
|
*dirty = true;
|
|
}
|
|
// Input consumed — Mind started a turn with it
|
|
if !prev.input.is_empty() && cur.input.is_empty() {
|
|
let text = prev.input.join("\n");
|
|
let _ = ui_tx.send(UiMessage::UserInput(text));
|
|
*dirty = true;
|
|
}
|
|
if cur.turn_active != prev.turn_active {
|
|
*dirty = true;
|
|
}
|
|
if cur.scoring_in_flight != prev.scoring_in_flight {
|
|
if !cur.scoring_in_flight && prev.scoring_in_flight {
|
|
let _ = ui_tx.send(UiMessage::Info("[scoring complete]".into()));
|
|
}
|
|
*dirty = true;
|
|
}
|
|
if cur.compaction_in_flight != prev.compaction_in_flight {
|
|
if !cur.compaction_in_flight && prev.compaction_in_flight {
|
|
let _ = ui_tx.send(UiMessage::Info("[compacted]".into()));
|
|
}
|
|
*dirty = true;
|
|
}
|
|
}
|
|
|
|
pub async fn run(
|
|
mut app: tui::App,
|
|
mind: &crate::mind::Mind,
|
|
mind_tx: tokio::sync::mpsc::UnboundedSender<MindCommand>,
|
|
ui_tx: ui_channel::UiSender,
|
|
mut ui_rx: ui_channel::UiReceiver,
|
|
) -> Result<()> {
|
|
let agent = &mind.agent;
|
|
let shared_mind = &mind.shared;
|
|
let turn_watch = mind.turn_watch();
|
|
// UI-owned state
|
|
let mut idle_state = crate::thalamus::idle::State::new();
|
|
idle_state.load();
|
|
|
|
let (channel_tx, mut channel_rx) = tokio::sync::mpsc::channel::<Vec<(String, bool, u32)>>(4);
|
|
{
|
|
let tx = channel_tx.clone();
|
|
tokio::spawn(async move {
|
|
let result = crate::thalamus::channels::fetch_all_channels().await;
|
|
let _ = tx.send(result).await;
|
|
});
|
|
}
|
|
let notify_rx = crate::thalamus::channels::subscribe_all();
|
|
let mut terminal = tui::init_terminal()?;
|
|
let mut reader = EventStream::new();
|
|
|
|
let mut render_interval = tokio::time::interval(Duration::from_millis(50));
|
|
render_interval.set_missed_tick_behavior(tokio::time::MissedTickBehavior::Skip);
|
|
let mut dirty = true;
|
|
let mut prev_mind = shared_mind.lock().unwrap().clone();
|
|
|
|
terminal.hide_cursor()?;
|
|
|
|
let _ = ui_tx.send(UiMessage::Info("consciousness v0.3 (tui)".into()));
|
|
|
|
// Initial render — don't wait for Mind to init
|
|
app.drain_messages(&mut ui_rx);
|
|
terminal.draw(|f| app.draw(f))?;
|
|
|
|
// Replay conversation after Mind init completes (non-blocking check)
|
|
let mut startup_done = false;
|
|
|
|
loop {
|
|
tokio::select! {
|
|
biased;
|
|
|
|
maybe_event = reader.next() => {
|
|
match maybe_event {
|
|
Some(Ok(Event::Key(key))) => {
|
|
if key.kind != KeyEventKind::Press { continue; }
|
|
app.handle_key(key);
|
|
idle_state.user_activity();
|
|
if false { // TODO: check active screen is thalamus
|
|
let tx = channel_tx.clone();
|
|
tokio::spawn(async move {
|
|
let result = crate::thalamus::channels::fetch_all_channels().await;
|
|
let _ = tx.send(result).await;
|
|
});
|
|
}
|
|
dirty = true;
|
|
}
|
|
Some(Ok(Event::Mouse(mouse))) => {
|
|
app.handle_mouse(mouse);
|
|
dirty = true;
|
|
}
|
|
Some(Ok(Event::Resize(w, h))) => {
|
|
app.handle_resize(w, h);
|
|
terminal.clear()?;
|
|
dirty = true;
|
|
}
|
|
Some(Err(_)) => break,
|
|
None => break,
|
|
_ => continue,
|
|
}
|
|
}
|
|
|
|
|
|
_ = render_interval.tick() => {
|
|
idle_state.decay_ewma();
|
|
app.update_idle(&idle_state);
|
|
|
|
// One-time: replay conversation after Mind init
|
|
if !startup_done {
|
|
if let Ok(ag) = agent.try_lock() {
|
|
if !ag.entries().is_empty() {
|
|
ui_channel::replay_session_to_ui(ag.entries(), &ui_tx);
|
|
let _ = ui_tx.send(UiMessage::Info("--- restored from conversation log ---".into()));
|
|
}
|
|
let _ = ui_tx.send(UiMessage::Info(format!(" model: {}", ag.model())));
|
|
startup_done = true;
|
|
dirty = true;
|
|
}
|
|
}
|
|
|
|
// Diff MindState — generate UI messages from changes
|
|
{
|
|
let cur = shared_mind.lock().unwrap();
|
|
diff_mind_state(&cur, &prev_mind, &ui_tx, &mut dirty);
|
|
prev_mind = cur.clone();
|
|
}
|
|
|
|
while let Ok(notif) = notify_rx.try_recv() {
|
|
let tx = channel_tx.clone();
|
|
tokio::spawn(async move {
|
|
let result = crate::thalamus::channels::fetch_all_channels().await;
|
|
let _ = tx.send(result).await;
|
|
});
|
|
}
|
|
}
|
|
|
|
Some(channels) = channel_rx.recv() => {
|
|
app.set_channel_status(channels);
|
|
dirty = true;
|
|
}
|
|
|
|
Some(msg) = ui_rx.recv() => {
|
|
app.handle_ui_message(msg);
|
|
dirty = true;
|
|
}
|
|
}
|
|
|
|
// Process submitted input
|
|
let submitted: Vec<String> = app.submitted.drain(..).collect();
|
|
for input in submitted {
|
|
let input = input.trim().to_string();
|
|
if input.is_empty() { continue; }
|
|
if input == "/quit" || input == "/exit" {
|
|
app.should_quit = true;
|
|
} else if let Some(cmd) = dispatch_command(&input) {
|
|
(cmd.handler)(mind, &mind_tx, &ui_tx, &input[cmd.name.len()..].trim_start());
|
|
} else {
|
|
let mut s = shared_mind.lock().unwrap();
|
|
diff_mind_state(&s, &prev_mind, &ui_tx, &mut dirty);
|
|
s.input.push(input);
|
|
prev_mind = s.clone();
|
|
}
|
|
}
|
|
|
|
// Handle hotkey actions
|
|
let actions: Vec<HotkeyAction> = app.hotkey_actions.drain(..).collect();
|
|
for action in actions {
|
|
match action {
|
|
HotkeyAction::CycleReasoning => hotkey_cycle_reasoning(mind, &ui_tx),
|
|
HotkeyAction::KillProcess => hotkey_kill_processes(mind, &ui_tx).await,
|
|
HotkeyAction::Interrupt => { let _ = mind_tx.send(MindCommand::Interrupt); }
|
|
HotkeyAction::CycleAutonomy => hotkey_cycle_autonomy(mind, &ui_tx),
|
|
HotkeyAction::AdjustSampling(param, delta) => hotkey_adjust_sampling(mind, param, delta),
|
|
}
|
|
}
|
|
|
|
if app.drain_messages(&mut ui_rx) {
|
|
dirty = true;
|
|
}
|
|
|
|
if dirty {
|
|
terminal.draw(|f| app.draw(f))?;
|
|
dirty = false;
|
|
}
|
|
|
|
if app.should_quit {
|
|
break;
|
|
}
|
|
}
|
|
|
|
tui::restore_terminal(&mut terminal)?;
|
|
Ok(())
|
|
}
|