handler.rs

//! REPL handler implementation

#[cfg(feature = "repl-sessions")]
use super::commands::SessionsSubcommand;
use super::commands::{
    ConfigSubcommand, ReplCommand, RobotSubcommand, RoleSubcommand, UpdateSubcommand,
};
#[cfg(feature = "server")]
use crate::client::ApiClient;
use crate::service::TuiService;

// Import robot module types
use crate::forgiving::parser::ForgivingParser;
use crate::robot::{ExitCode, SelfDocumentation};

#[cfg(feature = "repl-mcp")]
use crate::repl::mcp_tools::McpToolsHandler;
use anyhow::Result;
use std::io::{self, Write};
use std::str::FromStr;

#[cfg(feature = "repl")]
use rustyline::Editor;

#[cfg(feature = "repl")]
use colored::Colorize;

pub struct ReplHandler {
    service: Option<TuiService>,
    #[cfg(feature = "server")]
    api_client: Option<ApiClient>,
    current_role: String,
    #[cfg(feature = "repl-mcp")]
    mcp_handler: Option<McpToolsHandler>,
}

impl ReplHandler {
    pub fn new_offline(service: TuiService) -> Self {
        #[cfg(feature = "repl-mcp")]
        let mcp_handler = {
            let service_arc = std::sync::Arc::new(service.clone());
            Some(McpToolsHandler::new(service_arc))
        };

        Self {
            service: Some(service),
            #[cfg(feature = "server")]
            api_client: None,
            current_role: "Default".to_string(),
            #[cfg(feature = "repl-mcp")]
            mcp_handler,
        }
    }

    #[cfg(feature = "server")]
    pub fn new_server(api_client: ApiClient) -> Self {
        Self {
            service: None,
            api_client: Some(api_client),
            current_role: "Terraphim Engineer".to_string(),
            #[cfg(feature = "repl-mcp")]
            mcp_handler: None,
        }
    }

    #[cfg(feature = "repl")]
    pub async fn run(&mut self) -> Result<()> {
        use rustyline::completion::{Completer, Pair};
        use rustyline::highlight::Highlighter;
        use rustyline::hint::Hinter;
        use rustyline::validate::Validator;
        use rustyline::{Context, Helper};

        if let Some(service) = &self.service {
            let selected = service.get_selected_role().await;
            self.current_role = selected.to_string();
        }

        // Create a command completer
        #[derive(Clone)]
        struct CommandCompleter;

        impl Helper for CommandCompleter {}
        impl Hinter for CommandCompleter {
            type Hint = String;

            fn hint(&self, _line: &str, _pos: usize, _ctx: &Context<'_>) -> Option<String> {
                None
            }
        }

        impl Highlighter for CommandCompleter {}
        impl Validator for CommandCompleter {}

        impl Completer for CommandCompleter {
            type Candidate = Pair;

            fn complete(
                &self,
                line: &str,
                pos: usize,
                _ctx: &Context<'_>,
            ) -> rustyline::Result<(usize, Vec<Pair>)> {
                let line = &line[..pos];

                if line.starts_with('/') || line.is_empty() {
                    let prefix = if let Some(stripped) = line.strip_prefix('/') {
                        stripped
                    } else {
                        line
                    };
                    let commands = ReplCommand::available_commands();

                    let matches: Vec<Pair> = commands
                        .into_iter()
                        .filter(|cmd| cmd.starts_with(prefix))
                        .map(|cmd| Pair {
                            display: format!("/{}", cmd),
                            replacement: format!("/{}", cmd),
                        })
                        .collect();

                    let start_pos = if line.starts_with('/') {
                        pos - prefix.len() - 1
                    } else {
                        0
                    };
                    Ok((start_pos, matches))
                } else {
                    Ok((pos, Vec::new()))
                }
            }
        }

        let mut rl = Editor::<CommandCompleter, rustyline::history::DefaultHistory>::new()?;
        rl.set_helper(Some(CommandCompleter));

        // Load command history if it exists
        let history_file = dirs::home_dir()
            .map(|h| h.join(".terraphim_tui_history"))
            .unwrap_or_else(|| std::path::PathBuf::from(".terraphim_tui_history"));

        let _ = rl.load_history(&history_file);

        println!("{}", "=".repeat(60).cyan());
        println!("{}", "🌍 Terraphim TUI REPL".bold().cyan());
        println!("{}", "=".repeat(60).cyan());
        self.show_welcome().await;
        println!();

        loop {
            let prompt = format!("{}> ", self.current_role.green().bold());

            match rl.readline(&prompt) {
                Ok(line) => {
                    let line = line.trim();
                    if line.is_empty() {
                        continue;
                    }

                    rl.add_history_entry(line)?;

                    match self.execute_command(line).await {
                        Ok(should_exit) => {
                            if should_exit {
                                break;
                            }
                        }
                        Err(e) => {
                            println!("{} {}", "Error:".red().bold(), e);
                        }
                    }
                }
                Err(rustyline::error::ReadlineError::Interrupted) => {
                    println!("^C");
                    break;
                }
                Err(rustyline::error::ReadlineError::Eof) => {
                    println!("^D");
                    break;
                }
                Err(err) => {
                    println!("{} Failed to read line: {:?}", "Error:".red().bold(), err);
                    break;
                }
            }
        }

        // Save command history
        let _ = rl.save_history(&history_file);
        println!("{}", "Goodbye! 👋".cyan());

        Ok(())
    }

    #[cfg(not(feature = "repl"))]
    pub async fn run(&mut self) -> Result<()> {
        println!("REPL feature not enabled. Please rebuild with --features repl");
        Ok(())
    }

    async fn show_welcome(&self) {
        println!(
            "Type {} for help, {} to exit",
            "/help".yellow(),
            "/quit".yellow()
        );

        let mode = if self.service.is_some() {
            "Offline Mode"
        } else {
            "Server Mode"
        };

        println!(
            "Mode: {} | Current Role: {}",
            mode.bold(),
            self.current_role.green().bold()
        );

        self.show_available_commands();
    }

    #[cfg(feature = "repl")]
    fn show_available_commands(&self) {
        println!("\n{}", "Available commands:".bold());
        println!("  {} - Search documents", "/search <query>".yellow());
        println!("  {} - Manage configuration", "/config [show|set]".yellow());
        println!("  {} - Manage roles", "/role [list|select]".yellow());
        println!("  {} - Show knowledge graph", "/graph".yellow());

        #[cfg(feature = "llm")]
        {
            println!("  {} - Chat with AI", "/chat [message]".yellow());
            println!("  {} - Summarize content", "/summarize <target>".yellow());
        }

        #[cfg(feature = "repl-mcp")]
        {
            println!(
                "  {} - Autocomplete terms",
                "/autocomplete <query>".yellow()
            );
            println!("  {} - Extract paragraphs", "/extract <text>".yellow());
            println!("  {} - Find matches", "/find <text>".yellow());
            println!("  {} - Replace matches", "/replace <text>".yellow());
            println!("  {} - Show thesaurus", "/thesaurus".yellow());
        }

        println!(
            "  {} - Manage updates (check, install, rollback, list)",
            "/update <subcommand>".yellow()
        );
        println!("  {} - Show help", "/help [command]".yellow());
        println!("  {} - Exit REPL", "/quit".yellow());
    }

    #[cfg(not(feature = "repl"))]
    fn show_available_commands(&self) {
        println!("REPL commands not available without repl feature");
    }

    async fn execute_command(&mut self, input: &str) -> Result<bool> {
        let parser = ForgivingParser::new(
            ReplCommand::available_commands()
                .into_iter()
                .map(String::from)
                .collect(),
        );
        let parse_result = parser.parse(input.trim());

        let (effective_input, correction_msg) = match parse_result {
            crate::forgiving::parser::ParseResult::Exact { .. } => (input.to_string(), None),
            crate::forgiving::parser::ParseResult::AliasExpanded {
                original,
                command,
                args,
            } => {
                let reconstructed = if args.is_empty() {
                    format!("/{}", command)
                } else {
                    format!("/{} {}", command, args)
                };
                (
                    reconstructed,
                    Some(format!("[alias] {} -> {}", original, command)),
                )
            }
            crate::forgiving::parser::ParseResult::AutoCorrected {
                original,
                command,
                distance,
                args,
            } => {
                let reconstructed = if args.is_empty() {
                    format!("/{}", command)
                } else {
                    format!("/{} {}", command, args)
                };
                (
                    reconstructed,
                    Some(format!(
                        "[auto-corrected] {} -> {} (distance={})",
                        original, command, distance
                    )),
                )
            }
            crate::forgiving::parser::ParseResult::Suggestions {
                original,
                suggestions,
            } => {
                #[cfg(feature = "repl")]
                {
                    use colored::Colorize;
                    println!(
                        "{} Unknown command: {}",
                        "X".red().bold(),
                        original.yellow()
                    );
                    if !suggestions.is_empty() {
                        println!(
                            "  {} Did you mean: {}?",
                            "hint:".blue(),
                            suggestions
                                .iter()
                                .take(3)
                                .map(|s| s.command.green().to_string())
                                .collect::<Vec<_>>()
                                .join(", ")
                        );
                    }
                }
                return Ok(false);
            }
            crate::forgiving::parser::ParseResult::Unknown { original } => {
                #[cfg(feature = "repl")]
                {
                    use colored::Colorize;
                    println!(
                        "{} Unknown command: {}",
                        "X".red().bold(),
                        original.yellow()
                    );
                }
                return Ok(false);
            }
            crate::forgiving::parser::ParseResult::Empty => {
                return Ok(false);
            }
        };

        if let Some(msg) = &correction_msg {
            #[cfg(feature = "repl")]
            {
                use colored::Colorize;
                eprintln!("{}", msg.blue());
            }
            #[cfg(not(feature = "repl"))]
            {
                let _ = msg;
            }
        }

        let command = ReplCommand::from_str(&effective_input)?;

        match command {
            ReplCommand::Search {
                query,
                role,
                limit,
                semantic,
                concepts,
            } => {
                self.handle_search(query, role, limit, semantic, concepts)
                    .await?;
            }
            ReplCommand::Config { subcommand } => {
                self.handle_config(subcommand).await?;
            }
            ReplCommand::Role { subcommand } => {
                self.handle_role(subcommand).await?;
            }
            ReplCommand::Graph { top_k } => {
                self.handle_graph(top_k).await?;
            }
            ReplCommand::Help { command } => {
                self.handle_help(command).await?;
            }
            ReplCommand::Quit | ReplCommand::Exit => {
                return Ok(true);
            }
            ReplCommand::Clear => {
                self.handle_clear().await?;
            }

            #[cfg(feature = "llm")]
            ReplCommand::Chat { message } => {
                self.handle_chat(message).await?;
            }

            #[cfg(feature = "llm")]
            ReplCommand::Summarize { target } => {
                self.handle_summarize(target).await?;
            }

            #[cfg(feature = "repl-mcp")]
            ReplCommand::Autocomplete { query, limit } => {
                self.handle_autocomplete(query, limit).await?;
            }

            #[cfg(feature = "repl-mcp")]
            ReplCommand::Extract { text, exclude_term } => {
                self.handle_extract(text, exclude_term).await?;
            }

            #[cfg(feature = "repl-mcp")]
            ReplCommand::Find { text } => {
                self.handle_find(text).await?;
            }

            #[cfg(feature = "repl-mcp")]
            ReplCommand::Replace { text, format } => {
                self.handle_replace(text, format).await?;
            }

            #[cfg(feature = "repl-mcp")]
            ReplCommand::Thesaurus { role } => {
                self.handle_thesaurus(role).await?;
            }

            #[cfg(feature = "repl-file")]
            ReplCommand::File { subcommand } => {
                self.handle_file(subcommand).await?;
            }

            #[cfg(feature = "repl-web")]
            ReplCommand::Web { subcommand } => {
                self.handle_web(subcommand).await?;
            }

            #[cfg(feature = "firecracker")]
            ReplCommand::Vm { subcommand } => {
                self.handle_vm(subcommand).await?;
            }

            ReplCommand::Robot { subcommand } => {
                self.handle_robot(subcommand).await?;
            }

            #[cfg(feature = "repl-sessions")]
            ReplCommand::Sessions { subcommand } => {
                self.handle_sessions(subcommand).await?;
            }

            ReplCommand::Update { subcommand } => {
                self.handle_update(subcommand).await?;
            }
        }

        Ok(false)
    }

