fix(extract): resolve .h headers as C++ in C++ projects

- Auto-detect C vs C++ from project layout and header content
- Add .codegraph/config.toml with headers = auto|c|cpp override
- Document behavior in README; fixes #7

Author: Cleboost

Cargo.lock

@@ -200,13 +200,31 @@ A `.codegraph/` directory is created next to your project:
 ```
 .codegraph/
   db.sqlite        SQLite v1 (WAL mode, FTS5)
+  config.toml      Language overrides (see below)
   .gitignore       Pre-filled so the index is never committed
   version          Codegraph version that created the directory
 ```
 
 Add a `.codegraphignore` file at the workspace root to exclude additional
 paths beyond your `.gitignore`. Same syntax.
 
+### C vs C++ headers (`.h`)
+
+By default, `.h` files are resolved automatically:
+
+- **C++ project** (`.cpp`/`.hpp` present, no `.c`) → parsed as C++
+- **C project** (`.c` present, no C++ sources) → parsed as C
+- **Mixed C/C++** → each `.h` is inspected for C++ syntax (`namespace`, `class`, `template`, …)
+
+Override in `.codegraph/config.toml`:
+
+```toml
+[languages]
+headers = "auto"   # "auto" (default), "c", or "cpp"
+```
+
+After changing this setting, run `codegraph index` to re-index headers.
+
 ## Why Rust?
 
 This project is a from-scratch Rust rewrite of the previous TypeScript

README.md

@@ -33,6 +33,8 @@ ignore = { workspace = true }
 rayon = { workspace = true }
 camino = { workspace = true }
 tracing = { workspace = true }
+serde = { workspace = true }
+toml = "0.8"
 
 [dev-dependencies]
 tempfile = "3"

crates/codegraph-extract/Cargo.toml

@@ -0,0 +1,157 @@
+use camino::Utf8Path;
+use serde::Deserialize;
+use std::fs;
+
+/// How `.h` header files should be parsed when both C and C++ extractors are available.
+#[derive(Debug, Clone, Copy, PartialEq, Eq, Default)]
+pub enum HeaderLanguage {
+    /// Detect from project layout and file content.
+    #[default]
+    Auto,
+    C,
+    Cpp,
+}
+
+#[derive(Debug, Default, Deserialize)]
+struct ConfigFile {
+    #[serde(default)]
+    languages: LanguagesSection,
+}
+
+#[derive(Debug, Default, Deserialize)]
+struct LanguagesSection {
+    /// `"auto"`, `"c"`, or `"cpp"`.
+    #[serde(default)]
+    headers: Option<String>,
+}
+
+/// Project-level extraction settings (`.codegraph/config.toml`).
+#[derive(Debug, Clone, Default)]
+pub struct ExtractConfig {
+    pub header_language: HeaderLanguage,
+}
+
+impl ExtractConfig {
+    pub fn load(root: &Utf8Path) -> Self {
+        let path = root.join(".codegraph").join("config.toml");
+        Self::load_from(&path)
+    }
+
+    pub fn load_from(path: &Utf8Path) -> Self {
+        let Ok(text) = fs::read_to_string(path.as_std_path()) else {
+            return Self::default();
+        };
+        let Ok(file) = toml::from_str::<ConfigFile>(&text) else {
+            return Self::default();
+        };
+        Self {
+            header_language: parse_header_language(file.languages.headers.as_deref()),
+        }
+    }
+}
+
+fn parse_header_language(raw: Option<&str>) -> HeaderLanguage {
+    match raw.unwrap_or("auto").trim().to_ascii_lowercase().as_str() {
+        "c" => HeaderLanguage::C,
+        "cpp" | "c++" | "cxx" => HeaderLanguage::Cpp,
+        _ => HeaderLanguage::Auto,
+    }
+}
+
+/// Default `config.toml` written on `codegraph init`.
+pub const DEFAULT_CONFIG_TOML: &str = r#"# CodeGraph project configuration
+# See https://github.com/Cleboost/codegraph-rs
+
+[languages]
+# How to parse .h header files: "auto", "c", or "cpp".
+# "auto" detects C++ projects from .cpp/.hpp files and C++ syntax in headers.
+headers = "auto"
+"#;
+
+/// Quick project scan: returns a hint when the tree is clearly C-only or C++-only.
+pub fn detect_project_header_hint(root: &Utf8Path) -> Option<HeaderLanguage> {
+    let mut c_files = 0u32;
+    let mut cpp_files = 0u32;
+
+    let walker = ignore::WalkBuilder::new(root)
+        .hidden(true)
+        .git_ignore(true)
+        .git_exclude(true)
+        .parents(true)
+        .add_custom_ignore_filename(".codegraphignore")
+        .build();
+
+    for entry in walker.flatten() {
+        if !entry.file_type().map(|t| t.is_file()).unwrap_or(false) {
+            continue;
+        }
+        let Some(ext) = entry.path().extension().and_then(|s| s.to_str()) else {
+            continue;
+        };
+        match ext {
+            "c" => c_files += 1,
+            "cpp" | "cc" | "cxx" | "hpp" | "hh" | "hxx" => cpp_files += 1,
+            _ => {}
+        }
+    }
+
+    if cpp_files > 0 && c_files == 0 {
+        Some(HeaderLanguage::Cpp)
+    } else if c_files > 0 && cpp_files == 0 {
+        Some(HeaderLanguage::C)
+    } else {
+        None
+    }
+}
+
+/// Heuristic: does this header look like C++ from its source text?
+pub fn is_cpp_header(source: &str) -> bool {
+    let sample = &source[..source.len().min(8192)];
+    const MARKERS: &[&str] = &[
+        "namespace ",
+        "class ",
+        "template ",
+        "typename ",
+        "constexpr ",
+        "noexcept",
+        "public:",
+        "private:",
+        "protected:",
+        "operator ",
+        "std::",
+        "extern \"C\"",
+        "using ",
+        "::",
+    ];
+    MARKERS.iter().any(|m| sample.contains(m))
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn parse_config_headers() {
+        let cfg = toml::from_str::<ConfigFile>(
+            r#"
+[languages]
+headers = "cpp"
+"#,
+        )
+        .unwrap();
+        assert_eq!(
+            parse_header_language(cfg.languages.headers.as_deref()),
+            HeaderLanguage::Cpp
+        );
+    }
+
+    #[test]
+    fn sniff_cpp_header() {
+        assert!(is_cpp_header(
+            "#pragma once\nnamespace tnl { class String {}; }\n"
+        ));
+        assert!(!is_cpp_header(
+            "#ifndef FOO_H\n#define FOO_H\nstruct foo { int x; };\n#endif\n"
+        ));
+    }
+}

