chore: Commit

1 files changed, 22 insertions, 112 deletions

diff --git a/crates/daemon/src/client.rs b/crates/daemon/src/client.rs
index 5cccb5ff..5f8ea0f2 100644
--- a/crates/daemon/src/client.rs
+++ b/crates/daemon/src/client.rs
@@ -7,36 +7,25 @@ use hyper_util::rt::TokioIo;
 
 #[cfg(unix)]
 use tokio::net::UnixStream;
-use tracing::{Level, instrument, span};
 
+use crate::aclient::{history::History, settings::Settings};
 use crate::generated;
 use crate::{
-    atuin_client::{
-        database::Context,
-        history::History,
-        settings::{FilterMode, Settings},
-    },
-    atuin_daemon::{
-        events::DaemonEvent,
-        generated::{
-            control::{
-                ForceSyncEvent, HistoryDeletedEvent, HistoryPrunedEvent, HistoryRebuiltEvent,
-                SendEventRequest, SettingsReloadedEvent, ShutdownEvent,
-                control_client::ControlClient as ControlServiceClient,
-            },
-            history::{
-                EndHistoryReply, EndHistoryRequest, ShutdownRequest, StartHistoryReply,
-                StartHistoryRequest, StatusReply, StatusRequest, TailHistoryReply,
-                TailHistoryRequest, history_client::HistoryClient as HistoryServiceClient,
-            },
-            search::{
-                FilterMode as RpcFilterMode, SearchContext as RpcSearchContext, SearchRequest,
-                SearchResponse, search_client::SearchClient as SearchServiceClient,
-            },
-            semantic::{
-                CommandCapture, RecordCommandsReply,
-                semantic_client::SemanticClient as SemanticServiceClient,
-            },
+    events::DaemonEvent,
+    generated::{
+        control::{
+            ForceSyncEvent, HistoryDeletedEvent, HistoryPrunedEvent, HistoryRebuiltEvent,
+            SendEventRequest, SettingsReloadedEvent, ShutdownEvent,
+            control_client::ControlClient as ControlServiceClient,
+        },
+        history::{
+            EndHistoryReply, EndHistoryRequest, ShutdownRequest, StartHistoryReply,
+            StartHistoryRequest, StatusReply, StatusRequest, TailHistoryReply, TailHistoryRequest,
+            history_client::HistoryClient as HistoryServiceClient,
+        },
+        semantic::{
+            CommandCapture, RecordCommandsReply,
+            semantic_client::SemanticClient as SemanticServiceClient,
         },
     },
 };
@@ -129,7 +118,7 @@ impl HistoryClient {
         Ok(self.client.status(StatusRequest {}).await?.into_inner())
     }
 
-    pub async fn tail_history(&mut self) -> Result<tonic::Streaming<TailHistoryReply>> {
+    pub(crate) async fn tail_history(&mut self) -> Result<tonic::Streaming<TailHistoryReply>> {
         Ok(self
             .client
             .tail_history(TailHistoryRequest {})
@@ -143,92 +132,13 @@ impl HistoryClient {
     }
 }
 
-pub struct SearchClient {
-    client: SearchServiceClient<Channel>,
-}
-
-impl SearchClient {
-    #[cfg(unix)]
-    pub async fn new(path: String) -> Result<Self> {
-        let log_path = path.clone();
-        let channel = Endpoint::try_from("http://atuin_local_daemon:0")?
-            .connect_with_connector(service_fn(move |_: Uri| {
-                let path = path.clone();
-
-                async move {
-                    Ok::<_, std::io::Error>(TokioIo::new(UnixStream::connect(path.clone()).await?))
-                }
-            }))
-            .await
-            .wrap_err_with(|| {
-                format!(
-                    "failed to connect to local atuin daemon at {}. Is it running?",
-                    &log_path
-                )
-            })?;
-
-        let client = SearchServiceClient::new(channel);
-
-        Ok(Self { client })
-    }
-
-    #[instrument(skip_all, level = Level::TRACE, name = "daemon_client_search", fields(query = %query, query_id = query_id))]
-    pub async fn search(
-        &mut self,
-        query: String,
-        query_id: u64,
-        filter_mode: FilterMode,
-        context: Option<Context>,
-    ) -> Result<tonic::Streaming<SearchResponse>> {
-        let request = SearchRequest {
-            query,
-            query_id,
-            filter_mode: RpcFilterMode::from(filter_mode).into(),
-            context: context.map(RpcSearchContext::from),
-        };
-        let request_stream = tokio_stream::once(request);
-        let response = span!(Level::TRACE, "daemon_client_search.request")
-            .in_scope(async || self.client.search(request_stream).await)
-            .await?;
-
-        Ok(response.into_inner())
-    }
-}
-
-impl From<FilterMode> for RpcFilterMode {
-    fn from(filter_mode: FilterMode) -> Self {
-        match filter_mode {
-            FilterMode::Global => Self::Global,
-            FilterMode::Host => Self::Host,
-            FilterMode::Session => Self::Session,
-            FilterMode::Directory => Self::Directory,
-            FilterMode::Workspace => Self::Workspace,
-            FilterMode::SessionPreload => Self::SessionPreload,
-        }
-    }
-}
-
-impl From<Context> for RpcSearchContext {
-    fn from(context: Context) -> Self {
-        Self {
-            session_id: context.session,
-            cwd: context.cwd,
-            hostname: context.hostname,
-            host_id: context.host_id,
-            git_root: context
-                .git_root
-                .map(|path| path.to_string_lossy().to_string()),
-        }
-    }
-}
-
-pub struct SemanticClient {
+pub(crate) struct SemanticClient {
     client: SemanticServiceClient<Channel>,
 }
 
 impl SemanticClient {
     #[cfg(unix)]
-    pub async fn new(path: String) -> Result<Self> {
+    pub(crate) async fn new(path: String) -> Result<Self> {
         let log_path = path.clone();
         let channel = Endpoint::try_from("http://atuin_local_daemon:0")?
             .connect_with_connector(service_fn(move |_: Uri| {
@@ -252,11 +162,11 @@ impl SemanticClient {
     }
 
     #[cfg(unix)]
-    pub async fn from_settings(settings: &Settings) -> Result<Self> {
+    pub(crate) async fn from_settings(settings: &Settings) -> Result<Self> {
         Self::new(settings.daemon.socket_path.clone()).await
     }
 
-    pub async fn record_commands(
+    pub(crate) async fn record_commands(
         &mut self,
         captures: Vec<CommandCapture>,
     ) -> Result<RecordCommandsReply> {
@@ -279,7 +189,7 @@ pub struct ControlClient {
 impl ControlClient {
     /// Connect to the daemon's control service.
     #[cfg(unix)]
-    pub async fn new(path: String) -> Result<Self> {
+    pub(crate) async fn new(path: String) -> Result<Self> {
         let log_path = path.clone();
         let channel = Endpoint::try_from("http://atuin_local_daemon:0")?
             .connect_with_connector(service_fn(move |_: Uri| {