[5/5] Handle remote codebase auto-index follow-ups (#11092)

## Description

1. Allow for going from no auto indexing of repo -> auto starting
indexing when the setting gets changed. Calling out that even if
indexing hasn't happened for the repo, the agent knows that it has the
search codebase tool available to itself (this is true for local)
2. Pass the number of allowed indexed repos

## Testing
Added unit tests + local tests
- [x] I have manually tested my changes locally with `./script/run`

### Screenshots / Videos
https://www.loom.com/share/a2e572c9338e43d0b329ef241256b91d

## Agent Mode
- [x] Warp Agent Mode - This PR was created via Warp's AI Agent Mode

CHANGELOG-BUG-FIX: Fix remote codebase indexing incremental sync and
queued-status reporting for indexes that do not actually start.

_Conversation:
https://staging.warp.dev/conversation/cdd3638d-f1c3-479f-ab50-f62018beee7e_
_Run:
https://oz.staging.warp.dev/runs/019e2e95-b78f-79f5-892a-56aa7d09b25a_
_This PR was generated with [Oz](https://warp.dev/oz)._

---------

Co-authored-by: Oz <oz-agent@warp.dev>

Author: moirahuang

app/src/ai/codebase_auto_indexing.rs

@@ -0,0 +1,133 @@
+use std::collections::HashSet;
+use std::hash::Hash;
+
+use warp_core::features::FeatureFlag;
+use warpui::{AppContext, SingletonEntity};
+
+use crate::settings::CodeSettings;
+use crate::workspaces::user_workspaces::UserWorkspaces;
+
+#[derive(Clone, Copy, Debug)]
+pub(crate) enum CodebaseAutoIndexingSurface {
+    Local,
+    Remote,
+}
+
+impl CodebaseAutoIndexingSurface {
+    fn required_feature_enabled(self) -> bool {
+        match self {
+            Self::Local => true,
+            Self::Remote => FeatureFlag::RemoteCodebaseIndexing.is_enabled(),
+        }
+    }
+}
+
+pub(crate) fn should_auto_index_codebase(
+    surface: CodebaseAutoIndexingSurface,
+    ctx: &AppContext,
+) -> bool {
+    codebase_auto_indexing_enabled(
+        surface,
+        UserWorkspaces::as_ref(ctx).is_codebase_context_enabled(ctx),
+        *CodeSettings::as_ref(ctx).auto_indexing_enabled,
+    )
+}
+
+pub(crate) fn codebase_auto_indexing_enabled(
+    surface: CodebaseAutoIndexingSurface,
+    codebase_context_enabled: bool,
+    auto_indexing_enabled: bool,
+) -> bool {
+    FeatureFlag::FullSourceCodeEmbedding.is_enabled()
+        && surface.required_feature_enabled()
+        && codebase_context_enabled
+        && auto_indexing_enabled
+}
+
+pub(crate) fn auto_index_candidate_roots<Root>(
+    roots: impl IntoIterator<Item = Root>,
+    mut should_request_index: impl FnMut(&Root) -> bool,
+) -> Vec<Root>
+where
+    Root: Clone + Eq + Hash,
+{
+    let mut seen = HashSet::new();
+    let mut candidates = Vec::new();
+    for root in roots {
+        if seen.insert(root.clone()) && should_request_index(&root) {
+            candidates.push(root);
+        }
+    }
+    candidates
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn local_auto_indexing_requires_full_source_code_embedding_codebase_context_and_auto_indexing()
+    {
+        {
+            let _flag = FeatureFlag::FullSourceCodeEmbedding.override_enabled(false);
+            assert!(!codebase_auto_indexing_enabled(
+                CodebaseAutoIndexingSurface::Local,
+                true,
+                true,
+            ));
+        }
+        {
+            let _flag = FeatureFlag::FullSourceCodeEmbedding.override_enabled(true);
+            assert!(codebase_auto_indexing_enabled(
+                CodebaseAutoIndexingSurface::Local,
+                true,
+                true,
+            ));
+            assert!(!codebase_auto_indexing_enabled(
+                CodebaseAutoIndexingSurface::Local,
+                false,
+                true,
+            ));
+            assert!(!codebase_auto_indexing_enabled(
+                CodebaseAutoIndexingSurface::Local,
+                true,
+                false,
+            ));
+            assert!(!codebase_auto_indexing_enabled(
+                CodebaseAutoIndexingSurface::Local,
+                false,
+                false,
+            ));
+        }
+    }
+
+    #[test]
+    fn remote_auto_indexing_requires_remote_feature() {
+        {
+            let _remote_flag = FeatureFlag::RemoteCodebaseIndexing.override_enabled(false);
+            let _flag = FeatureFlag::FullSourceCodeEmbedding.override_enabled(true);
+            assert!(!codebase_auto_indexing_enabled(
+                CodebaseAutoIndexingSurface::Remote,
+                true,
+                true,
+            ));
+        }
+        {
+            let _remote_flag = FeatureFlag::RemoteCodebaseIndexing.override_enabled(true);
+            let _flag = FeatureFlag::FullSourceCodeEmbedding.override_enabled(true);
+            assert!(codebase_auto_indexing_enabled(
+                CodebaseAutoIndexingSurface::Remote,
+                true,
+                true,
+            ));
+        }
+    }
+
+    #[test]
+    fn candidate_roots_are_deduped_before_filtering() {
+        let roots = vec!["/repo", "/repo", "/other"];
+        let candidates = auto_index_candidate_roots(roots, |root| *root != "/other");
+
+        assert_eq!(candidates, vec!["/repo"]);
+    }
+}

app/src/ai/get_relevant_files/remote_search/native.rs

@@ -141,7 +141,7 @@ async fn execute_remote_codebase_search(
         .codebase_context_config()
         .await?
         .embedding_config;
-    log::info!(
+    log::debug!(
         "[Remote codebase indexing] Remote codebase search using embedding config: repo_path={repo_path} embedding_config={embedding_config:?}"
     );
     let candidate_hashes = store_client

app/src/ai/mod.rs

@@ -18,6 +18,8 @@ pub mod auth_secret_types;
 pub mod aws_credentials;
 pub(crate) mod block_context;
 pub(crate) mod blocklist;
+#[cfg(any(feature = "local_fs", not(target_family = "wasm")))]
+pub(crate) mod codebase_auto_indexing;
 pub mod control_code_parser;
 pub(crate) mod conversation_details_panel;
 pub(crate) mod conversation_navigation;

app/src/ai/persisted_workspace.rs

@@ -11,6 +11,10 @@ use repo_metadata::repositories::{DetectedRepositories, DetectedRepositoriesEven
 use serde::{Deserialize, Serialize};
 
 use crate::ai::blocklist::{BlocklistAIHistoryEvent, BlocklistAIHistoryModel};
+#[cfg(feature = "local_fs")]
+use crate::ai::codebase_auto_indexing::{
+    auto_index_candidate_roots, should_auto_index_codebase, CodebaseAutoIndexingSurface,
+};
 use crate::ai::AIRequestUsageModel;
 use crate::persistence::ModelEvent;
 use crate::report_if_error;
@@ -29,6 +33,8 @@ use itertools::Itertools;
 use lsp::supported_servers::LSPServerType;
 use warp_core::features::FeatureFlag;
 #[cfg(feature = "local_fs")]
+use warp_util::local_or_remote_path::LocalOrRemotePath;
+#[cfg(feature = "local_fs")]
 use warpui::windowing::WindowManager;
 use warpui::{AppContext, Entity, ModelContext, SingletonEntity};
 
@@ -651,19 +657,14 @@ impl PersistedWorkspace {
         );
 
         #[cfg(feature = "local_fs")]
-        for dir in all_working_directories(ctx) {
-            // Auto-index working directory ONLY if the user has "Read files" set to "Always allow" OR this directory is in the allowlist.
-            let auto_indexing_enabled = *CodeSettings::as_ref(ctx).auto_indexing_enabled;
-
-            if auto_indexing_enabled {
-                if let Some(root) = DetectedRepositories::as_ref(ctx)
-                    .get_root_for_path(&warp_util::local_or_remote_path::LocalOrRemotePath::Local(
-                        dir.clone(),
-                    ))
-                    .and_then(|r| r.to_local_path().map(std::path::Path::to_path_buf))
-                {
-                    manager.index_directory(root, ctx);
-                }
+        if should_auto_index_codebase(CodebaseAutoIndexingSurface::Local, ctx) {
+            let roots = all_working_directories(ctx).into_iter().filter_map(|dir| {
+                DetectedRepositories::as_ref(ctx)
+                    .get_root_for_path(&LocalOrRemotePath::Local(dir))
+                    .and_then(|root| root.to_local_path().map(Path::to_path_buf))
+            });
+            for root in auto_index_candidate_roots(roots, |_| true) {
+                manager.index_directory(root, ctx);
             }
         }
     }
@@ -816,13 +817,21 @@ impl PersistedWorkspace {
             for terminal_view in terminal_views.into_iter().flatten() {
                 let terminal_view_ref = terminal_view.as_ref(ctx);
                 if terminal_view_ref.view_id() == terminal_view_id {
-                    if let Some(pwd) = terminal_view_ref.pwd() {
-                        let directory_path = Path::new(&pwd);
+                    if terminal_view_ref.active_session_is_local(ctx) != Some(true) {
+                        log::info!(
+                            "Skipping local codebase incremental sync for non-local agent conversation"
+                        );
+                        return;
+                    }
+
+                    let pwd = terminal_view_ref.pwd();
+                    if let Some(pwd) = pwd {
+                        let directory_path = PathBuf::from(pwd);
 
                         // Trigger an incremental sync through the CodebaseIndexManager
                         CodebaseIndexManager::handle(ctx).update(ctx, |codebase_manager, ctx| {
                             if let Err(e) = codebase_manager
-                                .trigger_incremental_sync_for_path(directory_path, ctx)
+                                .trigger_incremental_sync_for_path(&directory_path, ctx)
                             {
                                 log::warn!("Failed to trigger incremental sync {e}");
                             }