rho-coding-agent 2.19.0

use super::{agent_picker::InternalAgentModelPickerOrigin, App, ComposerMode, InteractiveRuntime};
use crate::{
    agent::{effective_internal_agent_reasoning, PERMISSION_CLASSIFIER_AGENT_ID},
    permission::PermissionMode,
};

const SELECT_CLASSIFIER_MODEL_STATUS: &str =
    "select a permission classifier model to turn Auto mode on";
const SELECT_CLASSIFIER_MODEL_EDIT_STATUS: &str = "select a permission classifier model";
const SELECT_CLASSIFIER_MODEL_STARTUP_STATUS: &str =
    "select a permission classifier model for Auto mode";

/// Whether a TUI mode change becomes the saved default for future launches.
#[derive(Clone, Copy, PartialEq, Eq)]
pub(super) enum PermissionPersistence {
    /// Write the mode to config, like `/permissions`.
    Save,
    /// Keep the mode for this process only, across `/new` and `/resume`.
    /// The next launch starts in the saved mode.
    UntilExit,
}

/// Cycle from most restrictive to least restrictive, then wrap back to Plan.
/// Auto is only reachable when the session has a classifier model configured.
fn next_cycle_mode(current: PermissionMode, classifier_configured: bool) -> PermissionMode {
    let mut modes = PermissionMode::ALL;
    modes.sort_by_key(|mode| mode.restrictiveness_rank());
    modes
        .iter()
        .copied()
        .filter(|mode| classifier_configured || *mode != PermissionMode::Auto)
        .find(|mode| mode.restrictiveness_rank() > current.restrictiveness_rank())
        .unwrap_or(modes[0])
}

impl App {
    pub(super) fn queue_permission_mode_cycle(&mut self) {
        let current = self
            .pending_permission_mode
            .unwrap_or(self.info.runtime.permission_mode);
        let next = next_cycle_mode(current, self.permission_classifier_model_configured());
        self.pending_permission_mode = Some(next);
        self.set_status(format!(
            "permission mode {} queued for next turn",
            next.as_str()
        ));
    }

    pub(super) async fn cycle_permission_mode(
        &mut self,
        agent: &mut InteractiveRuntime,
    ) -> anyhow::Result<()> {
        if agent.is_session_busy() {
            self.queue_permission_mode_cycle();
            return Ok(());
        }
        let next = next_cycle_mode(
            self.info.runtime.permission_mode,
            self.permission_classifier_model_configured(),
        );
        self.apply_permission_mode(next, PermissionPersistence::UntilExit, agent)
            .await
    }

    /// Apply queued changes only after the runtime releases the active run or
    /// compaction. Used at turn end and before idle follow-ups can start.
    pub(super) async fn apply_pending_permission_mode(
        &mut self,
        agent: &mut InteractiveRuntime,
    ) -> anyhow::Result<bool> {
        if agent.is_session_busy() {
            return Ok(false);
        }
        let Some(mode) = self.pending_permission_mode.take() else {
            return Ok(false);
        };
        self.apply_permission_mode(mode, PermissionPersistence::UntilExit, agent)
            .await?;
        Ok(true)
    }

    pub(super) async fn execute_permissions_command(
        &mut self,
        invocation: super::CommandInvocation,
        agent: &mut InteractiveRuntime,
    ) -> anyhow::Result<()> {
        let args = invocation.args.trim();
        if args.is_empty() {
            self.insert_entry(&super::Entry::Notice(format!(
                "permission mode: {}. usage: /permissions [bypass|auto|allow_edits|plan|supervised]",
                agent.permission_mode().as_str()
            )));
            return Ok(());
        }
        let mode = match args.parse::<PermissionMode>() {
            Ok(mode) => mode,
            Err(error) => {
                self.insert_entry(&super::Entry::Error(format!(
                    "could not change permission mode: {error}"
                )));
                return Ok(());
            }
        };
        if agent.is_session_busy() {
            if agent.is_compacting() {
                self.set_status("permission mode cannot change while compaction is active");
            } else {
                self.reject_permission_mode_change();
            }
            return Ok(());
        }
        if mode == PermissionMode::Auto && !self.permission_classifier_model_configured() {
            if !self.open_permission_classifier_model_prompt(
                InternalAgentModelPickerOrigin::PermissionModeCommand,
            ) {
                self.set_status(
                    "could not enable auto: no classifier model available; use /refresh-models",
                );
            }
            return Ok(());
        }
        if let Err(error) = self
            .apply_permission_mode(mode, PermissionPersistence::Save, agent)
            .await
        {
            self.insert_entry(&super::Entry::Error(format!(
                "could not change permission mode: {error}"
            )));
        }
        Ok(())
    }