    async fn handle_search(
        &self,
        query: String,
        role: Option<String>,
        limit: Option<usize>,
        semantic: bool,
        concepts: bool,
    ) -> Result<()> {
        #[cfg(feature = "repl")]
        {
            use colored::Colorize;
            use comfy_table::modifiers::UTF8_ROUND_CORNERS;
            use comfy_table::presets::UTF8_FULL;
            use comfy_table::{Cell, Table};

            let search_mode = if semantic { "semantic " } else { "" }.to_string()
                + if concepts { "concepts " } else { "" };

            println!(
                "{} {}Searching for: '{}'",
                "🔍".bold(),
                search_mode,
                query.cyan()
            );

            if let Some(service) = &self.service {
                let role_name = if let Some(r) = role.as_deref() {
                    service.resolve_role(Some(r)).await?
                } else {
                    terraphim_types::RoleName::new(&self.current_role)
                };
                let results = service.search_with_role(&query, &role_name, limit).await?;

                if results.is_empty() {
                    println!("{} No results found", "ℹ".blue().bold());
                } else {
                    let mut table = Table::new();
                    table
                        .load_preset(UTF8_FULL)
                        .apply_modifier(UTF8_ROUND_CORNERS)
                        .set_header(vec![
                            Cell::new("Rank").add_attribute(comfy_table::Attribute::Bold),
                            Cell::new("Title").add_attribute(comfy_table::Attribute::Bold),
                            Cell::new("URL").add_attribute(comfy_table::Attribute::Bold),
                        ]);

                    for doc in &results {
                        table.add_row(vec![
                            Cell::new(doc.rank.unwrap_or_default().to_string()),
                            Cell::new(&doc.title),
                            Cell::new(if doc.url.is_empty() { "N/A" } else { &doc.url }),
                        ]);
                    }

                    println!("{}", table);
                    println!(
                        "{} Found {} result(s)",
                        "✅".bold(),
                        results.len().to_string().green()
                    );
                }
            }
            #[cfg(feature = "server")]
            if let Some(api_client) = &self.api_client {
                // Server mode - use current role if no role specified
                use terraphim_types::{Layer, NormalizedTermValue, RoleName, SearchQuery};

                let role_name = Some(match role.as_deref() {
                    Some(r) => api_client.resolve_role(r).await?,
                    None => RoleName::new(&self.current_role),
                });
                let search_query = SearchQuery {
                    search_term: NormalizedTermValue::from(query.as_str()),
                    search_terms: None,
                    operator: None,
                    skip: Some(0),
                    limit,
                    role: role_name,
                    layer: Layer::default(),
                    include_pinned: false,
                    min_quality: None,
                };

                match api_client.search(&search_query).await {
                    Ok(response) => {
                        if response.results.is_empty() {
                            println!("{} No results found", "ℹ".blue().bold());
                        } else {
                            let mut table = Table::new();
                            table
                                .load_preset(UTF8_FULL)
                                .apply_modifier(UTF8_ROUND_CORNERS)
                                .set_header(vec![
                                    Cell::new("Rank").add_attribute(comfy_table::Attribute::Bold),
                                    Cell::new("Title").add_attribute(comfy_table::Attribute::Bold),
                                    Cell::new("URL").add_attribute(comfy_table::Attribute::Bold),
                                ]);

                            for doc in &response.results {
                                table.add_row(vec![
                                    Cell::new(doc.rank.unwrap_or_default().to_string()),
                                    Cell::new(&doc.title),
                                    Cell::new(if doc.url.is_empty() { "N/A" } else { &doc.url }),
                                ]);
                            }

                            println!("{}", table);
                            println!(
                                "{} Found {} result(s)",
                                "✅".bold(),
                                response.results.len().to_string().green()
                            );
                        }
                    }
                    Err(e) => {
                        println!("{} Search failed: {}", "❌".bold(), e.to_string().red());
                    }
                }
            }
        }

        #[cfg(not(feature = "repl"))]
        {
            println!("Search functionality requires repl feature");
        }

        Ok(())
    }

    async fn handle_config(&self, subcommand: ConfigSubcommand) -> Result<()> {
        match subcommand {
            ConfigSubcommand::Show => {
                if let Some(service) = &self.service {
                    let config = service.get_config().await;
                    let config_json = serde_json::to_string_pretty(&config)?;
                    println!("{}", config_json);
                }
                #[cfg(feature = "server")]
                if let Some(api_client) = &self.api_client {
                    match api_client.get_config().await {
                        Ok(response) => {
                            let config_json = serde_json::to_string_pretty(&response.config)?;
                            println!("{}", config_json);
                        }
                        Err(e) => {
                            println!(
                                "{} Failed to get config: {}",
                                "❌".bold(),
                                e.to_string().red()
                            );
                        }
                    }
                }
            }
            ConfigSubcommand::Set { key, value } => {
                println!(
                    "{} Config modification not yet implemented",
                    "ℹ".blue().bold()
                );
                println!("Would set {} = {}", key.yellow(), value.cyan());
            }
        }
        Ok(())
    }

    async fn handle_role(&mut self, subcommand: RoleSubcommand) -> Result<()> {
        match subcommand {
            RoleSubcommand::List => {
                if let Some(service) = &self.service {
                    let roles_with_info = service.list_roles_with_info().await;
                    println!("{}", "Available roles:".bold());
                    for (role, shortname) in roles_with_info {
                        let marker = if role == self.current_role { ">" } else { " " };
                        if let Some(short) = shortname {
                            println!("  {} {} ({})", marker.green(), role, short.cyan());
                        } else {
                            println!("  {} {}", marker.green(), role);
                        }
                    }
                }
                #[cfg(feature = "server")]
                if let Some(api_client) = &self.api_client {
                    match api_client.get_config().await {
                        Ok(response) => {
                            println!("{}", "Available roles:".bold());
                            for (name, role) in response.config.roles.iter() {
                                let marker = if name.to_string() == self.current_role {
                                    ">"
                                } else {
                                    " "
                                };
                                if let Some(ref short) = role.shortname {
                                    println!("  {} {} ({})", marker.green(), name, short.cyan());
                                } else {
                                    println!("  {} {}", marker.green(), name);
                                }
                            }
                        }
                        Err(e) => {
                            println!(
                                "{} Failed to get roles: {}",
                                "X".bold(),
                                e.to_string().red()
                            );
                        }
                    }
                }
            }
            RoleSubcommand::Select { name } => {
                #[cfg_attr(not(feature = "server"), allow(unused_mut))]
                let mut resolved_name = if let Some(service) = &self.service {
                    service
                        .find_role_by_name_or_shortname(&name)
                        .await
                        .map(|r| r.to_string())
                } else {
                    None
                };
                #[cfg(feature = "server")]
                if resolved_name.is_none() {
                    if let Some(api_client) = &self.api_client {
                        resolved_name = match api_client.get_config().await {
                            Ok(cfg) => {
                                let query_lower = name.to_lowercase();
                                cfg.config
                                    .roles
                                    .iter()
                                    .find(|(n, _)| n.to_string().to_lowercase() == query_lower)
                                    .or_else(|| {
                                        cfg.config.roles.iter().find(|(_, role)| {
                                            role.shortname
                                                .as_ref()
                                                .map(|s| s.to_lowercase() == query_lower)
                                                .unwrap_or(false)
                                        })
                                    })
                                    .map(|(n, _)| n.to_string())
                            }
                            Err(_) => None,
                        };
                    }
                }

                let actual_name = match resolved_name {
                    Some(n) => n,
                    None => {
                        println!(
                            "{} Role '{}' not found (checked name and shortname)",
                            "X".bold(),
                            name.red()
                        );
                        return Ok(());
                    }
                };

                self.current_role = actual_name.clone();
                // Update the service's selected role so search uses the new role
                if let Some(service) = &self.service {
                    let role_name = terraphim_types::RoleName::new(&actual_name);
                    if let Err(e) = service.update_selected_role(role_name).await {
                        println!(
                            "{} Warning: Failed to update service role: {}",
                            "!".yellow().bold(),
                            e.to_string().yellow()
                        );
                    }
                }
                println!("{} Switched to role: {}", "OK".bold(), actual_name.green());
            }
        }
        Ok(())
    }

    async fn handle_graph(&self, top_k: Option<usize>) -> Result<()> {
        let k = top_k.unwrap_or(10);

        if let Some(service) = &self.service {
            let role_name = service.get_selected_role().await;
            let concepts = service.get_role_graph_top_k(&role_name, k).await?;

            println!("{} Top {} concepts:", "📊".bold(), k.to_string().cyan());
            for (i, concept) in concepts.iter().enumerate() {
                println!("  {}. {}", (i + 1).to_string().yellow(), concept);
            }
        }

        #[cfg(feature = "server")]
        if let Some(api_client) = &self.api_client {
            match api_client.rolegraph(Some(&self.current_role)).await {
                Ok(response) => {
                    let mut nodes = response.nodes;
                    #[allow(clippy::unnecessary_sort_by)]
                    nodes.sort_by(|a, b| b.rank.cmp(&a.rank));

                    println!("{} Top {} concepts:", "📊".bold(), k.to_string().cyan());
                    for (i, node) in nodes.iter().take(k).enumerate() {
                        println!(
                            "  {}. {} (rank: {})",
                            (i + 1).to_string().yellow(),
                            node.label,
                            node.rank.to_string().blue()
                        );
                    }
                }
                Err(e) => {
                    println!(
                        "{} Failed to get graph: {}",
                        "❌".bold(),
                        e.to_string().red()
                    );
                }
            }
        }

        Ok(())
    }

