Method run

atomic-cli/src/commands/agent/explain.rs:116–348

(&self)

impl Command for Explain {
    fn run(&self) -> CliResult<()> {
        let repo_root = find_repository_root()?;

        // Load the session to get the view name
        let session_store =
            SessionStore::for_repo(&repo_root).map_err(|e| CliError::InvalidRepository {
                reason: format!("Failed to open session store: {}", e),
            })?;

        let session = session_store
            .load(&self.session_id)
            .map_err(|e| CliError::Internal(anyhow::anyhow!("Failed to load session: {}", e)))?
            .ok_or_else(|| CliError::InvalidArgument {
                message: format!(
                    "Session '{}' not found. Use 'atomic agent status' to see available sessions.",
                    self.session_id
                ),
            })?;

        // Open the repository
        let repo = Repository::open(&repo_root)?;

        // Get the changes on the agent view
        let history_options = HistoryOptions::with_headers().view(&session.view_name);

        let entries = repo.log(history_options).map_err(|e| match e {
            atomic_repository::RepositoryError::ViewNotFound { name } => {
                CliError::ViewNotFound { name }
            }
            other => CliError::Repository(other),
        })?;

        if entries.is_empty() {
            println!(
                "Session '{}' has no recorded turns on view '{}'.",
                self.session_id, session.view_name,
            );
            return Ok(());
        }

        // Determine which turns to explain
        let turns_to_explain: Vec<usize> = if self.all {
            (0..entries.len()).collect()
        } else if let Some(turn_num) = self.turn {
            let idx =
                (turn_num as usize)
                    .checked_sub(1)
                    .ok_or_else(|| CliError::InvalidArgument {
                        message: "Turn number must be >= 1".to_string(),
                    })?;
            if idx >= entries.len() {
                return Err(CliError::InvalidArgument {
                    message: format!(
                        "Turn {} not found. Session has {} turn{}.",
                        turn_num,
                        entries.len(),
                        if entries.len() == 1 { "" } else { "s" }
                    ),