    pub(super) async fn select_permission_mode_from_config(
        &mut self,
        mode: PermissionMode,
        agent: &mut InteractiveRuntime,
    ) -> anyhow::Result<()> {
        if mode == PermissionMode::Auto && !self.permission_classifier_model_configured() {
            self.open_permission_classifier_model_prompt(
                InternalAgentModelPickerOrigin::PermissionModeConfigRow,
            );
            return Ok(());
        }
        self.apply_permission_mode(mode, PermissionPersistence::Save, agent)
            .await?;
        self.open_main_config_picker_selected(super::config_picker::PERMISSION_MODE_VALUE)
    }

    pub(super) async fn apply_permission_mode(
        &mut self,
        mode: PermissionMode,
        persistence: PermissionPersistence,
        agent: &mut InteractiveRuntime,
    ) -> anyhow::Result<()> {
        let previous = agent.permission_mode();
        let previous_config = agent.config_snapshot();
        let mut current_config = previous_config.clone();
        current_config
            .internal_agents
            .clone_from(&self.info.runtime.internal_agents);
        current_config.permission_mode = self.info.runtime.permission_mode;
        agent.update_config(current_config);
        if let Err(error) = agent.set_permission_mode(mode).await {
            agent.update_config(previous_config);
            return Err(error);
        }
        let save_result = match persistence {
            PermissionPersistence::Save => self.info.services.config_repository.update(|config| {
                config.permission_mode = mode;
            }),
            PermissionPersistence::UntilExit => Ok(()),
        };
        if let Err(error) = save_result {
            if let Err(rollback_error) = agent.set_permission_mode(previous).await {
                return Err(anyhow::anyhow!(
                    "could not save permission mode: {error}; runtime rollback failed: {rollback_error}"
                ));
            }
            agent.update_config(previous_config);
            return Err(error);
        }
        self.info.runtime.permission_mode = mode;
        let mut applied_config = agent.config_snapshot();
        applied_config.permission_mode = mode;
        agent.update_config(applied_config);
        self.set_status(format!("permission mode: {}", mode.as_str()));
        Ok(())
    }

    pub(super) fn permission_classifier_model_configured(&self) -> bool {
        self.info
            .runtime
            .internal_agents
            .contains_key(PERMISSION_CLASSIFIER_AGENT_ID)
    }

    /// Keeps interactive Auto consistent with a configured classifier model.
    ///
    /// Call from idle transitions that land on a free composer (startup, resume,
    /// setup finish, full picker dismiss). Drains a pending startup-dismiss
    /// demote first, then opens the classifier picker when Auto is active
    /// without a model. No-op while setup or another picker owns the composer.
    pub(super) async fn reconcile_auto_classifier_gate(
        &mut self,
        agent: &mut InteractiveRuntime,
    ) -> anyhow::Result<()> {
        if self.pending_auto_classifier_demote {
            self.pending_auto_classifier_demote = false;
            if self.info.runtime.permission_mode == PermissionMode::Auto
                && !self.permission_classifier_model_configured()
            {
                self.fallback_auto_without_classifier(agent).await?;
            }
            return Ok(());
        }
        if self.exclusive.setup_step().is_some() {
            return Ok(());
        }
        if !matches!(self.input_ui.composer(), ComposerMode::Input) {
            return Ok(());
        }
        if self.info.runtime.permission_mode != PermissionMode::Auto {
            return Ok(());
        }
        if self.permission_classifier_model_configured() {
            return Ok(());
        }
        if self.open_permission_classifier_model_prompt(
            InternalAgentModelPickerOrigin::PermissionModeStartup,
        ) {
            return Ok(());
        }
        // Empty model catalog: Auto would fail closed on every gated tool.
        // Drop to Supervised so the session can still ask a human.
        self.apply_permission_mode(
            PermissionMode::Supervised,
            PermissionPersistence::Save,
            agent,
        )
        .await?;
        self.set_status(
            "permission mode set to supervised: no classifier model available; use Config > Refresh model lists",
        );
        Ok(())
    }

