Support directory paths in --file/--from filters and fix overview CWD resolution

The --file flag on symbols/references/kind_counts and --from on definition
only accepted exact file paths. Passing a directory (e.g. --file src/) caused
"unsupported file type: .(none)". Now directories filter by prefix via a shared
resolve_file_filter helper. Also fixes overview resolving relative paths against
the project root instead of CWD, which broke directory detection in monorepos.

Co-Authored-By: Claude Opus 4.6 (1M context) <noreply@anthropic.com>

Author: ind-igo

Cargo.lock

@@ -1,6 +1,6 @@
 [package]
 name = "cx-cli"
-version = "0.6.4"
+version = "0.6.5"
 edition = "2024"
 description = "Semantic code navigation for AI agents"
 license = "MIT"

Cargo.toml

@@ -171,7 +171,7 @@ fn main() {
         Commands::Overview { path, full } => {
             let idx = index::Index::load_or_build(&root);
             let abs = if path.is_absolute() { path.clone() } else {
-                root.join(&path)
+                env::current_dir().unwrap_or_else(|_| root.clone()).join(&path)
             };
             if abs.is_dir() {
                 query::dir_overview(&idx, &path, full, cli.json, &resolve_pagination(None))

src/main.rs

@@ -125,24 +125,14 @@ pub fn symbols(
 
     let rel_path = file.map(|f| make_relative(f, &index.root));
 
-    if let Some(ref rel) = rel_path
-        && !index.entries.contains_key(rel) {
-            let abs = index.root.join(rel);
-            if abs.exists() && detect_language(&abs).is_none() {
-                let ext = abs.extension().and_then(|e| e.to_str()).unwrap_or("(none)");
-                eprintln!("cx: unsupported file type: .{}", ext);
-            } else {
-                eprintln!("cx: file not in index: {}", display_path(rel));
-            }
-            return 1;
-        }
-
     let files_to_search: Vec<(&PathBuf, &FileData)> = match rel_path {
-        Some(ref rel) => {
-            index.entries.get_key_value(rel).into_iter().collect()
-        }
+        Some(ref rel) => match resolve_file_filter(rel, index) {
+            Ok(v) => v,
+            Err(code) => return code,
+        },
         None => index.entries.iter().collect(),
     };
+    let is_single_file = file.is_some() && files_to_search.len() == 1;
 
     for (path, data) in files_to_search {
         for sym in &data.symbols {
@@ -170,7 +160,7 @@ pub fn symbols(
 
     rows.sort_by(|a, b| a.file.cmp(b.file).then(a.symbol.name.cmp(&b.symbol.name)));
 
-    let single_file = file.is_some();
+    let single_file = is_single_file;
     let out: Vec<SymbolRowOut> = rows
         .into_iter()
         .map(|r| SymbolRowOut {
@@ -216,15 +206,10 @@ pub fn kind_counts(
     let rel_path = file.map(|f| make_relative(f, &index.root));
 
     let files_to_search: Vec<(&PathBuf, &FileData)> = match rel_path {
-        Some(ref rel) => {
-            match index.entries.get_key_value(rel) {
-                Some(kv) => vec![kv],
-                None => {
-                    eprintln!("cx: file not in index: {}", display_path(rel));
-                    return 1;
-                }
-            }
-        }
+        Some(ref rel) => match resolve_file_filter(rel, index) {
+            Ok(v) => v,
+            Err(code) => return code,
+        },
         None => index.entries.iter().collect(),
     };
 
@@ -281,9 +266,12 @@ pub fn definition(
     }
 
     if let Some(ref from_path) = from_rel {
+        let is_dir = index.root.join(from_path).is_dir();
         let from_matches: Vec<_> = matches
             .iter()
-            .filter(|(path, _)| *path == from_path)
+            .filter(|(path, _)| {
+                if is_dir { path.starts_with(from_path) } else { *path == from_path }
+            })
             .cloned()
             .collect();
         if !from_matches.is_empty() {
@@ -404,21 +392,10 @@ pub fn references(
     let rel_path = file.map(|f| make_relative(f, &index.root));
 
     let files_to_search: Vec<(&PathBuf, &FileData)> = match rel_path {
-        Some(ref rel) => {
-            match index.entries.get_key_value(rel) {
-                Some(kv) => vec![kv],
-                None => {
-                    let abs = index.root.join(rel);
-                    if abs.exists() && detect_language(&abs).is_none() {
-                        let ext = abs.extension().and_then(|e| e.to_str()).unwrap_or("(none)");
-                        eprintln!("cx: unsupported file type: .{}", ext);
-                    } else {
-                        eprintln!("cx: file not in index: {}", display_path(rel));
-                    }
-                    return 1;
-                }
-            }
-        }
+        Some(ref rel) => match resolve_file_filter(rel, index) {
+            Ok(v) => v,
+            Err(code) => return code,
+        },
         None => index.entries.iter().collect(),
     };
 
@@ -768,6 +745,35 @@ fn display_path(path: &Path) -> String {
     path.to_string_lossy().replace('\\', "/")
 }
 
+fn resolve_file_filter<'a>(
+    rel: &Path,
+    index: &'a Index,
+) -> Result<Vec<(&'a PathBuf, &'a FileData)>, i32> {
+    if let Some(kv) = index.entries.get_key_value(rel) {
+        return Ok(vec![kv]);
+    }
+    let abs = index.root.join(rel);
+    if abs.is_dir() {
+        let matches: Vec<_> = index
+            .entries
+            .iter()
+            .filter(|(path, _)| path.starts_with(rel))
+            .collect();
+        if matches.is_empty() {
+            eprintln!("cx: no indexed files under {}", display_path(rel));
+            return Err(1);
+        }
+        return Ok(matches);
+    }
+    if abs.exists() && detect_language(&abs).is_none() {
+        let ext = abs.extension().and_then(|e| e.to_str()).unwrap_or("(none)");
+        eprintln!("cx: unsupported file type: .{}", ext);
+    } else {
+        eprintln!("cx: file not in index: {}", display_path(rel));
+    }
+    Err(1)
+}
+
 /// Make a path relative to the project root if it's absolute,
 /// or resolve it from cwd if relative.
 fn make_relative(path: &Path, root: &Path) -> PathBuf {

src/query.rs

@@ -543,3 +543,97 @@ fn no_pagination_when_under_limit() {
     let parsed: serde_json::Value = serde_json::from_str(&stdout).unwrap();
     assert!(parsed.is_array(), "single result should be bare array: {stdout}");
 }
+
+// --- Directory filtering ---
+
+fn dir_project() -> tempfile::TempDir {
+    temp_project(&[
+        ("src/lib.rs", "pub fn alpha() {}\npub fn beta() {}\n"),
+        ("src/util.rs", "pub fn gamma() {}\n"),
+        ("tests/test_main.rs", "fn test_alpha() {}\n"),
+    ])
+}
+
+#[test]
+fn symbols_file_directory_returns_all_files_in_dir() {
+    let dir = dir_project();
+    let out = cx_in(dir.path()).args(["symbols", "--kind", "fn", "--file", "src"]).output().unwrap();
+    let stdout = String::from_utf8_lossy(&out.stdout);
+    assert!(out.status.success(), "stderr: {}", String::from_utf8_lossy(&out.stderr));
+    assert!(stdout.contains("alpha"), "should find alpha in src/: {stdout}");
+    assert!(stdout.contains("gamma"), "should find gamma in src/: {stdout}");
+    assert!(!stdout.contains("test_alpha"), "should not include tests/: {stdout}");
+}
+
+#[test]
+fn symbols_file_directory_shows_file_column() {
+    let dir = dir_project();
+    let out = cx_in(dir.path()).args(["--json", "symbols", "--kind", "fn", "--file", "src"]).output().unwrap();
+    let stdout = String::from_utf8_lossy(&out.stdout);
+    assert!(out.status.success(), "stderr: {}", String::from_utf8_lossy(&out.stderr));
+    let parsed: serde_json::Value = serde_json::from_str(&stdout).unwrap();
+    let arr = parsed.as_array().unwrap();
+    assert!(arr.iter().all(|r| r.get("file").is_some()), "directory query should include file column: {stdout}");
+}
+
+#[test]
+fn symbols_file_single_file_hides_file_column() {
+    let dir = dir_project();
+    let out = cx_in(dir.path()).args(["--json", "symbols", "--kind", "fn", "--file", "src/lib.rs"]).output().unwrap();
+    let stdout = String::from_utf8_lossy(&out.stdout);
+    assert!(out.status.success(), "stderr: {}", String::from_utf8_lossy(&out.stderr));
+    let parsed: serde_json::Value = serde_json::from_str(&stdout).unwrap();
+    let arr = parsed.as_array().unwrap();
+    assert!(arr.iter().all(|r| r.get("file").is_none()), "single-file query should omit file column: {stdout}");
+}
+
+#[test]
+fn references_file_directory() {
+    let dir = dir_project();
+    let out = cx_in(dir.path()).args(["references", "--name", "alpha", "--file", "src"]).output().unwrap();
+    assert!(out.status.success(), "stderr: {}", String::from_utf8_lossy(&out.stderr));
+}
+
+#[test]
+fn kind_counts_file_directory() {
+    let dir = dir_project();
+    let out = cx_in(dir.path()).args(["symbols", "--kinds", "--file", "src"]).output().unwrap();
+    let stdout = String::from_utf8_lossy(&out.stdout);
+    assert!(out.status.success(), "stderr: {}", String::from_utf8_lossy(&out.stderr));
+    assert!(stdout.contains("fn"), "should list fn kind: {stdout}");
+}
+
+#[test]
+fn definition_from_directory() {
+    let dir = dir_project();
+    let out = cx_in(dir.path()).args(["definition", "--name", "alpha", "--from", "src"]).output().unwrap();
+    let stdout = String::from_utf8_lossy(&out.stdout);
+    assert!(out.status.success(), "stderr: {}", String::from_utf8_lossy(&out.stderr));
+    assert!(stdout.contains("alpha"), "should find alpha from src/: {stdout}");
+}
+
+#[test]
+fn symbols_file_nonexistent_directory() {
+    let dir = dir_project();
+    let out = cx_in(dir.path()).args(["symbols", "--file", "nonexistent"]).output().unwrap();
+    assert_eq!(out.status.code(), Some(1));
+}
+
+#[test]
+fn symbols_file_empty_directory() {
+    let dir = dir_project();
+    std::fs::create_dir(dir.path().join("empty")).unwrap();
+    let out = cx_in(dir.path()).args(["symbols", "--file", "empty"]).output().unwrap();
+    assert_eq!(out.status.code(), Some(1));
+    let stderr = String::from_utf8_lossy(&out.stderr);
+    assert!(stderr.contains("no indexed files under"), "should report empty dir: {stderr}");
+}
+
+#[test]
+fn overview_directory_from_subdirectory() {
+    let dir = dir_project();
+    let out = cx_in(&dir.path().join("src")).args(["overview", "."]).output().unwrap();
+    let stdout = String::from_utf8_lossy(&out.stdout);
+    assert!(out.status.success(), "overview from subdir should work: {}", String::from_utf8_lossy(&out.stderr));
+    assert!(stdout.contains("alpha") || stdout.contains("lib.rs"), "should find files in src/: {stdout}");
+}