consciousness/src/user/mod.rs

// user/ — User interface layer
//
// TUI, UI channel, parsing. The cognitive layer (session state
// machine, DMN, identity) lives in mind/.

pub mod chat;
pub mod context;
pub mod subconscious;
pub mod unconscious;
pub mod thalamus;

use anyhow::Result;
use std::io::Write;

use crate::mind::MindCommand;
use crate::user::{self as tui};

// --- TUI infrastructure (moved from tui/mod.rs) ---

use ratatui::crossterm::{
    event::{EnableMouseCapture, DisableMouseCapture},
    terminal::{self, EnterAlternateScreen, LeaveAlternateScreen},
    ExecutableCommand,
};
use ratatui::{
    backend::CrosstermBackend,
};
use std::io;

use crate::agent::context::SharedContextState;

/// Status info for the bottom status bar.
#[derive(Debug, Clone)]
pub struct StatusInfo {
    pub dmn_state: String,
    pub dmn_turns: u32,
    pub dmn_max_turns: u32,
    pub prompt_tokens: u32,
    pub completion_tokens: u32,
    pub model: String,
    pub turn_tools: u32,
    pub context_budget: String,
}

/// Context loading details for the debug screen.
#[derive(Debug, Clone)]
pub struct ContextInfo {
    pub model: String,
    pub available_models: Vec<String>,
    pub prompt_file: String,
    pub backend: String,
    pub instruction_files: Vec<(String, usize)>,
    pub memory_files: Vec<(String, usize)>,
    pub system_prompt_chars: usize,
    pub context_message_chars: usize,
}

/// Build the screen legend from screen labels.
pub(crate) fn screen_legend_from(screens: &[Box<dyn ScreenView>]) -> String {
    let parts: Vec<String> = screens.iter().enumerate()
        .map(|(i, s)| format!("F{}={}", i + 1, s.label()))
        .collect();
    format!(" {} ", parts.join("  "))
}

// Cached legend — set once at startup by event_loop
static SCREEN_LEGEND: std::sync::OnceLock<String> = std::sync::OnceLock::new();

pub(crate) fn set_screen_legend(legend: String) {
    let _ = SCREEN_LEGEND.set(legend);
}

pub(crate) fn screen_legend() -> String {
    SCREEN_LEGEND.get().cloned().unwrap_or_default()
}

/// Action returned from a screen's tick method.
pub enum ScreenAction {
    /// Switch to screen at this index
    Switch(usize),
    /// Send a hotkey action to the Mind
    Hotkey(HotkeyAction),
}

/// A screen that can draw itself and handle input.
pub(crate) trait ScreenView: Send {
    fn tick(&mut self, frame: &mut ratatui::Frame, area: ratatui::layout::Rect,
            events: &[ratatui::crossterm::event::Event], app: &mut App);
    fn label(&self) -> &'static str;
}

#[derive(Debug)]
pub enum HotkeyAction {
    CycleReasoning, KillProcess, Interrupt, CycleAutonomy,
    /// Adjust a sampling parameter: (param_index, delta)
    /// 0=temperature, 1=top_p, 2=top_k
    AdjustSampling(usize, f32),
}

#[derive(Clone)]
pub(crate) struct IdleInfo {
    pub user_present: bool,
    pub since_activity: f64,
    pub activity_ewma: f64,
    pub block_reason: String,
    pub dreaming: bool,
    pub sleeping: bool,
}

#[derive(Clone)]
pub(crate) struct ChannelStatus {
    pub name: String,
    pub connected: bool,
    pub unread: u32,
}

pub struct App {
    pub(crate) status: StatusInfo,
    pub(crate) activity: String,
    pub running_processes: u32,
    pub reasoning_effort: String,
    pub temperature: f32,
    pub top_p: f32,
    pub top_k: u32,
    pub(crate) active_tools: crate::agent::tools::SharedActiveTools,
    pub should_quit: bool,
    pub submitted: Vec<String>,
    pub(crate) context_info: Option<ContextInfo>,
    pub(crate) shared_context: SharedContextState,
    pub(crate) agent_state: Vec<crate::subconscious::subconscious::AgentSnapshot>,
    pub(crate) channel_status: Vec<ChannelStatus>,
    pub(crate) idle_info: Option<IdleInfo>,
}

impl App {
    pub fn new(model: String, shared_context: SharedContextState, active_tools: crate::agent::tools::SharedActiveTools) -> Self {
        Self {
            status: StatusInfo {
                dmn_state: "resting".into(), dmn_turns: 0, dmn_max_turns: 20,
                prompt_tokens: 0, completion_tokens: 0, model,
                turn_tools: 0, context_budget: String::new(),
            },
            activity: String::new(),
            running_processes: 0,
            reasoning_effort: "none".to_string(),
            temperature: 0.6,
            top_p: 0.95,
            top_k: 20,
            active_tools,
            should_quit: false, submitted: Vec::new(),
            context_info: None, shared_context,
            agent_state: Vec::new(),
            channel_status: Vec::new(), idle_info: None,
        }
    }