    pub(super) fn open_permission_classifier_model_prompt(
        &mut self,
        origin: InternalAgentModelPickerOrigin,
    ) -> bool {
        if !self.open_internal_agent_model_picker(PERMISSION_CLASSIFIER_AGENT_ID, origin) {
            return false;
        }
        let status = match origin {
            InternalAgentModelPickerOrigin::PermissionClassifierModelConfigRow => {
                SELECT_CLASSIFIER_MODEL_EDIT_STATUS
            }
            InternalAgentModelPickerOrigin::PermissionModeStartup => {
                SELECT_CLASSIFIER_MODEL_STARTUP_STATUS
            }
            InternalAgentModelPickerOrigin::AgentsPicker
            | InternalAgentModelPickerOrigin::AdvisorCommand
            | InternalAgentModelPickerOrigin::AdvisorModelCommand
            | InternalAgentModelPickerOrigin::AdvisorConfigRow
            | InternalAgentModelPickerOrigin::AdvisorModelConfigRow
            | InternalAgentModelPickerOrigin::PermissionModeCommand
            | InternalAgentModelPickerOrigin::PermissionModeConfigRow
            | InternalAgentModelPickerOrigin::PermissionScreenModelConfigRow
            | InternalAgentModelPickerOrigin::PermissionScreenSetupConfigRow
            | InternalAgentModelPickerOrigin::PermissionScreenSetupCommand => {
                SELECT_CLASSIFIER_MODEL_STATUS
            }
        };
        self.set_status(status);
        true
    }

    pub(super) async fn finish_permission_classifier_model_selection(
        &mut self,
        selected: bool,
        origin: InternalAgentModelPickerOrigin,
        agent: &mut InteractiveRuntime,
    ) -> anyhow::Result<()> {
        // `selected == false` means model resolve failed after confirm, not Esc.
        // Cancel/demote lives only in cancel_permission_classifier_model_prompt.
        if !selected {
            return Ok(());
        }
        match origin {
            InternalAgentModelPickerOrigin::PermissionModeConfigRow
            | InternalAgentModelPickerOrigin::PermissionModeCommand => {
                self.apply_permission_mode(
                    PermissionMode::Auto,
                    PermissionPersistence::Save,
                    agent,
                )
                .await?;
            }
            InternalAgentModelPickerOrigin::PermissionModeStartup => {
                // Auto is already active; the picker only stored the model.
                self.pending_auto_classifier_demote = false;
                self.sync_permission_classifier_runtime_config(agent);
                self.set_status("permission mode: auto");
            }
            _ => {}
        }
        Ok(())
    }

    /// Startup Auto without a classifier cannot run gated tools. Supervised keeps
    /// the same capability gate and asks a human instead.
    pub(super) async fn fallback_auto_without_classifier(
        &mut self,
        agent: &mut InteractiveRuntime,
    ) -> anyhow::Result<()> {
        self.apply_permission_mode(
            PermissionMode::Supervised,
            PermissionPersistence::Save,
            agent,
        )
        .await?;
        self.set_status("permission mode set to supervised: no classifier model selected");
        Ok(())
    }