    async fn handle_help(&self, command: Option<String>) -> Result<()> {
        if let Some(cmd) = command {
            if let Some(help_text) = ReplCommand::get_command_help(&cmd) {
                println!("{}", help_text);
            } else {
                println!(
                    "{} No help available for command: {}",
                    "ℹ".blue().bold(),
                    cmd.yellow()
                );
            }
        } else {
            self.show_available_commands();
        }
        Ok(())
    }

    async fn handle_clear(&self) -> Result<()> {
        print!("\x1B[2J\x1B[1;1H");
        io::stdout().flush()?;
        Ok(())
    }

    #[cfg(feature = "llm")]
    async fn handle_chat(&self, message: Option<String>) -> Result<()> {
        #[cfg(feature = "repl")]
        {
            use colored::Colorize;

            if let Some(msg) = message {
                println!("{} Sending message: '{}'", "💬".bold(), msg.cyan());

                if let Some(service) = &self.service {
                    let role_name = service.get_selected_role().await;

                    match service.chat(&role_name, &msg, None).await {
                        Ok(response) => {
                            println!("\n{} {}\n", "🤖".bold(), "Response:".bold());
                            println!("{}", response);
                        }
                        Err(e) => {
                            println!("{} Chat failed: {}", "❌".bold(), e.to_string().red());
                        }
                    }
                }
                #[cfg(feature = "server")]
                if let Some(api_client) = &self.api_client {
                    match api_client.chat(&self.current_role, &msg, None).await {
                        Ok(response) => {
                            println!("\n{} {}\n", "🤖".bold(), "Response:".bold());
                            println!("{}", response.message.unwrap_or(response.status));
                        }
                        Err(e) => {
                            println!("{} Chat failed: {}", "❌".bold(), e.to_string().red());
                        }
                    }
                }
            } else {
                println!("{} Please provide a message to chat", "ℹ".blue().bold());
                println!("Usage: {} <message>", "/chat".yellow());
            }
        }

        #[cfg(not(feature = "repl"))]
        {
            println!("Chat functionality requires repl feature");
        }

        Ok(())
    }

    #[cfg(feature = "llm")]
    async fn handle_summarize(&self, target: String) -> Result<()> {
        #[cfg(feature = "repl")]
        {
            use colored::Colorize;

            println!("{} Summarizing: '{}'", "📝".bold(), target.cyan());

            if let Some(service) = &self.service {
                let role_name = service.get_selected_role().await;

                match service.summarize(&role_name, &target).await {
                    Ok(summary) => {
                        println!("\n{} {}\n", "📋".bold(), "Summary:".bold());
                        println!("{}", summary);
                    }
                    Err(e) => {
                        println!(
                            "{} Summarization failed: {}",
                            "❌".bold(),
                            e.to_string().red()
                        );
                    }
                }
            }
            #[cfg(feature = "server")]
            if let Some(api_client) = &self.api_client {
                use terraphim_types::{Document, DocumentType};

                let doc = Document {
                    id: "temp-summary".to_string(),
                    url: "".to_string(),
                    title: "Text to Summarize".to_string(),
                    body: target,
                    description: None,
                    summarization: None,
                    stub: None,
                    tags: Some(vec![]),
                    rank: None,
                    source_haystack: None,
                    doc_type: DocumentType::KgEntry,
                    synonyms: None,
                    route: None,
                    priority: None,
                    quality_score: None,
                };

                match api_client
                    .summarize_document(&doc, Some(&self.current_role))
                    .await
                {
                    Ok(response) => {
                        println!("\n{} {}\n", "📋".bold(), "Summary:".bold());
                        println!(
                            "{}",
                            response
                                .summary
                                .unwrap_or_else(|| "No summary available".to_string())
                        );
                    }
                    Err(e) => {
                        println!(
                            "{} Summarization failed: {}",
                            "❌".bold(),
                            e.to_string().red()
                        );
                    }
                }
            }
        }

        #[cfg(not(feature = "repl"))]
        {
            println!("Summarization functionality requires repl feature");
        }

        Ok(())
    }

    #[cfg(feature = "repl-mcp")]
    async fn handle_autocomplete(&self, query: String, limit: Option<usize>) -> Result<()> {
        #[cfg(feature = "repl")]
        {
            use colored::Colorize;

            println!("{} Autocompleting: '{}'", "🔍".bold(), query.cyan());

            if let Some(mcp_handler) = &self.mcp_handler {
                match mcp_handler.autocomplete_terms(&query, limit).await {
                    Ok(results) => {
                        if results.is_empty() {
                            println!("{} No autocomplete suggestions found", "ℹ".blue().bold());
                        } else {
                            for (i, term) in results.iter().enumerate() {
                                println!("  {}. {}", (i + 1).to_string().yellow(), term);
                            }
                            println!(
                                "{} Found {} suggestion(s)",
                                "✅".bold(),
                                results.len().to_string().green()
                            );
                        }
                    }
                    Err(e) => {
                        println!(
                            "{} Autocomplete failed: {}",
                            "❌".bold(),
                            e.to_string().red()
                        );
                    }
                }
            } else {
                println!(
                    "{} Autocomplete requires offline mode with thesaurus",
                    "ℹ".blue().bold()
                );
            }
        }

        #[cfg(not(feature = "repl"))]
        {
            println!("Autocomplete functionality requires repl feature");
        }

        Ok(())
    }

    #[cfg(feature = "repl-mcp")]
    async fn handle_extract(&self, text: String, exclude_term: bool) -> Result<()> {
        #[cfg(feature = "repl")]
        {
            use colored::Colorize;

            println!("{} Extracting paragraphs from text...", "📄".bold());

            if let Some(mcp_handler) = &self.mcp_handler {
                match mcp_handler.extract_paragraphs(&text, exclude_term).await {
                    Ok(results) => {
                        if results.is_empty() {
                            println!("{} No paragraphs found", "ℹ".blue().bold());
                        } else {
                            for (i, (term, paragraph)) in results.iter().enumerate() {
                                let truncated = if paragraph.len() > 100 {
                                    format!("{}...", &paragraph[..97])
                                } else {
                                    paragraph.clone()
                                };
                                println!(
                                    "  {}. {}: {}",
                                    (i + 1).to_string().yellow(),
                                    term.cyan(),
                                    truncated
                                );
                            }
                            println!(
                                "{} Found {} paragraph(s)",
                                "✅".bold(),
                                results.len().to_string().green()
                            );
                        }
                    }
                    Err(e) => {
                        println!("{} Extract failed: {}", "❌".bold(), e.to_string().red());
                    }
                }
            } else {
                println!(
                    "{} Extract requires offline mode with thesaurus",
                    "ℹ".blue().bold()
                );
            }
        }

        #[cfg(not(feature = "repl"))]
        {
            println!("Extract functionality requires repl feature");
        }

        Ok(())
    }

    #[cfg(feature = "repl-mcp")]
    async fn handle_find(&self, text: String) -> Result<()> {
        #[cfg(feature = "repl")]
        {
            use colored::Colorize;

            println!("{} Finding matches in text...", "🔍".bold());

            if let Some(mcp_handler) = &self.mcp_handler {
                match mcp_handler.find_matches(&text).await {
                    Ok(results) => {
                        if results.is_empty() {
                            println!("{} No matches found", "ℹ".blue().bold());
                        } else {
                            for (i, matched) in results.iter().enumerate() {
                                println!("  {}. {}", (i + 1).to_string().yellow(), matched);
                            }
                            println!(
                                "{} Found {} match(es)",
                                "✅".bold(),
                                results.len().to_string().green()
                            );
                        }
                    }
                    Err(e) => {
                        println!("{} Find failed: {}", "❌".bold(), e.to_string().red());
                    }
                }
            } else {
                println!(
                    "{} Find requires offline mode with thesaurus",
                    "ℹ".blue().bold()
                );
            }
        }

        #[cfg(not(feature = "repl"))]
        {
            println!("Find functionality requires repl feature");
        }

        Ok(())
    }

    #[cfg(feature = "repl-mcp")]
    async fn handle_replace(&self, text: String, format: Option<String>) -> Result<()> {
        #[cfg(feature = "repl")]
        {
            use colored::Colorize;

            println!("{} Replacing matches in text...", "🔄".bold());

            if let Some(mcp_handler) = &self.mcp_handler {
                match mcp_handler.replace_matches(&text, format).await {
                    Ok(result) => {
                        println!("\n{} {}\n", "📝".bold(), "Result:".bold());
                        println!("{}", result);
                    }
                    Err(e) => {
                        println!("{} Replace failed: {}", "❌".bold(), e.to_string().red());
                    }
                }
            } else {
                println!(
                    "{} Replace requires offline mode with thesaurus",
                    "ℹ".blue().bold()
                );
            }
        }

        #[cfg(not(feature = "repl"))]
        {
            println!("Replace functionality requires repl feature");
        }

        Ok(())
    }

    #[cfg(feature = "repl-mcp")]
    async fn handle_thesaurus(&self, role: Option<String>) -> Result<()> {
        #[cfg(feature = "repl")]
        {
            use colored::Colorize;

            println!("{} Loading thesaurus...", "📚".bold());

            if let Some(mcp_handler) = &self.mcp_handler {
                match mcp_handler.get_thesaurus(role).await {
                    Ok(results) => {
                        let mut count = 0;
                        for (term, url) in results.iter().take(20) {
                            // Show first 20 entries
                            if url.is_empty() {
                                println!("  {}. {}", (count + 1).to_string().yellow(), term);
                            } else {
                                println!(
                                    "  {}. {} -> {}",
                                    (count + 1).to_string().yellow(),
                                    term,
                                    url.cyan()
                                );
                            }
                            count += 1;
                        }

                        println!(
                            "{} Showing {} of {} thesaurus entries",
                            "✅".bold(),
                            count.to_string().green(),
                            results.len().to_string().cyan()
                        );
                    }
                    Err(e) => {
                        println!("{} Thesaurus failed: {}", "❌".bold(), e.to_string().red());
                    }
                }
            } else {
                println!("{} Thesaurus requires offline mode", "ℹ".blue().bold());
            }
        }

        #[cfg(not(feature = "repl"))]
        {
            println!("Thesaurus functionality requires repl feature");
        }

        Ok(())
    }

