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 #[arg(long, conflicts_with = "global")]
18 pub here: bool,
19 #[arg(long)]
21 pub global: bool,
22 #[arg(long, short = 'q', allow_hyphen_values = true)]
24 pub query: Option<String>,
25 #[arg(long, short = 'p')]
27 pub print: bool,
28 #[arg(long, short = 'l', default_value = "20")]
30 pub limit: usize,
31 #[arg(long, hide = true)]
33 pub timing: bool,
34 #[arg(long, hide = true)]
36 pub paint_then_exit: bool,
37 #[arg(long)]
39 pub shell_mode: bool,
40}
41
42#[derive(Debug, Clone, Copy, PartialEq, Eq)]
44pub enum FilterMode {
45 Directory,
47 Global,
49}
50
51#[derive(Debug, Clone, Copy, PartialEq, Eq, Default)]
53pub enum HostFilter {
54 ThisHost,
56 #[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 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 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 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 print!("{selection}");
152 Ok(())
153 }
154 None => {
155 Ok(())
157 }
158 }
159 }
160}