fix: remote semantic status reporting and Windows path tests (#98)

Author: bartolli

src/cli/commands/index_parallel.rs

@@ -6,8 +6,11 @@
 use std::path::{Path, PathBuf};
 use std::sync::{Arc, Mutex};
 
+use crate::IndexPersistence;
 use crate::config::Settings;
-use crate::indexing::facade::{build_embedding_backend, resolve_remote_model_name};
+use crate::indexing::facade::{
+    build_embedding_backend, format_semantic_status, resolve_remote_model_name,
+};
 use crate::indexing::pipeline::{IncrementalStats, Phase2Stats, Pipeline, PipelineConfig};
 use crate::io::status_line::{ProgressBar, ProgressBarOptions, ProgressBarStyle};
 use crate::semantic::{EmbeddingBackend, SemanticSearchError, SimpleSemanticSearch};
@@ -121,6 +124,12 @@ pub fn run(args: IndexParallelArgs, settings: &Settings) {
         }
     }
 
+    let persistence = IndexPersistence::new(settings.index_path.clone());
+    if let Err(e) = persistence.save_document_index_metadata(index.as_ref(), &paths_to_index) {
+        tracing::error!(target: "pipeline", "Failed to persist index metadata: {e}");
+        std::process::exit(1);
+    }
+
     tracing::info!(target: "pipeline", "Index saved to: {}", index_path.display());
     if semantic.is_some() {
         tracing::info!(target: "pipeline", "Embeddings saved to: {}", semantic_path.display());
@@ -157,6 +166,11 @@ fn create_semantic_search(
     };
 
     let model = &settings.semantic_search.model;
+    let effective_model = if is_remote {
+        resolve_remote_model_name(&settings.semantic_search)
+    } else {
+        model.clone()
+    };
 
     // Load existing embeddings or create fresh instance.
     // After loading, verify dimensions match the backend so we don't silently
@@ -207,14 +221,19 @@ fn create_semantic_search(
         let new_result = if is_remote {
             Ok(SimpleSemanticSearch::new_empty(
                 backend.dimensions(),
-                &resolve_remote_model_name(&settings.semantic_search),
+                &effective_model,
             ))
         } else {
             SimpleSemanticSearch::from_model_name(model)
         };
         match new_result {
             Ok(s) => {
-                tracing::debug!(target: "pipeline", "Created new semantic search with model: {model}");
+                tracing::debug!(
+                    target: "pipeline",
+                    "Created new semantic search with model: {effective_model}"
+                );
+                let status = format_semantic_status(&settings.semantic_search);
+                eprintln!("{status}");
                 Some(Arc::new(Mutex::new(s)))
             }
             Err(e) => {

src/indexing/facade.rs

@@ -96,6 +96,10 @@ pub struct IndexFacade {
     /// Set to true when load_semantic_search fails with DimensionMismatch so
     /// hot-reload and other callers do not retry on every reload cycle.
     semantic_incompatible: bool,
+
+    /// Persisted semantic metadata for status/reporting when semantic search
+    /// is not loaded into memory (for example, lite facade loads).
+    semantic_metadata_snapshot: Option<crate::semantic::SemanticMetadata>,
 }
 
 impl IndexFacade {
@@ -126,6 +130,7 @@ impl IndexFacade {
             indexed_paths: HashSet::new(),
             index_base,
             semantic_incompatible: false,
+            semantic_metadata_snapshot: None,
         })
     }
 
@@ -151,6 +156,7 @@ impl IndexFacade {
             indexed_paths: HashSet::new(),
             index_base,
             semantic_incompatible: false,
+            semantic_metadata_snapshot: None,
         }
     }
 
@@ -201,6 +207,7 @@ impl IndexFacade {
         };
 
         self.semantic_search = Some(Arc::new(Mutex::new(semantic)));
+        self.semantic_metadata_snapshot = self.get_semantic_metadata();
         self.embedding_pool = Some(backend);
 
         Ok(())
@@ -289,6 +296,7 @@ impl IndexFacade {
                     }
 
                     self.semantic_search = Some(Arc::new(Mutex::new(semantic)));
+                    self.semantic_metadata_snapshot = self.get_semantic_metadata();
                     return Ok(true);
                 }
                 Err(SemanticSearchError::DimensionMismatch {
@@ -324,6 +332,18 @@ impl IndexFacade {
         Ok(false)
     }
 
+    /// Load persisted semantic metadata without initializing the semantic backend.
+    pub fn load_semantic_metadata_snapshot(&mut self, path: &Path) -> FacadeResult<bool> {
+        if !path.join("metadata.json").exists() {
+            self.semantic_metadata_snapshot = None;
+            return Ok(false);
+        }
+
+        let metadata = crate::semantic::SemanticMetadata::load(path)?;
+        self.semantic_metadata_snapshot = Some(metadata);
+        Ok(true)
+    }
+
     /// Ensure embedding backend is initialized for generating new embeddings.
     ///
     /// Called lazily by methods that need to compute embeddings (reindexing, watcher).
@@ -343,6 +363,11 @@ impl IndexFacade {
         self.semantic_search
             .as_ref()
             .map(|s| s.lock().map(|sem| sem.embedding_count()).unwrap_or(0))
+            .or_else(|| {
+                self.semantic_metadata_snapshot
+                    .as_ref()
+                    .map(|m| m.embedding_count)
+            })
             .unwrap_or(0)
     }
 
@@ -351,6 +376,7 @@ impl IndexFacade {
         self.semantic_search
             .as_ref()
             .and_then(|s| s.lock().ok().and_then(|sem| sem.metadata().cloned()))
+            .or_else(|| self.semantic_metadata_snapshot.clone())
     }
 
     // =========================================================================
@@ -1224,6 +1250,20 @@ pub fn resolve_remote_model_name(cfg: &crate::config::SemanticSearchConfig) -> S
         .unwrap_or_else(|| "text-embedding-ada-002".to_string())
 }
 
+/// Format a human-readable semantic search status line for CLI output.
+pub fn format_semantic_status(cfg: &crate::config::SemanticSearchConfig) -> String {
+    let is_remote = std::env::var("CODANNA_EMBED_URL").is_ok() || cfg.remote_url.is_some();
+    let threshold = cfg.threshold;
+
+    if is_remote {
+        let model = resolve_remote_model_name(cfg);
+        format!("Semantic search enabled (backend: remote, model: {model}, threshold: {threshold})")
+    } else {
+        let model = &cfg.model;
+        format!("Semantic search enabled (model: {model}, threshold: {threshold})")
+    }
+}
+
 pub fn build_embedding_backend(
     cfg: &crate::config::SemanticSearchConfig,
 ) -> FacadeResult<EmbeddingBackend> {

src/main.rs

@@ -5,7 +5,7 @@
 
 use clap::Parser;
 use codanna::cli::{Cli, Commands, RetrieveQuery};
-use codanna::indexing::facade::IndexFacade;
+use codanna::indexing::facade::{IndexFacade, format_semantic_status};
 use codanna::project_resolver::{
     providers::{
         csharp::CSharpProvider, go::GoProvider, java::JavaProvider, javascript::JavaScriptProvider,
@@ -414,10 +414,8 @@ async fn main() {
             if let Err(e) = idx.enable_semantic_search() {
                 eprintln!("Warning: Failed to enable semantic search: {e}");
             } else {
-                eprintln!(
-                    "Semantic search enabled (model: {}, threshold: {})",
-                    config.semantic_search.model, config.semantic_search.threshold
-                );
+                let status = format_semantic_status(&config.semantic_search);
+                eprintln!("{status}");
             }
         }
     }

src/parsing/java/behavior.rs

@@ -963,16 +963,13 @@ mod tests {
         fs::write(&pom_path, pom_content).unwrap();
 
         // Create settings and build provider cache
-        let settings_content = format!(
-            r#"
-[languages.java]
-enabled = true
-config_files = ["{}"]
-"#,
-            pom_path.display()
-        );
-
-        let settings: crate::config::Settings = toml::from_str(&settings_content).unwrap();
+        let mut settings = crate::config::Settings::default();
+        let java_settings = settings
+            .languages
+            .get_mut("java")
+            .expect("java language config should exist");
+        java_settings.enabled = true;
+        java_settings.config_files = vec![pom_path.clone()];
 
         // Save original directory to restore later
         let original_dir = std::env::current_dir().unwrap();

src/parsing/lua/behavior.rs

@@ -250,7 +250,7 @@ impl LanguageBehavior for LuaBehavior {
 mod tests {
     use super::*;
     use crate::Visibility;
-    use std::path::Path;
+    use tempfile::TempDir;
 
     #[test]
     fn test_module_separator() {
@@ -261,18 +261,19 @@ mod tests {
     #[test]
     fn test_module_path_from_file() {
         let behavior = LuaBehavior::new();
-        let project_root = Path::new("/home/user/project");
+        let temp_dir = TempDir::new().unwrap();
+        let project_root = temp_dir.path();
         let extensions = &["lua"];
 
-        let file_path = Path::new("/home/user/project/lib/utils.lua");
+        let file_path = project_root.join("lib/utils.lua");
         assert_eq!(
-            behavior.module_path_from_file(file_path, project_root, extensions),
+            behavior.module_path_from_file(&file_path, project_root, extensions),
             Some("lib.utils".to_string())
         );
 
-        let file_path = Path::new("/home/user/project/main.lua");
+        let file_path = project_root.join("main.lua");
         assert_eq!(
-            behavior.module_path_from_file(file_path, project_root, extensions),
+            behavior.module_path_from_file(&file_path, project_root, extensions),
             Some("main".to_string())
         );
     }

src/parsing/paths.rs

@@ -74,11 +74,13 @@ pub fn strip_extension<'a>(path_str: &'a str, extensions: &[&str]) -> &'a str {
 #[cfg(test)]
 mod tests {
     use super::*;
+    use tempfile::TempDir;
 
     #[test]
     fn test_normalize_relative_path() {
         let file_path = Path::new("src/foo/bar.rs");
-        let workspace_root = Path::new("/home/user/workspace");
+        let temp_dir = TempDir::new().unwrap();
+        let workspace_root = temp_dir.path();
 
         let result = normalize_for_module_path(file_path, workspace_root);
 
@@ -88,10 +90,11 @@ mod tests {
 
     #[test]
     fn test_normalize_absolute_path() {
-        let file_path = Path::new("/home/user/workspace/src/foo/bar.rs");
-        let workspace_root = Path::new("/home/user/workspace");
+        let temp_dir = TempDir::new().unwrap();
+        let workspace_root = temp_dir.path();
+        let file_path = workspace_root.join("src/foo/bar.rs");
 
-        let result = normalize_for_module_path(file_path, workspace_root);
+        let result = normalize_for_module_path(&file_path, workspace_root);
 
         assert_eq!(result, file_path);
     }