    #[cfg(feature = "repl-file")]
    async fn handle_file(&self, subcommand: super::commands::FileSubcommand) -> Result<()> {
        #[cfg(feature = "repl")]
        {
            use colored::Colorize;

            match subcommand {
                super::commands::FileSubcommand::Search { query } => {
                    println!("🔍 File search: {}", query.green());
                    println!("File search functionality is not yet implemented.");
                    println!("This would search for files matching: {}", query);
                }
                super::commands::FileSubcommand::List => {
                    println!("📂 File listing");
                    println!("File listing functionality is not yet implemented.");
                }
                super::commands::FileSubcommand::Info { path } => {
                    println!("ℹ️  File info: {}", path.green());
                    println!("File info functionality is not yet implemented.");
                    println!("This would show information about: {}", path);
                }
            }
        }

        #[cfg(not(feature = "repl"))]
        {
            println!("File operations require repl feature");
        }

        Ok(())
    }

    #[cfg(feature = "repl-web")]
    async fn handle_web(&self, subcommand: super::commands::WebSubcommand) -> Result<()> {
        #[cfg(feature = "repl")]
        {
            use colored::Colorize;

            match subcommand {
                super::commands::WebSubcommand::Get { url, headers } => {
                    println!("🌐 Web GET: {}", url.green());
                    if let Some(headers) = headers {
                        println!("Headers: {:?}", headers);
                    }
                    println!("Web GET functionality is not yet implemented.");
                }
                super::commands::WebSubcommand::Post { url, body, headers } => {
                    println!("🌐 Web POST: {}", url.green());
                    if !body.is_empty() {
                        println!("Body: {}", body);
                    }
                    if let Some(headers) = headers {
                        println!("Headers: {:?}", headers);
                    }
                    println!("Web POST functionality is not yet implemented.");
                }
                super::commands::WebSubcommand::Scrape {
                    url,
                    selector,
                    wait_for_element,
                } => {
                    println!("🌐 Web Scrape: {}", url.green());
                    if let Some(selector) = selector {
                        println!("Selector: {}", selector);
                    }
                    if let Some(wait) = wait_for_element {
                        println!("Wait for: {}", wait);
                    }
                    println!("Web scraping functionality is not yet implemented.");
                }
                super::commands::WebSubcommand::Screenshot {
                    url,
                    width,
                    height,
                    full_page,
                } => {
                    println!("🌐 Web Screenshot: {}", url.green());
                    if let Some(width) = width {
                        println!("Width: {}", width);
                    }
                    if let Some(height) = height {
                        println!("Height: {}", height);
                    }
                    if let Some(full_page) = full_page {
                        println!("Full page: {}", full_page);
                    }
                    println!("Web screenshot functionality is not yet implemented.");
                }
                super::commands::WebSubcommand::Pdf { url, page_size } => {
                    println!("🌐 Web PDF: {}", url.green());
                    if let Some(page_size) = page_size {
                        println!("Page size: {}", page_size);
                    }
                    println!("Web PDF functionality is not yet implemented.");
                }
                super::commands::WebSubcommand::Form { url, form_data } => {
                    println!("🌐 Web Form: {}", url.green());
                    println!("Form data: {:?}", form_data);
                    println!("Web form functionality is not yet implemented.");
                }
                super::commands::WebSubcommand::Api {
                    endpoint,
                    method,
                    data,
                } => {
                    println!("🌐 Web API: {} {}", method.bold(), endpoint.green());
                    if let Some(data) = data {
                        println!("Data: {}", data);
                    }
                    println!("Web API functionality is not yet implemented.");
                }
                super::commands::WebSubcommand::Status { operation_id } => {
                    println!("🌐 Web Status: {}", operation_id.green());
                    println!("Web status functionality is not yet implemented.");
                }
                super::commands::WebSubcommand::Cancel { operation_id } => {
                    println!("🌐 Web Cancel: {}", operation_id.green());
                    println!("Web cancel functionality is not yet implemented.");
                }
                super::commands::WebSubcommand::History { limit } => {
                    println!("🌐 Web History");
                    if let Some(limit) = limit {
                        println!("Limit: {}", limit);
                    }
                    println!("Web history functionality is not yet implemented.");
                }
                super::commands::WebSubcommand::Config {
                    subcommand: web_config_subcommand,
                } => match web_config_subcommand {
                    super::commands::WebConfigSubcommand::Show => {
                        println!("🌐 Web Config Show");
                        println!("Web config show functionality is not yet implemented.");
                    }
                    super::commands::WebConfigSubcommand::Set { key, value } => {
                        println!("🌐 Web Config Set: {} = {}", key.green(), value.green());
                        println!("Web config set functionality is not yet implemented.");
                    }
                    super::commands::WebConfigSubcommand::Reset => {
                        println!("🌐 Web Config Reset");
                        println!("Web config reset functionality is not yet implemented.");
                    }
                },
            }
        }

        #[cfg(not(feature = "repl"))]
        {
            println!("Web operations require repl feature");
        }

        Ok(())
    }

    #[cfg(feature = "firecracker")]
    async fn handle_vm(&self, subcommand: super::commands::VmSubcommand) -> Result<()> {
        #[cfg(feature = "repl")]
        {
            use colored::Colorize;

            match subcommand {
                super::commands::VmSubcommand::List => {
                    println!("🖥️  VM List");
                    if let Some(api_client) = &self.api_client {
                        match api_client.list_vms().await {
                            Ok(response) => {
                                println!("Available VMs:");
                                if response.vms.is_empty() {
                                    println!("  No VMs currently running");
                                } else {
                                    for vm in &response.vms {
                                        println!(
                                            "  {} ({})",
                                            vm.vm_id.bright_green(),
                                            vm.ip_address.bright_blue()
                                        );
                                    }
                                }
                            }
                            Err(e) => {
                                println!("❌ Error listing VMs: {}", e);
                            }
                        }
                    } else {
                        println!("❌ API client not available");
                    }
                }
                super::commands::VmSubcommand::Pool => {
                    println!("🏊 VM Pool Status");
                    if let Some(api_client) = &self.api_client {
                        match api_client.get_vm_pool_stats().await {
                            Ok(response) => {
                                println!("VM Pool Statistics:");
                                println!(
                                    "  Available IPs: {}",
                                    response.available_ips.to_string().bright_green()
                                );
                                println!(
                                    "  Allocated IPs: {}",
                                    response.allocated_ips.to_string().bright_yellow()
                                );
                                println!(
                                    "  Total IPs: {}",
                                    response.total_ips.to_string().bright_blue()
                                );
                                println!("  Utilization: {}%", response.utilization_percent);
                            }
                            Err(e) => {
                                println!("❌ Error getting VM pool stats: {}", e);
                            }
                        }
                    } else {
                        println!("❌ API client not available");
                    }
                }
                super::commands::VmSubcommand::Status { vm_id } => {
                    if let Some(api_client) = &self.api_client {
                        if let Some(id) = vm_id {
                            println!("📊 VM Status: {}", id.green());
                            match api_client.get_vm_status(&id).await {
                                Ok(response) => {
                                    println!("  Status: {}", response.status.bright_green());
                                    println!("  IP Address: {}", response.ip_address.bright_blue());
                                    println!("  Created: {}", response.created_at);
                                    if let Some(updated_at) = response.updated_at {
                                        println!("  Updated: {}", updated_at);
                                    }
                                }
                                Err(e) => {
                                    println!("❌ Error getting VM status: {}", e);
                                }
                            }
                        } else {
                            println!("📊 All VM Status");
                            match api_client.list_vms().await {
                                Ok(response) => {
                                    for vm in &response.vms {
                                        println!(
                                            "  {} ({})",
                                            vm.vm_id.bright_green(),
                                            vm.ip_address.bright_blue()
                                        );
                                    }
                                }
                                Err(e) => {
                                    println!("❌ Error listing VMs: {}", e);
                                }
                            }
                        }
                    } else {
                        println!("❌ API client not available");
                    }
                }
                super::commands::VmSubcommand::Metrics { vm_id } => {
                    if let Some(api_client) = &self.api_client {
                        if let Some(id) = vm_id {
                            println!("📈 VM Metrics: {}", id.green());
                            match api_client.get_vm_metrics(&id).await {
                                Ok(response) => {
                                    println!("  Status: {}", response.status.bright_green());
                                    println!("  CPU Usage: {:.1}%", response.cpu_usage_percent);
                                    println!("  Memory Usage: {} MB", response.memory_usage_mb);
                                    println!("  Disk Usage: {:.1}%", response.disk_usage_percent);
                                    println!("  Network I/O: {:.1} Mbps", response.network_io_mbps);
                                    println!("  Uptime: {} seconds", response.uptime_seconds);
                                }
                                Err(e) => {
                                    println!("❌ Error getting VM metrics: {}", e);
                                }
                            }
                        } else {
                            println!("📈 All VM Metrics");
                            match api_client.get_all_vm_metrics().await {
                                Ok(metrics) => {
                                    for metric in &metrics {
                                        println!(
                                            "  {} - CPU: {:.1}%, Memory: {} MB",
                                            metric.vm_id.bright_green(),
                                            metric.cpu_usage_percent,
                                            metric.memory_usage_mb
                                        );
                                    }
                                }
                                Err(e) => {
                                    println!("❌ Error getting all VM metrics: {}", e);
                                }
                            }
                        }
                    } else {
                        println!("❌ API client not available");
                    }
                }
                super::commands::VmSubcommand::Execute {
                    code,
                    language,
                    vm_id,
                } => {
                    if let Some(api_client) = &self.api_client {
                        if let Some(id) = vm_id {
                            println!("⚡ Execute on VM: {}", id.green());
                            println!("Language: {}", language.cyan());
                            println!("Code: {}", code.yellow());
                            match api_client
                                .execute_vm_code(&id, &code, Some(&language))
                                .await
                            {
                                Ok(response) => {
                                    println!("✅ Execution successful!");
                                    println!("  Exit Code: {}", response.exit_code);
                                    if !response.stdout.is_empty() {
                                        println!("  Output:\n{}", response.stdout.bright_green());
                                    }
                                    if !response.stderr.is_empty() {
                                        println!("  Errors:\n{}", response.stderr.bright_red());
                                    }
                                    // Note: execution_time_ms field not available in current response type
                                    // if let Some(execution_time) = response.execution_time_ms {
                                    //     println!("  Execution Time: {}ms", execution_time);
                                    // }
                                }
                                Err(e) => {
                                    println!("❌ Error executing code: {}", e);
                                }
                            }
                        } else {
                            println!("⚡ Execute on default VM");
                            println!("Language: {}", language.cyan());
                            println!("Code: {}", code.yellow());
                            println!(
                                "💡 Default VM execution not yet implemented. Please specify a VM ID with --vm-id"
                            );
                        }
                    } else {
                        println!("❌ API client not available");
                    }
                }
                super::commands::VmSubcommand::Agent {
                    agent_id,
                    task,
                    vm_id,
                } => {
                    if let Some(api_client) = &self.api_client {
                        if let Some(id) = vm_id {
                            println!("🤖 Agent: {} on VM: {}", agent_id.green(), id.cyan());
                            println!("Task: {}", task.yellow());
                            match api_client
                                .execute_agent_task(&id, &agent_id, Some(&task))
                                .await
                            {
                                Ok(response) => {
                                    println!("✅ Agent task executed successfully!");
                                    println!("  Task ID: {}", response.task_id.bright_green());
                                    println!("  Status: {}", response.status.bright_yellow());
                                    if !response.result.is_empty() {
                                        println!("  Result:\n{}", response.result.bright_blue());
                                    }
                                }
                                Err(e) => {
                                    println!("❌ Error executing agent task: {}", e);
                                }
                            }
                        } else {
                            println!("🤖 Agent: {} on default VM", agent_id.green());
                            println!("Task: {}", task.yellow());
                            println!(
                                "💡 Default VM agent execution not yet implemented. Please specify a VM ID with --vm-id"
                            );
                        }
                    } else {
                        println!("❌ API client not available");
                    }
                }
                super::commands::VmSubcommand::Tasks { vm_id } => {
                    if let Some(api_client) = &self.api_client {
                        println!("📋 Tasks for VM: {}", vm_id.green());
                        match api_client.list_vm_tasks(&vm_id).await {
                            Ok(response) => {
                                if response.tasks.is_empty() {
                                    println!("  No tasks found for VM");
                                } else {
                                    for task in &response.tasks {
                                        println!(
                                            "  {} - {}",
                                            task.id.bright_green(),
                                            task.status.bright_yellow()
                                        );
                                        // Note: agent_type field not available in current VmTask type
                                        // task.agent_type.bright_blue()
                                        println!("    Created: {}", task.created_at);
                                    }
                                }
                            }
                            Err(e) => {
                                println!("❌ Error listing VM tasks: {}", e);
                            }
                        }
                    } else {
                        println!("❌ API client not available");
                    }
                }
                super::commands::VmSubcommand::Allocate { vm_id } => {
                    if let Some(api_client) = &self.api_client {
                        println!("➕ Allocate VM: {}", vm_id.green());
                        match api_client.allocate_vm_ip(&vm_id).await {
                            Ok(response) => {
                                println!("✅ VM allocated successfully!");
                                println!("  VM ID: {}", response.vm_id.bright_green());
                                println!("  IP Address: {}", response.ip_address.bright_blue());
                                // Note: pool_id field not available in current VmAllocateResponse type
                                // println!("  Pool ID: {}", response.pool_id.bright_yellow());
                            }
                            Err(e) => {
                                println!("❌ Error allocating VM: {}", e);
                            }
                        }
                    } else {
                        println!("❌ API client not available");
                    }
                }
                super::commands::VmSubcommand::Release { vm_id } => {
                    if let Some(api_client) = &self.api_client {
                        println!("➖ Release VM: {}", vm_id.green());
                        match api_client.release_vm_ip(&vm_id).await {
                            Ok(_) => {
                                println!("✅ VM released successfully!");
                                println!("  VM {} resources have been freed", vm_id.bright_green());
                            }
                            Err(e) => {
                                println!("❌ Error releasing VM: {}", e);
                            }
                        }
                    } else {
                        println!("❌ API client not available");
                    }
                }
                super::commands::VmSubcommand::Monitor { vm_id, refresh } => {
                    if let Some(api_client) = &self.api_client {
                        let interval = refresh.unwrap_or(5); // Default 5 seconds
                        println!("👁️  Monitor VM: {} (refresh: {}s)", vm_id.green(), interval);
                        println!("Starting VM monitoring... Press Ctrl+C to stop");

                        // Simple monitoring loop
                        let mut count = 0;
                        loop {
                            count += 1;
                            println!("\n--- Check #{} ---", count);

                            // Get VM status
                            match api_client.get_vm_status(&vm_id).await {
                                Ok(status) => {
                                    println!(
                                        "Status: {} | IP: {} | Created: {}",
                                        status.status.bright_green(),
                                        status.ip_address.bright_blue(),
                                        status.created_at
                                    );
                                }
                                Err(e) => {
                                    println!("❌ Error getting status: {}", e);
                                }
                            }

                            // Get VM metrics
                            match api_client.get_vm_metrics(&vm_id).await {
                                Ok(metrics) => {
                                    println!(
                                        "CPU: {:.1}% | Memory: {}MB | Disk: {:.1}% | Uptime: {}s",
                                        metrics.cpu_usage_percent,
                                        metrics.memory_usage_mb,
                                        metrics.disk_usage_percent,
                                        metrics.uptime_seconds
                                    );
                                }
                                Err(e) => {
                                    println!("❌ Error getting metrics: {}", e);
                                }
                            }

                            // Wait before next check
                            tokio::time::sleep(tokio::time::Duration::from_secs(interval as u64))
                                .await;
                        }
                    } else {
                        println!("❌ API client not available");
                    }
                }
            }
        }

        #[cfg(not(feature = "repl"))]
        {
            println!("VM operations require repl feature");
        }

        Ok(())
    }

