fix: add C/C++ Makefile project support, prefer source over header

- Detect C/C++ projects without CMakeLists.txt or compile_commands.json
  by scanning for .c/.cpp/.cc/.cxx files in root and src/ (has_c_files)
- Ensure every detected language gets an LSP workspace slot even when
  find_package_roots() returns nothing (add_missing_language_roots);
  this unblocks find refs, read symbol, and check on Makefile projects
- Prefer source file definitions over header declarations in both the
  cache path (cached_read_symbol) and LSP path (resolve_symbol_location)
  so read symbol returns the full body, not a single-line declaration

Validated against Open-PS2-Loader (pure C, Makefile-only, 308 files,
8581 symbols): all commands work correctly with clangd.

Co-Authored-By: Claude Sonnet 4.6 <noreply@anthropic.com>

Author: Codestz

src/commands/find.rs

@@ -46,6 +46,9 @@ pub async fn find_symbol(
     Ok(parse_symbol_results(&response, name, project_root))
 }
 
+/// Header file extensions — used to prefer source definitions over declarations.
+const HEADER_EXTS: &[&str] = &["h", "hpp", "hxx", "hh"];
+
 /// Resolve a symbol name to its absolute file path and 0-indexed (line, character) position.
 ///
 /// Uses `workspace/symbol` to locate the symbol, then `find_name_position` to find
@@ -70,8 +73,18 @@ pub async fn resolve_symbol_location(
     } else {
         lsp_symbols
     };
+    // For C/C++: clangd returns both the header declaration and the source definition.
+    // Prefer the source file (the definition) over the header (the declaration).
     let symbol = symbols
-        .first()
+        .iter()
+        .find(|s| {
+            let ext = std::path::Path::new(&s.path)
+                .extension()
+                .and_then(|e| e.to_str())
+                .unwrap_or("");
+            !HEADER_EXTS.contains(&ext)
+        })
+        .or_else(|| symbols.first())
         .with_context(|| format!("symbol '{name}' not found"))?;
 
     let abs_path = project_root.join(&symbol.path);

src/daemon/server.rs

@@ -150,6 +150,23 @@ impl DaemonState {
     }
 }
 
+/// Ensure every detected language has at least one workspace root.
+///
+/// Languages found via file-extension scan (e.g. Makefile-based C projects) won't
+/// appear in `roots` from `find_package_roots()` — fall back to the project root
+/// so the LSP pool has a slot for them.
+fn add_missing_language_roots(
+    languages: &[Language],
+    roots: &mut Vec<(Language, PathBuf)>,
+    project_root: &Path,
+) {
+    for &lang in languages {
+        if !roots.iter().any(|(l, _)| *l == lang) {
+            roots.push((lang, project_root.to_path_buf()));
+        }
+    }
+}
+
 /// Run the daemon's accept loop until shutdown is requested or idle timeout fires.
 ///
 /// # Errors