    pub fn set_channel_status(&mut self, channels: Vec<(String, bool, u32)>) {
        self.channel_status = channels.into_iter()
            .map(|(name, connected, unread)| ChannelStatus { name, connected, unread })
            .collect();
    }

    pub fn update_idle(&mut self, state: &crate::thalamus::idle::State) {
        self.idle_info = Some(IdleInfo {
            user_present: state.user_present(), since_activity: state.since_activity(),
            activity_ewma: state.activity_ewma, block_reason: state.block_reason().to_string(),
            dreaming: state.dreaming, sleeping: state.sleep_until.is_some(),
        });
    }

}

pub fn init_terminal() -> io::Result<ratatui::Terminal<CrosstermBackend<io::Stdout>>> {
    terminal::enable_raw_mode()?;
    let mut stdout = io::stdout();
    stdout.execute(EnterAlternateScreen)?;
    stdout.execute(EnableMouseCapture)?;
    let backend = CrosstermBackend::new(stdout);
    ratatui::Terminal::new(backend)
}

pub fn restore_terminal(terminal: &mut ratatui::Terminal<CrosstermBackend<io::Stdout>>) -> io::Result<()> {
    terminal::disable_raw_mode()?;
    terminal.backend_mut().execute(DisableMouseCapture)?;
    terminal.backend_mut().execute(LeaveAlternateScreen)?;
    terminal.show_cursor()
}

/// 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 (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, 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,
            ).await;
        });
    });
    result
}

fn hotkey_cycle_reasoning(mind: &crate::mind::Mind) {
    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,
        };
        ag.notify(format!("reasoning: {}", label));
    }
}

async fn hotkey_kill_processes(mind: &crate::mind::Mind) {
    let mut ag = mind.agent.lock().await;
    let active_tools = ag.active_tools.clone();
    let mut tools = active_tools.lock().unwrap();
    if tools.is_empty() {
        ag.notify("no running tools");
    } else {
        let count = tools.len();
        for entry in tools.drain(..) {
            entry.handle.abort();
        }
        ag.notify(format!("killed {} tools", count));
    }
}

fn hotkey_cycle_autonomy(mind: &crate::mind::Mind) {
    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);
    if let Ok(mut ag) = mind.agent.try_lock() {
        ag.notify(format!("DMN → {}", 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,
            _ => {}
        }
    }
}

/// Returns true if this is an event the main loop handles (F-keys, Ctrl combos, resize).
fn is_global_event(event: &ratatui::crossterm::event::Event) -> bool {
    use ratatui::crossterm::event::{Event, KeyCode, KeyModifiers, KeyEventKind};

    match event {
        Event::Key(key) => {
            if key.kind != KeyEventKind::Press { return false; }
            matches!(key.code, KeyCode::F(_))
                || key.modifiers.contains(KeyModifiers::CONTROL)
        }
        Event::Resize(_, _) => true,
        _ => false,
    }
}