    async fn handle_robot(&self, subcommand: RobotSubcommand) -> Result<()> {
        #[cfg(feature = "repl")]
        {
            use colored::Colorize;

            let docs = SelfDocumentation::new();

            match subcommand {
                RobotSubcommand::Capabilities => {
                    println!("{} Robot Mode - Capabilities\n", "🤖".bold());
                    let capabilities = docs.capabilities_data();
                    let json = serde_json::to_string_pretty(&capabilities)?;
                    println!("{}", json);
                }
                RobotSubcommand::Schemas { command } => {
                    println!("{} Robot Mode - Schemas\n", "📋".bold());
                    if let Some(cmd) = command {
                        if let Some(schema) = docs.schema(&cmd) {
                            let json = serde_json::to_string_pretty(schema)?;
                            println!("{}", json);
                        } else {
                            println!(
                                "{} No schema found for command: {}",
                                "ℹ".blue().bold(),
                                cmd.yellow()
                            );
                        }
                    } else {
                        // Show all schemas
                        let schemas = docs.all_schemas();
                        let json = serde_json::to_string_pretty(schemas)?;
                        println!("{}", json);
                    }
                }
                RobotSubcommand::Examples { command } => {
                    println!("{} Robot Mode - Examples\n", "📝".bold());
                    if let Some(cmd) = command {
                        if let Some(examples) = docs.examples(&cmd) {
                            let json = serde_json::to_string_pretty(examples)?;
                            println!("{}", json);
                        } else {
                            println!(
                                "{} No examples found for command: {}",
                                "ℹ".blue().bold(),
                                cmd.yellow()
                            );
                        }
                    } else {
                        // Show examples for all commands
                        let all_examples: Vec<_> = docs
                            .all_schemas()
                            .iter()
                            .flat_map(|s| {
                                s.examples.iter().map(move |e| {
                                    serde_json::json!({
                                        "command": s.name,
                                        "example": e
                                    })
                                })
                            })
                            .collect();
                        let json = serde_json::to_string_pretty(&all_examples)?;
                        println!("{}", json);
                    }
                }
                RobotSubcommand::ExitCodes => {
                    println!("{} Robot Mode - Exit Codes\n", "🚪".bold());
                    let exit_codes = vec![
                        serde_json::json!({
                            "code": ExitCode::Success.code(),
                            "name": ExitCode::Success.name(),
                            "description": ExitCode::Success.description()
                        }),
                        serde_json::json!({
                            "code": ExitCode::ErrorGeneral.code(),
                            "name": ExitCode::ErrorGeneral.name(),
                            "description": ExitCode::ErrorGeneral.description()
                        }),
                        serde_json::json!({
                            "code": ExitCode::ErrorUsage.code(),
                            "name": ExitCode::ErrorUsage.name(),
                            "description": ExitCode::ErrorUsage.description()
                        }),
                        serde_json::json!({
                            "code": ExitCode::ErrorIndexMissing.code(),
                            "name": ExitCode::ErrorIndexMissing.name(),
                            "description": ExitCode::ErrorIndexMissing.description()
                        }),
                        serde_json::json!({
                            "code": ExitCode::ErrorNotFound.code(),
                            "name": ExitCode::ErrorNotFound.name(),
                            "description": ExitCode::ErrorNotFound.description()
                        }),
                        serde_json::json!({
                            "code": ExitCode::ErrorAuth.code(),
                            "name": ExitCode::ErrorAuth.name(),
                            "description": ExitCode::ErrorAuth.description()
                        }),
                        serde_json::json!({
                            "code": ExitCode::ErrorNetwork.code(),
                            "name": ExitCode::ErrorNetwork.name(),
                            "description": ExitCode::ErrorNetwork.description()
                        }),
                        serde_json::json!({
                            "code": ExitCode::ErrorTimeout.code(),
                            "name": ExitCode::ErrorTimeout.name(),
                            "description": ExitCode::ErrorTimeout.description()
                        }),
                    ];
                    let json = serde_json::to_string_pretty(&exit_codes)?;
                    println!("{}", json);
                }
            }
        }

        #[cfg(not(feature = "repl"))]
        {
            println!("Robot mode requires repl feature");
        }

        Ok(())
    }