@@ -169,7 +186,7 @@ pub async fn run_server(
     // Load config: krait.toml → .krait/config.toml → auto-detection
     let loaded = config::load(project_root);
     let config_source = loaded.source.clone();
-    let package_roots = if let Some(ref cfg) = loaded.config {
+    let mut package_roots = if let Some(ref cfg) = loaded.config {
         let roots = config::config_to_package_roots(cfg, project_root);
         info!(
             "config: {} ({} workspaces)",
@@ -181,6 +198,8 @@ pub async fn run_server(
         detect::find_package_roots(project_root)
     };
 
+    add_missing_language_roots(&languages, &mut package_roots, project_root);
+
     if package_roots.len() > 1 {
         if loaded.config.is_none() {
             info!("monorepo detected: {} workspace roots", package_roots.len());

src/detect/language.rs

@@ -122,6 +122,7 @@ pub fn detect_languages(root: &Path) -> Vec<Language> {
         .workspace_markers()
         .iter()
         .any(|m| root.join(m).exists())
+        || has_c_files(root)
     {
         languages.push(Language::Cpp);
     }
@@ -178,6 +179,35 @@ fn has_ts_files(root: &Path) -> bool {
     false
 }
 
+/// Returns true if the project root (or its `src/` subdirectory) contains C/C++ source files.
+/// Handles Makefile-based and legacy C/C++ projects that lack `CMakeLists.txt` or
+/// `compile_commands.json`.
+fn has_c_files(root: &Path) -> bool {
+    // C source extensions (not headers — headers alone don't indicate a buildable project)
+    const C_SRC_EXTS: &[&str] = &["c", "cpp", "cc", "cxx"];
+
+    let mut dirs = vec![root.to_path_buf()];
+    let src = root.join("src");
+    if src.is_dir() {
+        dirs.push(src);
+    }
+
+    for dir in &dirs {
+        let Ok(entries) = std::fs::read_dir(dir) else {
+            continue;
+        };
+        if entries.filter_map(Result::ok).any(|e| {
+            e.path()
+                .extension()
+                .and_then(|x| x.to_str())
+                .is_some_and(|x| C_SRC_EXTS.contains(&x))
+        }) {
+            return true;
+        }
+    }
+    false
+}
+
 #[cfg(test)]
 mod tests {
     use super::*;
@@ -269,4 +299,52 @@ mod tests {
         let langs = detect_languages(dir.path());
         assert!(langs.is_empty());
     }
+
+    #[test]
+    fn detects_cpp_from_cmake() {
+        let dir = tempfile::tempdir().unwrap();
+        std::fs::write(dir.path().join("CMakeLists.txt"), "").unwrap();
+
+        let langs = detect_languages(dir.path());
+        assert_eq!(langs, vec![Language::Cpp]);
+    }
+
+    #[test]
+    fn detects_c_project_from_root_c_files() {
+        let dir = tempfile::tempdir().unwrap();
+        std::fs::write(dir.path().join("main.c"), "int main() {}").unwrap();
+
+        let langs = detect_languages(dir.path());
+        assert_eq!(langs, vec![Language::Cpp]);
+    }
+
+    #[test]
+    fn detects_c_project_from_src_c_files() {
+        let dir = tempfile::tempdir().unwrap();
+        std::fs::create_dir(dir.path().join("src")).unwrap();
+        std::fs::write(dir.path().join("src/app.c"), "").unwrap();
+
+        let langs = detect_languages(dir.path());
+        assert_eq!(langs, vec![Language::Cpp]);
+    }
+
+    #[test]
+    fn detects_cpp_project_from_src_cpp_files() {
+        let dir = tempfile::tempdir().unwrap();
+        std::fs::create_dir(dir.path().join("src")).unwrap();
+        std::fs::write(dir.path().join("src/main.cpp"), "").unwrap();
+
+        let langs = detect_languages(dir.path());
+        assert_eq!(langs, vec![Language::Cpp]);
+    }
+
+    #[test]
+    fn headers_only_not_detected_as_c() {
+        // .h files alone shouldn't trigger C detection (could be headers for another language)
+        let dir = tempfile::tempdir().unwrap();
+        std::fs::write(dir.path().join("config.h"), "").unwrap();
+
+        let langs = detect_languages(dir.path());
+        assert!(langs.is_empty());
+    }
 }

src/index/cache_query.rs

@@ -197,7 +197,22 @@ pub fn cached_read_symbol(
             .into_iter()
             .find(|s| s.name == child && s.parent_name.as_deref() == Some(search_name))?
     } else {
-        symbols.into_iter().next()?
+        // For C/C++: the index may return the header declaration before the source
+        // definition (alphabetical path order: include/ before src/). Prefer the
+        // source file when both exist.
+        const HEADER_EXTS: &[&str] = &["h", "hpp", "hxx", "hh"];
+        let preferred = symbols
+            .iter()
+            .find(|s| {
+                let ext = std::path::Path::new(&s.path)
+                    .extension()
+                    .and_then(|e| e.to_str())
+                    .unwrap_or("");
+                !HEADER_EXTS.contains(&ext)
+            })
+            .or_else(|| symbols.first())
+            .cloned();
+        preferred?
     };
 
     // Check file freshness