pub async fn run(
    mut app: tui::App,
    mind: &crate::mind::Mind,
    mind_tx: tokio::sync::mpsc::UnboundedSender<MindCommand>,
) -> Result<()> {
    let agent = &mind.agent;
    // 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();

    // F1=chat, F2=conscious, F3=subconscious, F4=unconscious, F5=thalamus
    let mut screens: Vec<Box<dyn tui::ScreenView>> = vec![
        Box::new(crate::user::chat::InteractScreen::new(
            mind.agent.clone(), mind.shared.clone(), mind_tx.clone(),
        )),
        Box::new(crate::user::context::ConsciousScreen::new()),
        Box::new(crate::user::subconscious::SubconsciousScreen::new()),
        Box::new(crate::user::unconscious::UnconsciousScreen::new()),
        Box::new(crate::user::thalamus::ThalamusScreen::new()),
    ];
    let mut active_screen: usize = 1; // F-key number
    tui::set_screen_legend(tui::screen_legend_from(&*screens));

    let mut terminal = tui::init_terminal()?;

    // Terminal event reader — dedicated thread reads sync, pushes to channel
    let (event_tx, mut event_rx) = tokio::sync::mpsc::unbounded_channel();
    std::thread::spawn(move || {
        loop {
            match crossterm::event::read() {
                Ok(event) => { if event_tx.send(event).is_err() { break; } }
                Err(_) => break,
            }
        }
    });

    let agent_changed = agent.lock().await.changed.clone();
    let mut turn_watch = mind.turn_watch();
    let mut pending: Vec<ratatui::crossterm::event::Event> = Vec::new();

    terminal.hide_cursor()?;

    if let Ok(mut ag) = agent.try_lock() { ag.notify("consciousness v0.3"); }

    // Initial render
    {
        let mut frame = terminal.get_frame();
        let area = frame.area();
        screens[active_screen - 1].tick(&mut frame, area, &[], &mut app);
        drop(frame);
        terminal.flush()?;
        terminal.swap_buffers();
        terminal.backend_mut().flush()?;
    }

    // Replay conversation after Mind init completes (non-blocking check)
    let mut startup_done = false;
    let mut dirty = true; // render on first loop

    loop {
        tokio::select! {
            biased;

            Some(event) = event_rx.recv() => {
                pending.push(event);
                while let Ok(event) = event_rx.try_recv() {
                    pending.push(event);
                }
            }

            _ = agent_changed.notified() => {
                dirty = true;
            }

            _ = turn_watch.changed() => {
                dirty = true;
            }

            Some(channels) = channel_rx.recv() => {
                app.set_channel_status(channels);
            }
        }

        // State sync on every wake
        idle_state.decay_ewma();
        app.update_idle(&idle_state);
        if !startup_done {
            if let Ok(mut ag) = agent.try_lock() {
                let model = ag.model().to_string();
                ag.notify(format!("model: {}", model));
                startup_done = true;
            }
        }

        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;
            });
        }

        if !pending.is_empty() { idle_state.user_activity(); }

        while !pending.is_empty() || dirty {
            let global_pos = pending.iter().position(|e| is_global_event(e))
                .unwrap_or(pending.len());

            let mut frame = terminal.get_frame();
            let area = frame.area();
            screens[active_screen - 1].tick(&mut frame, area, &pending[..global_pos], &mut app);
            drop(frame);
            terminal.flush()?;
            terminal.swap_buffers();
            terminal.backend_mut().flush()?;
            dirty = false;

            pending = pending.split_off(global_pos);
            if pending.is_empty() { break; }

            dirty = true;

            // Global event is first — handle it
            use ratatui::crossterm::event::{Event, KeyCode, KeyModifiers};
            let event = pending.remove(0);
            match event {
                Event::Key(key) => {
                    if let KeyCode::F(n) = key.code {
                        let idx = n as usize;
                        if idx >= 1 && idx <= screens.len() {
                            active_screen = idx;
                            // Refresh context state when switching to the conscious screen
                            if idx == 2 {
                                if let Ok(mut ag) = agent.try_lock() {
                                    ag.publish_context_state();
                                }
                            }
                        }
                    } else if key.modifiers.contains(KeyModifiers::CONTROL) {
                        match key.code {
                            KeyCode::Char('c') => { app.should_quit = true; }
                            KeyCode::Char('r') => hotkey_cycle_reasoning(mind),
                            KeyCode::Char('k') => hotkey_kill_processes(mind).await,
                            KeyCode::Char('p') => hotkey_cycle_autonomy(mind),
                            _ => {}
                        }
                    }
                }
                Event::Resize(_, _) => {
                    let _ = terminal.autoresize();
                    let _ = terminal.clear();
                }
                _ => {}
            }
        }

        if app.should_quit {
            break;
        }
    }

    tui::restore_terminal(&mut terminal)?;
    Ok(())
}

// --- CLI ---

use clap::{Parser, Subcommand};
use std::path::PathBuf;

#[derive(Parser, Debug)]
#[command(name = "consciousness", about = "Substrate-independent AI agent")]
pub struct CliArgs {
    /// Select active backend ("anthropic" or "openrouter")
    #[arg(long)]
    pub backend: Option<String>,

    /// Model override
    #[arg(short, long)]
    pub model: Option<String>,

    /// API key override
    #[arg(long)]
    pub api_key: Option<String>,

    /// Base URL override
    #[arg(long)]
    pub api_base: Option<String>,

    /// Enable debug logging
    #[arg(long)]
    pub debug: bool,

    /// Print effective config with provenance and exit
    #[arg(long)]
    pub show_config: bool,

    /// Override all prompt assembly with this file
    #[arg(long)]
    pub system_prompt_file: Option<PathBuf>,

    /// Project memory directory
    #[arg(long)]
    pub memory_project: Option<PathBuf>,

    /// Max consecutive DMN turns
    #[arg(long)]
    pub dmn_max_turns: Option<u32>,

    /// Disable background agents (surface, observe, scoring)
    #[arg(long)]
    pub no_agents: bool,

    #[command(subcommand)]
    pub command: Option<SubCmd>,
}

#[derive(Subcommand, Debug)]
pub enum SubCmd {
    /// Print new output since last read and exit
    Read {
        /// Stream output continuously instead of exiting
        #[arg(short, long)]
        follow: bool,
        /// Block until a complete response is received, then exit
        #[arg(long)]
        block: bool,
    },
    /// Send a message to the running agent
    Write {
        /// The message to send
        message: Vec<String>,
    },
}

#[tokio::main]
pub async fn main() {
    let cli = CliArgs::parse();

    if cli.show_config {
        match crate::config::load_app(&cli) {
            Ok((app, figment)) => crate::config::show_config(&app, &figment),
            Err(e) => {
                eprintln!("Error loading config: {:#}", e);
                std::process::exit(1);
            }
        }
        return;
    }

    if let Err(e) = start(cli).await {
        let _ = ratatui::crossterm::terminal::disable_raw_mode();
        let _ = ratatui::crossterm::execute!(
            std::io::stdout(),
            ratatui::crossterm::terminal::LeaveAlternateScreen
        );
        eprintln!("Error: {:#}", e);
        std::process::exit(1);
    }
}