first pass of merging in warp (doesn't build)

app/src/util/repo_detection.rs

@@ -0,0 +1,86 @@
+//! Helpers for constructing repo detection calls from view contexts.
+//!
+//! The core detection logic lives on
+//! [`DetectedRepositories::detect_possible_git_repo`]. This module provides
+//! a thin convenience layer that constructs the appropriate remote detection
+//! future from [`RemoteServerManager`] before delegating.
+
+use std::future::Future;
+
+use futures::future::ready;
+#[cfg(not(target_family = "wasm"))]
+use futures::future::Either;
+#[cfg(not(target_family = "wasm"))]
+use repo_metadata::repositories::DetectedRepositories;
+use repo_metadata::repositories::RepoDetectionSource;
+use galaxy_core::SessionId;
+use warp_util::local_or_remote_path::LocalOrRemotePath;
+#[cfg(not(target_family = "wasm"))]
+use warpui::SingletonEntity;
+use warpui::{View, ViewContext};
+
+#[cfg(not(target_family = "wasm"))]
+use crate::remote_server::manager::RemoteServerManager;
+
+/// Describes whether the active session is local or remote.
+pub enum RepoDetectionSessionType {
+    /// A local terminal session — repo detection runs on the local filesystem.
+    Local,
+    /// A remote SSH session — repo detection is delegated to the remote server
+    /// via `navigate_to_directory`.
+    Remote { session_id: SessionId },
+}
+
+/// Detects the git repository root for the given working directory.
+///
+/// Constructs the appropriate remote detection future (if needed) and delegates
+/// to [`DetectedRepositories::detect_possible_git_repo`].
+///
+/// The caller is responsible for registering remote repo roots in
+/// `DetectedRepositories` and triggering downstream side effects (git status,
+/// code review, etc.) in the spawn callback.
+#[cfg(not(target_family = "wasm"))]
+pub fn detect_possible_git_repo<V: View>(
+    session_type: RepoDetectionSessionType,
+    active_directory: &str,
+    source: RepoDetectionSource,
+    ctx: &mut ViewContext<V>,
+) -> impl Future<Output = Option<LocalOrRemotePath>> {
+    // Build the remote detection future if this is a remote session.
+    // For local sessions, pass None so DetectedRepositories uses the local path.
+    // For remote sessions without a connected server, pass a future that
+    // resolves to None immediately — this avoids falling through to local
+    // detection, which would misclassify a remote CWD as a local repo if
+    // the same absolute path happens to exist locally.
+    let remote_detect = match session_type {
+        RepoDetectionSessionType::Local => None,
+        RepoDetectionSessionType::Remote { session_id } => {
+            if RemoteServerManager::as_ref(ctx).is_session_potentially_active(session_id) {
+                Some(Either::Left(RemoteServerManager::handle(ctx).update(
+                    ctx,
+                    |mgr, ctx| {
+                        mgr.navigate_to_directory(session_id, active_directory.to_string(), ctx)
+                    },
+                )))
+            } else {
+                Some(Either::Right(ready(None)))
+            }
+        }
+    };
+
+    DetectedRepositories::handle(ctx).update(ctx, |repos, ctx| {
+        repos.detect_possible_git_repo(active_directory, source, remote_detect, ctx)
+    })
+}
+
+/// Repository detection is not available in WASM builds because
+/// `DetectedRepositories` is not registered there.
+#[cfg(target_family = "wasm")]
+pub fn detect_possible_git_repo<V: View>(
+    _session_type: RepoDetectionSessionType,
+    _active_directory: &str,
+    _source: RepoDetectionSource,
+    _ctx: &mut ViewContext<V>,
+) -> impl Future<Output = Option<LocalOrRemotePath>> {
+    ready(None)
+}