Skip to main content

pxh/recall/
command.rs

1use std::collections::HashSet;
2use std::io::{self, Write};
3use std::time::Instant;
4use std::{env, path::PathBuf};
5
6use anyhow::Result;
7use clap::Parser;
8use rusqlite::Connection;
9
10use super::engine::{SearchEngine, format_relative_time};
11use super::query::RecallQuery;
12use super::tui::RecallTui;
13use crate::config::Config;
14#[derive(Parser, Debug)]
15pub struct RecallCommand {
16    /// Search only in current directory
17    #[arg(long, conflicts_with = "global")]
18    pub here: bool,
19    /// Search across all directories (overrides --here in config)
20    #[arg(long)]
21    pub global: bool,
22    /// Initial search query
23    #[arg(long, short = 'q', allow_hyphen_values = true)]
24    pub query: Option<String>,
25    /// Print results instead of showing TUI
26    #[arg(long, short = 'p')]
27    pub print: bool,
28    /// Limit results when printing
29    #[arg(long, short = 'l', default_value = "20")]
30    pub limit: usize,
31    /// Show timing information
32    #[arg(long, hide = true)]
33    pub timing: bool,
34    /// Paint TUI once then exit (for profiling)
35    #[arg(long, hide = true)]
36    pub paint_then_exit: bool,
37    /// Shell integration mode (outputs command for shell to execute)
38    #[arg(long)]
39    pub shell_mode: bool,
40}
41
42/// Filter mode for recall search
43#[derive(Debug, Clone, Copy, PartialEq, Eq)]
44pub enum FilterMode {
45    /// Search only in current directory
46    Directory,
47    /// Search across all directories
48    Global,
49}
50
51/// Host filter mode for recall search
52#[derive(Debug, Clone, Copy, PartialEq, Eq, Default)]
53pub enum HostFilter {
54    /// Search only on current host
55    ThisHost,
56    /// Search across all hosts (default)
57    #[default]
58    AllHosts,
59}
60
61impl RecallCommand {
62    pub fn go(&self, conn: Connection) -> Result<()> {
63        let start = Instant::now();
64
65        let config_start = Instant::now();
66        let config = Config::load();
67        let config_time = config_start.elapsed();
68
69        let initial_mode = if self.here { FilterMode::Directory } else { FilterMode::Global };
70
71        let working_directory = env::var_os("PWD")
72            .map(PathBuf::from)
73            .or_else(|| env::current_dir().ok())
74            .unwrap_or_default();
75
76        let result_limit = if self.print { self.limit } else { config.recall.result_limit };
77        let host_set = crate::effective_host_set(&config);
78        let engine = SearchEngine::new(conn, working_directory, host_set, result_limit);
79
80        // Print mode: just query and print results, no TUI
81        if self.print {
82            let query_start = Instant::now();
83            let query = self.query.as_deref().map(RecallQuery::parse);
84            let entries =
85                engine.load_entries(initial_mode, HostFilter::default(), query.as_ref())?;
86            let query_time = query_start.elapsed();
87
88            // Deduplicate by command text (matching TUI behavior) and respect limit
89            let mut seen = HashSet::new();
90            let entries: Vec<_> = entries
91                .into_iter()
92                .filter(|e| seen.insert(e.command.trim_end().to_string()))
93                .take(self.limit)
94                .collect();
95
96            let mut stdout = io::stdout().lock();
97            for entry in &entries {
98                let time_str = format_relative_time(entry.timestamp);
99                writeln!(stdout, " {time_str}  {}", entry.command)?;
100            }
101
102            if self.timing {
103                let total = start.elapsed();
104                eprintln!("\nTiming:");
105                eprintln!("  Config load:  {config_time:?}");
106                eprintln!("  DB query:     {query_time:?}");
107                eprintln!("  Total:        {total:?}");
108                eprintln!("  Entries:      {}", entries.len());
109            }
110
111            return Ok(());
112        }
113
114        // TUI mode
115        let tui_start = Instant::now();
116        let mut tui = RecallTui::new(
117            engine,
118            initial_mode,
119            self.query.clone(),
120            &config.recall,
121            self.shell_mode,
122        )?;
123        let tui_init_time = tui_start.elapsed();
124
125        if self.paint_then_exit {
126            let draw_start = Instant::now();
127            tui.draw_once()?;
128            let draw_time = draw_start.elapsed();
129
130            if self.timing {
131                eprintln!("Timing:");
132                eprintln!("  Config load:  {config_time:?}");
133                eprintln!("  TUI init:     {tui_init_time:?}");
134                eprintln!("  Draw:         {draw_time:?}");
135                eprintln!("  Total:        {:?}", start.elapsed());
136            }
137            return Ok(());
138        }
139
140        if self.timing {
141            eprintln!("Timing (before run):");
142            eprintln!("  Config load:  {config_time:?}");
143            eprintln!("  TUI init:     {tui_init_time:?}");
144            eprintln!("  Total:        {:?}", start.elapsed());
145        }
146
147        match tui.run()? {
148            Some(selection) => {
149                // Output the selected command with mode prefix
150                // The shell integration will parse and handle accordingly
151                print!("{selection}");
152                Ok(())
153            }
154            None => {
155                // User cancelled - don't output anything
156                Ok(())
157            }
158        }
159    }
160}