    /// Handle update management commands
    async fn handle_update(&mut self, subcommand: UpdateSubcommand) -> Result<()> {
        use terraphim_update::{
            UpdateStatus, check_for_updates_auto, rollback::BackupManager, update_binary,
        };

        // Get the current binary name and version
        let bin_name = env!("CARGO_PKG_NAME");
        let current_version = env!("CARGO_PKG_VERSION");

        match subcommand {
            UpdateSubcommand::Check => {
                println!("Checking for updates...");
                match check_for_updates_auto(bin_name, current_version).await {
                    Ok(status) => {
                        println!("{}", status);
                    }
                    Err(e) => {
                        println!("Failed to check for updates: {}", e);
                    }
                }
            }
            UpdateSubcommand::Install => {
                println!("Checking for updates and installing if available...");
                match update_binary(bin_name).await {
                    Ok(status) => match status {
                        UpdateStatus::Updated {
                            from_version,
                            to_version,
                        } => {
                            println!(
                                "Successfully updated from {} to {}",
                                from_version, to_version
                            );
                            println!("Please restart the application to use the new version.");
                        }
                        UpdateStatus::UpToDate(version) => {
                            println!("Already running the latest version: {}", version);
                        }
                        UpdateStatus::Available {
                            current_version,
                            latest_version,
                        } => {
                            println!(
                                "Update available: {} -> {} (installation pending)",
                                current_version, latest_version
                            );
                        }
                        UpdateStatus::Failed(error) => {
                            println!("Update failed: {}", error);
                        }
                    },
                    Err(e) => {
                        println!("Failed to update: {}", e);
                    }
                }
            }
            UpdateSubcommand::Rollback { version } => {
                println!("Rolling back to version {}...", version);

                // Get backup directory (use standard location)
                let backup_dir = dirs::data_local_dir()
                    .unwrap_or_else(|| std::path::PathBuf::from("."))
                    .join("terraphim")
                    .join("backups");

                match BackupManager::new(backup_dir, 3) {
                    Ok(manager) => {
                        // Get current executable path as target
                        let target_path = std::env::current_exe()
                            .unwrap_or_else(|_| std::path::PathBuf::from(bin_name));

                        match manager.rollback_to_version(&version, &target_path) {
                            Ok(()) => {
                                println!("Successfully rolled back to version {}", version);
                                println!("Please restart the application.");
                            }
                            Err(e) => {
                                println!("Rollback failed: {}", e);
                            }
                        }
                    }
                    Err(e) => {
                        println!("Failed to initialize backup manager: {}", e);
                    }
                }
            }
            UpdateSubcommand::List => {
                println!("Available backup versions:");

                // Get backup directory
                let backup_dir = dirs::data_local_dir()
                    .unwrap_or_else(|| std::path::PathBuf::from("."))
                    .join("terraphim")
                    .join("backups");

                match BackupManager::new(backup_dir, 3) {
                    Ok(manager) => {
                        let versions = manager.list_backups();
                        if versions.is_empty() {
                            println!("  No backups available.");
                        } else {
                            for (i, version) in versions.iter().enumerate() {
                                println!("  {}. {}", i + 1, version);
                            }
                        }
                    }
                    Err(e) => {
                        println!("Failed to list backups: {}", e);
                    }
                }
            }
        }

        Ok(())
    }