    /// Dismisses a pending classifier prompt opened to enable or repair Auto.
    /// Startup dismiss only marks a demote; [`Self::reconcile_auto_classifier_gate`]
    /// applies it once an idle path has a runtime handle.
    pub(super) fn cancel_permission_classifier_model_prompt(
        &mut self,
        restore_input: bool,
    ) -> bool {
        let origin = match self.internal_agent_model_target.as_ref() {
            Some(target)
                if target.id == PERMISSION_CLASSIFIER_AGENT_ID
                    && matches!(
                        target.origin,
                        InternalAgentModelPickerOrigin::PermissionModeConfigRow
                            | InternalAgentModelPickerOrigin::PermissionModeCommand
                            | InternalAgentModelPickerOrigin::PermissionModeStartup
                    ) =>
            {
                target.origin
            }
            _ => return false,
        };
        self.internal_agent_model_target = None;
        if restore_input {
            self.input_ui.set_composer(ComposerMode::Input);
        }
        match origin {
            InternalAgentModelPickerOrigin::PermissionModeConfigRow
            | InternalAgentModelPickerOrigin::PermissionModeCommand => {
                self.set_status(format!(
                    "permission mode stays {}: no classifier model selected",
                    self.info.runtime.permission_mode.as_str()
                ));
            }
            InternalAgentModelPickerOrigin::PermissionModeStartup => {
                self.pending_auto_classifier_demote = true;
                self.set_status("permission mode set to supervised: no classifier model selected");
            }
            _ => {}
        }
        true
    }

    pub(super) fn cycle_permission_classifier_reasoning(
        &mut self,
        agent: &mut InteractiveRuntime,
    ) -> anyhow::Result<()> {
        let Some(mut selection) = self
            .info
            .runtime
            .internal_agents
            .get(PERMISSION_CLASSIFIER_AGENT_ID)
            .cloned()
        else {
            self.set_status("select a permission classifier model first");
            return Ok(());
        };
        let capabilities = crate::agent::internal_agent_reasoning_capabilities(&selection);
        if capabilities == rho_providers::model::ReasoningCapabilities::NotConfigurable {
            return Ok(());
        }
        let current =
            effective_internal_agent_reasoning(PERMISSION_CLASSIFIER_AGENT_ID, &selection);
        let reasoning = capabilities.next_level(current);
        selection.reasoning = Some(reasoning);
        self.info
            .runtime
            .internal_agents
            .insert(PERMISSION_CLASSIFIER_AGENT_ID.into(), selection.clone());
        match self.info.services.config_repository.update(|config| {
            config.set_internal_agent_model_config(PERMISSION_CLASSIFIER_AGENT_ID, selection);
        }) {
            Ok(()) => {
                self.set_status(format!("permission classifier reasoning: {reasoning}"));
            }
            Err(err) => {
                self.insert_entry(&super::Entry::Error(format!(
                    "permission classifier reasoning set to {reasoning} for this session, but saving config failed: {err}"
                )));
                self.set_status("config save failed");
            }
        }
        if self.info.runtime.permission_mode == PermissionMode::Auto {
            self.sync_permission_classifier_runtime_config(agent);
        }
        Ok(())
    }

    pub(super) fn sync_permission_classifier_runtime_config(&self, agent: &mut InteractiveRuntime) {
        let mut config = agent.config_snapshot();
        config
            .internal_agents
            .clone_from(&self.info.runtime.internal_agents);
        config.permission_mode = self.info.runtime.permission_mode;
        agent.update_config(config);
    }

    /// Hands the classifier settings saved by an editor that had no agent,
    /// such as the screen allow threshold. Runs on each idle pass and before
    /// each turn starts, so the next classification sees them.
    pub(super) fn apply_pending_classifier_config(&mut self, agent: &mut InteractiveRuntime) {
        if std::mem::take(&mut self.classifier_config_sync_pending) {
            self.sync_permission_classifier_runtime_config(agent);
        }
    }

    pub(super) fn reject_permission_mode_change(&mut self) {
        self.set_status("permission mode cannot change until the current turn finishes");
    }
}

#[cfg(test)]
#[path = "permission_mode_tests.rs"]
mod tests;