crates/codegraph-extract/src/config.rs

@@ -22,7 +22,7 @@ fn import_path(n: &Node, src: &[u8]) -> Option<String> {
 
 pub static SPEC: LangSpec = LangSpec {
     language_name: "c",
-    extensions: &["c", "h"],
+    extensions: &["c"],
     ts_language,
     decls: &[
         ("function_definition", NodeKind::Function),

crates/codegraph-extract/src/languages/c.rs

@@ -1,9 +1,11 @@
 //! Tree-sitter extraction orchestrator + per-language extractors.
 
+pub mod config;
 pub mod languages;
 mod orchestrator;
 mod walker;
 
+pub use config::{ExtractConfig, HeaderLanguage, DEFAULT_CONFIG_TOML};
 pub use orchestrator::{ExtractStats, Orchestrator};
 
 use codegraph_core::{Error, NodeKind, Result};

crates/codegraph-extract/src/lib.rs

@@ -1,3 +1,4 @@
+use crate::config::ExtractConfig;
 use crate::{walker, ExtractResult, Extractor};
 use camino::{Utf8Path, Utf8PathBuf};
 use codegraph_core::Result;
@@ -36,7 +37,8 @@ impl Orchestrator {
     }
 
     pub fn sync(&self, root: &Utf8Path, db: &Db) -> Result<ExtractStats> {
-        let files = walker::walk(root, &self.extractors);
+        let config = ExtractConfig::load(root);
+        let files = walker::walk(root, &self.extractors, &config);
         let results: Vec<_> = files.par_iter().map(|fm| parse_one(fm, db)).collect();
         let mut parsed = Vec::with_capacity(results.len());
         let mut skipped = 0u64;
@@ -55,8 +57,10 @@ impl Orchestrator {
     /// Sync only the given paths instead of walking the whole tree. Used by the
     /// watcher so that a burst of filesystem events costs O(changed files),
     /// not O(repo size).
-    pub fn sync_paths(&self, db: &Db, paths: &[Utf8PathBuf]) -> Result<ExtractStats> {
+    pub fn sync_paths(&self, root: &Utf8Path, db: &Db, paths: &[Utf8PathBuf]) -> Result<ExtractStats> {
+        let config = ExtractConfig::load(root);
         let ext_map = walker::build_ext_map(&self.extractors);
+        let opts = walker::walk_options(&self.extractors, &config, root);
         let mut matches = Vec::new();
         for p in paths {
             if !p.as_std_path().is_file() {
@@ -68,7 +72,7 @@ impl Orchestrator {
                 }
                 continue;
             }
-            if let Some(extractor) = walker::match_extractor(p, &ext_map) {
+            if let Some(extractor) = walker::match_extractor(p, &ext_map, &opts) {
                 matches.push(walker::FileMatch {
                     path: p.clone(),
                     extractor,