    #[cfg(feature = "repl-sessions")]
    async fn handle_sessions(&mut self, subcommand: SessionsSubcommand) -> Result<()> {
        use colored::Colorize;
        use comfy_table::Color;
        use comfy_table::modifiers::UTF8_ROUND_CORNERS;
        use comfy_table::presets::UTF8_FULL;
        use comfy_table::{Cell, Table};
        use terraphim_sessions::{
            ConnectorStatus, FileAccess, MessageRole, Session, SessionService,
        };

        // Get or create session service
        static SESSION_SERVICE: std::sync::OnceLock<
            std::sync::Arc<tokio::sync::Mutex<SessionService>>,
        > = std::sync::OnceLock::new();
        let service = SESSION_SERVICE
            .get_or_init(|| std::sync::Arc::new(tokio::sync::Mutex::new(SessionService::new())));
        let svc = service.lock().await;

        match subcommand {
            SessionsSubcommand::Sources => {
                println!("\n{}", "Available Session Sources:".bold().cyan());

                let sources = svc.detect_sources();
                let mut table = Table::new();
                table
                    .load_preset(UTF8_FULL)
                    .apply_modifier(UTF8_ROUND_CORNERS)
                    .set_header(vec![
                        Cell::new("Source").add_attribute(comfy_table::Attribute::Bold),
                        Cell::new("Status").add_attribute(comfy_table::Attribute::Bold),
                        Cell::new("Sessions").add_attribute(comfy_table::Attribute::Bold),
                    ]);

                for source in sources {
                    let (status, count) = match &source.status {
                        ConnectorStatus::Available {
                            sessions_estimate, ..
                        } => (
                            "Available".green().to_string(),
                            sessions_estimate
                                .map(|c| c.to_string())
                                .unwrap_or("-".to_string()),
                        ),
                        ConnectorStatus::NotFound => {
                            ("Not Found".yellow().to_string(), "-".to_string())
                        }
                        ConnectorStatus::Error(e) => {
                            (format!("Error: {}", e).red().to_string(), "-".to_string())
                        }
                    };

                    table.add_row(vec![
                        Cell::new(&source.id),
                        Cell::new(status),
                        Cell::new(count),
                    ]);
                }

                println!("{}", table);
            }

            SessionsSubcommand::List { source, limit } => {
                let sessions = if let Some(source_id) = source {
                    svc.sessions_by_source(&source_id).await
                } else {
                    svc.list_sessions().await
                };

                let sessions: Vec<_> = if let Some(lim) = limit {
                    sessions.into_iter().take(lim).collect()
                } else {
                    sessions.into_iter().take(20).collect()
                };

                if sessions.is_empty() {
                    println!("{} No sessions found.", "ℹ".blue().bold());
                    return Ok(());
                }

                println!("\n{}", "Sessions:".bold().cyan());
                let mut table = Table::new();
                table
                    .load_preset(UTF8_FULL)
                    .apply_modifier(UTF8_ROUND_CORNERS)
                    .set_header(vec![
                        Cell::new("ID").add_attribute(comfy_table::Attribute::Bold),
                        Cell::new("Source").add_attribute(comfy_table::Attribute::Bold),
                        Cell::new("Title").add_attribute(comfy_table::Attribute::Bold),
                        Cell::new("Messages").add_attribute(comfy_table::Attribute::Bold),
                    ]);

                for session in &sessions {
                    let title = session
                        .title
                        .as_ref()
                        .map(|t| {
                            if t.len() > 40 {
                                format!("{}...", &t[..40])
                            } else {
                                t.clone()
                            }
                        })
                        .unwrap_or_else(|| "-".to_string());

                    table.add_row(vec![
                        Cell::new(&session.external_id[..8.min(session.external_id.len())]),
                        Cell::new(&session.source),
                        Cell::new(title),
                        Cell::new(session.message_count().to_string()),
                    ]);
                }

                println!("{}", table);
                println!("Showing {} session(s)", sessions.len().to_string().green());
            }

            SessionsSubcommand::Search { query } => {
                #[cfg(feature = "enrichment")]
                {
                    let thesaurus = if let Some(ref tui_service) = self.service {
                        let role_name: terraphim_types::RoleName = self.current_role.clone().into();
                        tui_service.get_thesaurus(&role_name).await.ok()
                    } else {
                        None
                    };
                    let sessions = svc.search_with_thesaurus(&query, thesaurus).await;

                    if sessions.is_empty() {
                        println!("{} No sessions match '{}'", "ℹ".blue().bold(), query.cyan());
                        return Ok(());
                    }

                    println!(
                        "\n{} sessions match '{}':",
                        sessions.len().to_string().green(),
                        query.cyan()
                    );
                    let mut table = Table::new();
                    table
                        .load_preset(UTF8_FULL)
                        .apply_modifier(UTF8_ROUND_CORNERS)
                        .set_header(vec![
                            Cell::new("ID").add_attribute(comfy_table::Attribute::Bold),
                            Cell::new("Source").add_attribute(comfy_table::Attribute::Bold),
                            Cell::new("Title").add_attribute(comfy_table::Attribute::Bold),
                        ]);

                    for session in sessions.iter().take(10) {
                        let title = session
                            .title
                            .as_ref()
                            .map(|t| {
                                if t.len() > 50 {
                                    format!("{}...", &t[..50])
                                } else {
                                    t.clone()
                                }
                            })
                            .unwrap_or_else(|| "-".to_string());

                        table.add_row(vec![
                            Cell::new(&session.external_id[..8.min(session.external_id.len())]),
                            Cell::new(&session.source),
                            Cell::new(title),
                        ]);
                    }

                    println!("{}", table);
                }

                #[cfg(not(feature = "enrichment"))]
                {
                    let sessions = svc.search(&query).await;

                    if sessions.is_empty() {
                        println!("{} No sessions match '{}'", "ℹ".blue().bold(), query.cyan());
                        return Ok(());
                    }

                    println!(
                        "\n{} sessions match '{}':",
                        sessions.len().to_string().green(),
                        query.cyan()
                    );
                    let mut table = Table::new();
                    table
                        .load_preset(UTF8_FULL)
                        .apply_modifier(UTF8_ROUND_CORNERS)
                        .set_header(vec![
                            Cell::new("ID").add_attribute(comfy_table::Attribute::Bold),
                            Cell::new("Source").add_attribute(comfy_table::Attribute::Bold),
                            Cell::new("Title").add_attribute(comfy_table::Attribute::Bold),
                        ]);

                    for session in sessions.iter().take(10) {
                        let title = session
                            .title
                            .as_ref()
                            .map(|t| {
                                if t.len() > 50 {
                                    format!("{}...", &t[..50])
                                } else {
                                    t.clone()
                                }
                            })
                            .unwrap_or_else(|| "-".to_string());

                        table.add_row(vec![
                            Cell::new(&session.external_id[..8.min(session.external_id.len())]),
                            Cell::new(&session.source),
                            Cell::new(title),
                        ]);
                    }

                    println!("{}", table);
                }
            }

            SessionsSubcommand::Stats => {
                let stats = svc.statistics().await;

                println!("\n{}", "Session Statistics:".bold().cyan());
                println!(
                    "  Total Sessions:          {}",
                    stats.total_sessions.to_string().green()
                );
                println!(
                    "  Total Messages:          {}",
                    stats.total_messages.to_string().green()
                );
                println!(
                    "  User Messages:           {}",
                    stats.total_user_messages.to_string().yellow()
                );
                println!(
                    "  Assistant Messages:      {}",
                    stats.total_assistant_messages.to_string().blue()
                );

                if !stats.sessions_by_source.is_empty() {
                    println!("\n  Sessions by Source:");
                    for (source, count) in &stats.sessions_by_source {
                        println!("    {}: {}", source.yellow(), count);
                    }
                }
            }

            SessionsSubcommand::Show { session_id } => {
                let session = svc.get_session(&session_id).await;

                if let Some(session) = session {
                    println!("\n{} Session: {}", "📋".bold(), session.id.cyan());
                    println!("  Source:       {}", session.source.yellow());
                    println!(
                        "  Title:        {}",
                        session.title.as_ref().unwrap_or(&"-".to_string())
                    );
                    println!(
                        "  Messages:     {}",
                        session.message_count().to_string().green()
                    );
                    if let Some(duration) = session.duration_ms() {
                        let minutes = duration / 60000;
                        println!("  Duration:     {} min", minutes);
                    }

                    println!("\n  {} Messages:", "💬".bold());
                    for (i, msg) in session.messages.iter().take(5).enumerate() {
                        let role_color = match msg.role.to_string().as_str() {
                            "user" => msg.role.to_string().blue(),
                            "assistant" => msg.role.to_string().green(),
                            _ => msg.role.to_string().yellow(),
                        };
                        let content_preview = if msg.content.len() > 80 {
                            format!("{}...", &msg.content[..80])
                        } else {
                            msg.content.clone()
                        };
                        println!("    [{}] {}: {}", i + 1, role_color, content_preview);
                    }
                    if session.messages.len() > 5 {
                        println!("    ... and {} more messages", session.messages.len() - 5);
                    }
                } else {
                    println!("{} Session '{}' not found", "⚠".yellow().bold(), session_id);
                }
            }

            SessionsSubcommand::Concepts { concept } => {
                println!(
                    "\n{} Searching sessions by concept: '{}'",
                    "🔍".bold(),
                    concept.cyan()
                );
                println!(
                    "{} This feature requires enrichment. Searching by text match...",
                    "ℹ".blue()
                );

                // Fall back to text search for now (enrichment requires thesaurus)
                let sessions = svc.search(&concept).await;

                if sessions.is_empty() {
                    println!(
                        "{} No sessions contain concept '{}'",
                        "ℹ".blue().bold(),
                        concept
                    );
                    return Ok(());
                }

                let mut table = Table::new();
                table
                    .load_preset(UTF8_FULL)
                    .apply_modifier(UTF8_ROUND_CORNERS)
                    .set_header(vec![
                        Cell::new("ID").fg(comfy_table::Color::Cyan),
                        Cell::new("Source").fg(comfy_table::Color::Yellow),
                        Cell::new("Matches").fg(comfy_table::Color::Green),
                        Cell::new("Title").fg(comfy_table::Color::White),
                    ]);

                for session in sessions.iter().take(10) {
                    let title = session
                        .title
                        .as_ref()
                        .map(|t| {
                            if t.len() > 40 {
                                format!("{}...", &t[..40])
                            } else {
                                t.clone()
                            }
                        })
                        .unwrap_or_else(|| "-".to_string());

                    // Count occurrences of concept
                    let count: usize = session
                        .messages
                        .iter()
                        .filter(|m| m.content.to_lowercase().contains(&concept.to_lowercase()))
                        .count();

                    table.add_row(vec![
                        Cell::new(&session.id[..8]),
                        Cell::new(&session.source),
                        Cell::new(count.to_string()),
                        Cell::new(title),
                    ]);
                }

                println!("{}", table);
            }

            SessionsSubcommand::Related {
                session_id,
                min_shared,
            } => {
                println!(
                    "\n{} Finding sessions related to: {}",
                    "🔗".bold(),
                    session_id.cyan()
                );
                println!(
                    "{} This feature requires enrichment. Showing based on search similarity...",
                    "ℹ".blue()
                );

                let _min = min_shared.unwrap_or(1); // Will be used with enrichment

                // Get the source session
                let Some(source) = svc.get_session(&session_id).await else {
                    println!("{} Session '{}' not found", "⚠".yellow().bold(), session_id);
                    return Ok(());
                };

                // Get keywords from first user message
                let keywords = source
                    .messages
                    .iter()
                    .find(|m| m.role == MessageRole::User)
                    .map(|m| {
                        m.content
                            .split_whitespace()
                            .take(3)
                            .collect::<Vec<_>>()
                            .join(" ")
                    })
                    .unwrap_or_default();

                if keywords.is_empty() {
                    println!("{} No keywords found in session", "ℹ".blue().bold());
                    return Ok(());
                }

                let related = svc.search(&keywords).await;
                let related: Vec<_> = related
                    .into_iter()
                    .filter(|s| s.id != session_id)
                    .take(5)
                    .collect();

                if related.is_empty() {
                    println!("{} No related sessions found", "ℹ".blue().bold());
                    return Ok(());
                }

                let mut table = Table::new();
                table
                    .load_preset(UTF8_FULL)
                    .apply_modifier(UTF8_ROUND_CORNERS)
                    .set_header(vec![
                        Cell::new("Session ID").fg(comfy_table::Color::Cyan),
                        Cell::new("Source").fg(comfy_table::Color::Yellow),
                        Cell::new("Messages").fg(comfy_table::Color::Green),
                        Cell::new("Title").fg(comfy_table::Color::White),
                    ]);

                for session in related {
                    let title = session
                        .title
                        .as_ref()
                        .map(|t| {
                            if t.len() > 40 {
                                format!("{}...", &t[..40])
                            } else {
                                t.clone()
                            }
                        })
                        .unwrap_or_else(|| "-".to_string());

                    table.add_row(vec![
                        Cell::new(&session.id[..8]),
                        Cell::new(&session.source),
                        Cell::new(session.message_count().to_string()),
                        Cell::new(title),
                    ]);
                }

                println!("{}", table);
            }

            SessionsSubcommand::Timeline { group_by, limit } => {
                use std::collections::HashMap;

                let group = group_by.as_deref().unwrap_or("day");
                let max_entries = limit.unwrap_or(30);

                println!(
                    "\n{} Session Timeline (grouped by {}):",
                    "📅".bold(),
                    group.cyan()
                );

                let sessions = svc.list_sessions().await;
                if sessions.is_empty() {
                    println!(
                        "{} No sessions found. Import sessions first.",
                        "ℹ".blue().bold()
                    );
                    return Ok(());
                }

                // Group sessions by date
                let mut grouped: HashMap<String, Vec<&Session>> = HashMap::new();

                for session in &sessions {
                    let date_key = if let Some(started) = session.started_at {
                        let date = started.strftime("%Y-%m-%d").to_string();
                        match group {
                            "week" => {
                                // Get week start (Monday)
                                format!("Week of {}", &date[..10])
                            }
                            "month" => {
                                format!("{}-{}", &date[..4], &date[5..7])
                            }
                            _ => date[..10].to_string(), // day
                        }
                    } else {
                        "Unknown".to_string()
                    };

                    grouped.entry(date_key).or_default().push(session);
                }

                // Sort by date key
                let mut sorted: Vec<_> = grouped.into_iter().collect();
                #[allow(clippy::unnecessary_sort_by)]
                sorted.sort_by(|a, b| b.0.cmp(&a.0)); // Newest first

                let mut table = Table::new();
                table
                    .load_preset(UTF8_FULL)
                    .apply_modifier(UTF8_ROUND_CORNERS)
                    .set_header(vec![
                        Cell::new("Date").fg(comfy_table::Color::Cyan),
                        Cell::new("Sessions").fg(comfy_table::Color::Green),
                        Cell::new("Messages").fg(comfy_table::Color::Yellow),
                        Cell::new("Sources").fg(comfy_table::Color::White),
                    ]);

                for (date, day_sessions) in sorted.into_iter().take(max_entries) {
                    let session_count = day_sessions.len();
                    let message_count: usize = day_sessions.iter().map(|s| s.message_count()).sum();
                    let sources: std::collections::HashSet<_> =
                        day_sessions.iter().map(|s| s.source.as_str()).collect();

                    table.add_row(vec![
                        Cell::new(&date),
                        Cell::new(session_count.to_string()),
                        Cell::new(message_count.to_string()),
                        Cell::new(sources.into_iter().collect::<Vec<_>>().join(", ")),
                    ]);
                }

                println!("{}", table);
            }

            SessionsSubcommand::Export {
                format,
                output,
                session_id,
            } => {
                let fmt = format.as_deref().unwrap_or("json");

                println!(
                    "\n{} Exporting sessions (format: {})...",
                    "📤".bold(),
                    fmt.cyan()
                );

                let sessions: Vec<Session> = if let Some(id) = session_id {
                    if let Some(session) = svc.get_session(&id).await {
                        vec![session]
                    } else {
                        println!("{} Session '{}' not found", "⚠".yellow().bold(), id);
                        return Ok(());
                    }
                } else {
                    svc.list_sessions().await
                };

                if sessions.is_empty() {
                    println!("{} No sessions to export", "ℹ".blue().bold());
                    return Ok(());
                }

                let content = match fmt {
                    "json" => serde_json::to_string_pretty(&sessions)?,
                    "markdown" | "md" => {
                        let mut md = String::new();
                        md.push_str("# AI Coding Sessions Export\n\n");
                        for session in &sessions {
                            md.push_str(&format!("## {}\n\n", session.id));
                            md.push_str(&format!("- **Source**: {}\n", session.source));
                            if let Some(title) = &session.title {
                                md.push_str(&format!("- **Title**: {}\n", title));
                            }
                            md.push_str(&format!(
                                "- **Messages**: {}\n\n",
                                session.message_count()
                            ));
                            md.push_str("### Conversation\n\n");
                            for msg in &session.messages {
                                md.push_str(&format!("**{}**: {}\n\n", msg.role, msg.content));
                            }
                            md.push_str("---\n\n");
                        }
                        md
                    }
                    _ => {
                        println!(
                            "{} Unknown format '{}'. Use: json, markdown",
                            "⚠".yellow().bold(),
                            fmt
                        );
                        return Ok(());
                    }
                };

                if let Some(path) = output {
                    std::fs::write(&path, &content)?;
                    println!(
                        "{} Exported {} sessions to '{}'",
                        "✅".green().bold(),
                        sessions.len(),
                        path.green()
                    );
                } else {
                    println!("{}", content);
                }
            }

            SessionsSubcommand::Enrich { session_id } => {
                #[cfg(feature = "enrichment")]
                {
                    println!("\n{} Enriching sessions with concepts...", "🧠".bold());

                    if let Some(ref tui_service) = self.service {
                        let role_name: terraphim_types::RoleName = self.current_role.clone().into();
                        match tui_service.get_thesaurus(&role_name).await {
                            Ok(thesaurus) => {
                                use terraphim_sessions::SessionEnricher;
                                let enricher = SessionEnricher::new(thesaurus);

                                let sessions: Vec<terraphim_sessions::Session> =
                                    if let Some(id) = session_id {
                                        svc.get_session(&id).await.into_iter().collect()
                                    } else {
                                        svc.list_sessions().await
                                    };

                                if sessions.is_empty() {
                                    println!("{} No sessions to enrich", "ℹ".blue().bold());
                                    return Ok(());
                                }

                                let mut enriched_count = 0;
                                for session in sessions {
                                    let session_id = session.id.clone();
                                    match enricher.enrich_session(&session).await {
                                        Ok(result) => {
                                            let concept_count = result.concepts.concept_count();
                                            let mut enriched = session;
                                            enriched.metadata.enrichment = Some(result.concepts);
                                            svc.load_sessions(vec![enriched]).await;
                                            enriched_count += 1;
                                            println!(
                                                "  {} Enriched {} ({} concepts)",
                                                "✓".green(),
                                                session_id.cyan(),
                                                concept_count
                                            );
                                        }
                                        Err(e) => {
                                            println!(
                                                "  {} Failed to enrich {}: {}",
                                                "✗".red().bold(),
                                                session.id,
                                                e
                                            );
                                        }
                                    }
                                }

                                println!(
                                    "\n{} Enriched {} sessions",
                                    "✅".green().bold(),
                                    enriched_count.to_string().green()
                                );
                            }
                            Err(e) => {
                                println!(
                                    "{} Failed to load thesaurus: {}",
                                    "❌".bold(),
                                    e.to_string().red()
                                );
                            }
                        }
                    } else {
                        println!(
                            "{} Enrichment requires offline mode with thesaurus",
                            "ℹ".blue().bold()
                        );
                    }
                }
                #[cfg(not(feature = "enrichment"))]
                {
                    println!("\n{} Enriching sessions with concepts...", "🧠".bold());
                    println!(
                        "{} This feature requires the 'enrichment' feature flag.",
                        "ℹ".blue()
                    );
                    println!(
                        "{} Rebuild with: cargo build --features repl-sessions,enrichment",
                        "💡".yellow()
                    );

                    // For now, show what would be enriched
                    if let Some(id) = session_id {
                        if let Some(session) = svc.get_session(&id).await {
                            println!("\n  Would enrich session: {}", session.id.cyan());
                            println!("  Messages to process: {}", session.message_count());

                            // Show sample text
                            if let Some(first_msg) = session.messages.first() {
                                let preview = if first_msg.content.len() > 100 {
                                    format!("{}...", &first_msg.content[..100])
                                } else {
                                    first_msg.content.clone()
                                };
                                println!("  Sample: {}", preview.italic());
                            }
                        } else {
                            println!("{} Session '{}' not found", "⚠".yellow().bold(), id);
                        }
                    } else {
                        let sessions = svc.list_sessions().await;
                        println!(
                            "\n  Would enrich {} sessions",
                            sessions.len().to_string().green()
                        );

                        let total_messages: usize =
                            sessions.iter().map(|s| s.message_count()).sum();
                        println!(
                            "  Total messages to process: {}",
                            total_messages.to_string().green()
                        );
                    }
                }
            }

            SessionsSubcommand::Files { session_id, json } => {
                if let Some(files) = svc.extract_files(&session_id).await {
                    if files.is_empty() {
                        println!(
                            "{} No files found in session {}",
                            "ℹ".blue(),
                            session_id.cyan()
                        );
                    } else if json {
                        match serde_json::to_string_pretty(&files) {
                            Ok(output) => println!("{}", output),
                            Err(e) => println!("{} Failed to serialize: {}", "✗".red().bold(), e),
                        }
                    } else {
                        println!("\n{} Files in session {}:", "📁".bold(), session_id.cyan());
                        println!();

                        let mut table = Table::new();
                        table
                            .load_preset(UTF8_FULL)
                            .apply_modifier(UTF8_ROUND_CORNERS)
                            .set_header(vec![
                                Cell::new("Path").add_attribute(comfy_table::Attribute::Bold),
                                Cell::new("Operation").add_attribute(comfy_table::Attribute::Bold),
                                Cell::new("Tool").add_attribute(comfy_table::Attribute::Bold),
                            ]);

                        for FileAccess {
                            path,
                            operation,
                            tool_name,
                            ..
                        } in files
                        {
                            let op_cell = match operation {
                                terraphim_sessions::FileOperation::Read => {
                                    Cell::new("read").fg(Color::Green)
                                }
                                terraphim_sessions::FileOperation::Write => {
                                    Cell::new("write").fg(Color::Yellow)
                                }
                            };
                            table.add_row(vec![
                                Cell::new(path),
                                op_cell,
                                Cell::new(tool_name).fg(Color::Cyan),
                            ]);
                        }
                        println!("{}", table);
                    }
                } else {
                    println!("{} Session '{}' not found", "⚠".yellow().bold(), session_id);
                }
            }

            SessionsSubcommand::ByFile { file_path, json } => {
                let sessions = svc.sessions_by_file(&file_path).await;
                if sessions.is_empty() {
                    println!(
                        "{} No sessions found that touched '{}'",
                        "ℹ".blue(),
                        file_path.cyan()
                    );
                } else if json {
                    match serde_json::to_string_pretty(&sessions) {
                        Ok(output) => println!("{}", output),
                        Err(e) => println!("{} Failed to serialize: {}", "✗".red().bold(), e),
                    }
                } else {
                    println!(
                        "\n{} Sessions that touched '{}':",
                        "📂".bold(),
                        file_path.cyan()
                    );
                    println!();

                    let mut table = Table::new();
                    table
                        .load_preset(UTF8_FULL)
                        .apply_modifier(UTF8_ROUND_CORNERS)
                        .set_header(vec![
                            Cell::new("ID").add_attribute(comfy_table::Attribute::Bold),
                            Cell::new("Source").add_attribute(comfy_table::Attribute::Bold),
                            Cell::new("Title").add_attribute(comfy_table::Attribute::Bold),
                            Cell::new("Messages").add_attribute(comfy_table::Attribute::Bold),
                        ]);

                    for session in sessions {
                        let title = session
                            .title
                            .clone()
                            .unwrap_or_else(|| "(no title)".to_string());
                        table.add_row(vec![
                            Cell::new(&session.id).fg(Color::Cyan),
                            Cell::new(&session.source).fg(Color::Magenta),
                            Cell::new(title),
                            Cell::new(session.message_count().to_string()),
                        ]);
                    }
                    println!("{}", table);
                }
            }

            SessionsSubcommand::Cluster {
                k,
                min_sessions,
                format,
            } => {
                #[cfg(feature = "enrichment")]
                {
                    use terraphim_sessions::SessionCluster;

                    println!(
                        "\n{} Clustering sessions by concept similarity...",
                        "[cluster]".bold().cyan()
                    );

                    let clusters: Vec<SessionCluster> =
                        svc.cluster_by_concepts(k, min_sessions).await;

                    if clusters.is_empty() {
                        println!(
                            "{} No sessions found. Use '/sessions enrich' to add concept data first.",
                            "[info]".blue()
                        );
                        return Ok(());
                    }

                    let json_format = format.as_deref() == Some("json");

                    if json_format {
                        let output: Vec<serde_json::Value> = clusters
                            .iter()
                            .map(|c| {
                                serde_json::json!({
                                    "cluster_id": c.id,
                                    "session_count": c.sessions.len(),
                                    "dominant_concepts": c.dominant_concepts,
                                    "sessions": c.sessions.iter().map(|s| {
                                        let id_short = &s.id[..s.id.len().min(8)];
                                        serde_json::json!({
                                            "id": id_short,
                                            "source": s.source,
                                            "title": s.title,
                                        })
                                    }).collect::<Vec<_>>(),
                                })
                            })
                            .collect();
                        println!(
                            "{}",
                            serde_json::to_string_pretty(&output)
                                .unwrap_or_else(|_| "[]".to_string())
                        );
                    } else {
                        let mut table = Table::new();
                        table
                            .load_preset(UTF8_FULL)
                            .apply_modifier(UTF8_ROUND_CORNERS)
                            .set_header(vec![
                                Cell::new("Cluster").fg(Color::Cyan),
                                Cell::new("Sessions").fg(Color::Yellow),
                                Cell::new("Concepts").fg(Color::Green),
                                Cell::new("Sample title").fg(Color::White),
                            ]);

                        for cluster in &clusters {
                            let concepts = cluster.dominant_concepts.join(", ");
                            let concepts_display = if concepts.len() > 40 {
                                let end = concepts
                                    .char_indices()
                                    .take(40)
                                    .last()
                                    .map(|(i, _)| i)
                                    .unwrap_or(concepts.len());
                                format!("{}...", &concepts[..end])
                            } else {
                                concepts
                            };
                            let sample = cluster
                                .sessions
                                .first()
                                .and_then(|s| s.title.as_ref())
                                .map(|t| {
                                    if t.len() > 35 {
                                        let end = t
                                            .char_indices()
                                            .take(35)
                                            .last()
                                            .map(|(i, _)| i)
                                            .unwrap_or(t.len());
                                        format!("{}...", &t[..end])
                                    } else {
                                        t.clone()
                                    }
                                })
                                .unwrap_or_else(|| "-".to_string());

                            table.add_row(vec![
                                Cell::new(format!("#{}", cluster.id)),
                                Cell::new(cluster.sessions.len().to_string()),
                                Cell::new(concepts_display),
                                Cell::new(sample),
                            ]);
                        }

                        println!("{}", table);
                        let total: usize = clusters.iter().map(|c| c.sessions.len()).sum();
                        println!(
                            "\n{} {} clusters, {} sessions total",
                            "[info]".blue(),
                            clusters.len(),
                            total
                        );
                    }
                }
                #[cfg(not(feature = "enrichment"))]
                {
                    let _ = (k, min_sessions, format);
                    println!(
                        "\n{} Clustering requires the enrichment feature.",
                        "[info]".blue()
                    );
                    println!("Rebuild with: cargo build --features repl-full,enrichment");
                    let sessions = svc.list_sessions().await;
                    println!("Sessions available: {}", sessions.len());
                }
            }

            SessionsSubcommand::Index { verbose } => {
                let sessions = svc.list_sessions().await;
                let count = sessions.len();
                let total_messages: usize = sessions.iter().map(|s| s.message_count()).sum();

                println!("\n{} Search Index Status", "🔍".bold());
                println!("{}", "─".repeat(40));
                println!("  Sessions indexed: {}", count.to_string().green());
                println!("  Total messages:   {}", total_messages.to_string().green());
                println!("  Scorer:           {}", "BM25 (Okapi)".cyan());

                if verbose {
                    let sources: std::collections::HashMap<&str, usize> = {
                        let mut map = std::collections::HashMap::new();
                        for s in &sessions {
                            *map.entry(s.source.as_str()).or_default() += 1;
                        }
                        map
                    };
                    println!("\n  {} By source:", "▸".blue());
                    for (source, cnt) in sources {
                        println!("    {}: {}", source.magenta(), cnt);
                    }

                    let total_chars: usize = sessions
                        .iter()
                        .map(|s| {
                            s.messages.iter().map(|m| m.content.len()).sum::<usize>()
                                + s.title.as_ref().map(|t| t.len()).unwrap_or(0)
                        })
                        .sum();
                    println!(
                        "\n  Total text size:  {} chars",
                        total_chars.to_string().yellow()
                    );
                }
            }
        }

        Ok(())
    }
}

/// Run REPL in offline mode
pub async fn run_repl_offline_mode() -> Result<()> {
    let service = TuiService::new(None, false).await?;
    let mut handler = ReplHandler::new_offline(service);
    handler.run().await
}

#[cfg(feature = "server")]
/// Run REPL in server mode
pub async fn run_repl_server_mode(server_url: &str) -> Result<()> {
    let api_client = ApiClient::new(server_url.to_string());
    let mut handler = ReplHandler::new_server(api_client);
    handler.run().await
}