polypty 0.1.0

Agent-aware terminal multiplexer with sidebar tabs and nested panes
Documentation
use std::time::{Duration, Instant};

use crate::agent::{self, AgentKind, AgentState, AgentStatus};

use super::{activity::AgentActivity, signature::screen_signature, Tab};

pub(super) struct AgentTracker {
    kind: Option<AgentKind>,
    state: Option<AgentState>,
    title_updated_at: Option<Instant>,
    activity: AgentActivity,
    screen_signature: Option<u64>,
    last_scan: Instant,
}

impl AgentTracker {
    pub fn new(now: Instant) -> Self {
        Self {
            kind: None,
            state: None,
            title_updated_at: None,
            activity: AgentActivity::default(),
            screen_signature: None,
            last_scan: now - Duration::from_secs(10),
        }
    }

    pub fn note_input(&mut self, data: &[u8], now: Instant) {
        self.activity.note_input(data, now);
    }

    pub fn note_resize(&mut self, screen: &vt100::Screen, now: Instant) {
        self.activity.note_resize(now);
        self.screen_signature = self.kind.map(|_| screen_signature(screen));
    }

    pub fn note_title_update(&mut self, now: Instant) {
        self.title_updated_at = Some(now);
    }

    pub fn note_output(&mut self, screen: &vt100::Screen, now: Instant) {
        let current = self.kind.map(|_| screen_signature(screen));
        let changed = self
            .screen_signature
            .zip(current)
            .is_some_and(|(before, after)| before != after);
        self.screen_signature = current;
        self.activity.note_output(now, changed);
    }

    pub fn refresh(
        &mut self,
        process: Option<&str>,
        screen: &vt100::Screen,
        osc_title: Option<&str>,
        now: Instant,
        force: bool,
    ) -> bool {
        if !force && now.duration_since(self.last_scan) < agent::SCAN_INTERVAL {
            return false;
        }
        self.last_scan = now;
        let next_kind = process.and_then(agent::identify_name);
        if next_kind != self.kind {
            self.kind = next_kind;
            self.state = next_kind.map(|_| AgentState::Ready);
            self.reset_evidence(next_kind.map(|_| screen_signature(screen)));
            return true;
        }

        let next_state = next_kind.map(|kind| {
            let title = recent_osc_title(osc_title, self.title_updated_at, now);
            let previous = self.state.unwrap_or(AgentState::Ready);
            agent::detect_state(
                kind,
                screen,
                title,
                self.activity.observation(previous, now),
            )
        });
        if next_state == self.state {
            return false;
        }
        self.state = next_state;
        true
    }

    pub fn status(&self) -> Option<AgentStatus> {
        self.kind
            .zip(self.state)
            .map(|(kind, state)| AgentStatus::single(kind, state))
    }

    #[cfg(test)]
    pub(super) fn evidence_snapshot(
        &self,
        now: Instant,
    ) -> (Option<Instant>, Option<u64>, Duration) {
        (
            self.title_updated_at,
            self.screen_signature,
            self.activity.observation(AgentState::Ready, now).quiet_for,
        )
    }

    fn reset_evidence(&mut self, next_signature: Option<u64>) {
        self.activity.reset();
        self.title_updated_at = None;
        self.screen_signature = next_signature;
    }
}

impl Tab {
    pub(super) fn refresh_agent_status(&mut self, now: Instant, force: bool) -> bool {
        let changed = self.agent.refresh(
            self.metadata.process(),
            self.terminal.screen(),
            self.terminal.title(),
            now,
            force,
        );
        if changed {
            self.recompose();
        }
        changed
    }
}

pub(super) fn recent_osc_title(
    title: Option<&str>,
    updated_at: Option<Instant>,
    now: Instant,
) -> Option<&str> {
    updated_at
        .filter(|updated| now.saturating_duration_since(*updated) <= agent::ACTIVITY_WINDOW)
        .and(title)
}