fix: treat .h as ambiguous with C++ in language-family scoping (#1928)

docs check acknowledged — fixes a real cross-language false-rejection.

Author: carlos-alm

crates/codegraph-core/src/domain/graph/resolve.rs

@@ -317,8 +317,21 @@ fn directory_distance(a: &str, b: &str) -> usize {
 /// separate families would reject huge amounts of legitimate same-project
 /// resolution. Every other `LanguageKind` variant keeps its own family,
 /// preserving `from_extension`'s existing per-language extension groupings
-/// (e.g. C's `.c`+`.h`, C++'s `.cpp`/`.cc`/`.cxx`/`.hpp`).
+/// (e.g. C's `.c`+`.h`, C++'s `.cpp`/`.cc`/`.cxx`/`.hpp`) — EXCEPT `.h`,
+/// treated as ambiguous (returns `None`) rather than inheriting
+/// `from_extension`'s C-only mapping: `from_extension` needs one canonical
+/// grammar per extension, but a `.h` header is real-world ambiguous between
+/// C and C++, and the extremely common case of a `.cpp` file calling into
+/// its own project's `.h` header would otherwise be misclassified as
+/// cross-language and rejected outright — a real regression from the
+/// pre-#1783 same-directory score of 0.7 (Greptile review). This keeps the
+/// C/C++-header case working without merging C and C++ source-file families
+/// wholesale (`.c` vs `.cpp` intentionally do NOT merge — see
+/// is_same_language_family_does_not_merge_c_and_cpp).
 fn language_family(file: &str) -> Option<LanguageKind> {
+    if file.to_ascii_lowercase().ends_with(".h") {
+        return None;
+    }
     match LanguageKind::from_extension(file) {
         Some(LanguageKind::TypeScript) | Some(LanguageKind::Tsx) => Some(LanguageKind::JavaScript),
         other => other,
@@ -635,6 +648,15 @@ mod tests {
         assert!(is_same_language_family("src/a.c", "src/a.h"));
     }
 
+    #[test]
+    fn is_same_language_family_treats_h_as_ambiguous_with_cpp() {
+        // Greptile follow-up to #1783: `.h` is real-world ambiguous between C
+        // and C++ (LANGUAGE_REGISTRY/from_extension assigns it to C alone for
+        // grammar-selection purposes), so a `.cpp` file calling into its own
+        // project's `.h` header must not be rejected as cross-language.
+        assert!(is_same_language_family("src/widget.cpp", "src/widget.h"));
+    }
+
     #[test]
     fn is_same_language_family_merges_cpp_source_and_header_variants() {
         assert!(is_same_language_family("src/a.cpp", "src/a.hpp"));

src/domain/graph/resolve.ts

@@ -533,6 +533,24 @@ function directoryDistance(a: string, b: string): number {
  */
 const JS_FAMILY_REGISTRY_IDS = new Set(['javascript', 'typescript', 'tsx']);
 
+/**
+ * Extensions excluded from the family map entirely, so `languageFamily`
+ * returns null for them and they fall through to the ambiguous-extension
+ * path (ordinary distance-based scoring, never rejected outright).
+ *
+ * `.h` is real-world ambiguous between C and C++: LANGUAGE_REGISTRY assigns
+ * it to the `c` entry alone (grammar selection needs one canonical parser),
+ * but the extremely common case of a `.cpp` file calling into its own
+ * project's `.h` header would otherwise be misclassified as cross-language
+ * and rejected outright (confidence 0) — a real regression from the
+ * pre-#1783 same-directory score of 0.7 (Greptile review). Treating `.h` as
+ * ambiguous — like an unrecognised extension — keeps the C/C++-header case
+ * working without merging C and C++ source-file families wholesale (`.c`
+ * vs `.cpp` intentionally do NOT merge — see
+ * is_same_language_family_does_not_merge_c_and_cpp).
+ */
+const AMBIGUOUS_EXTENSIONS = new Set(['.h']);
+
 /**
  * extension → language-family lookup, derived from LANGUAGE_REGISTRY (the
  * single source of truth for language definitions) so newly-added languages
@@ -542,6 +560,7 @@ const _extToLanguageFamily: Map<string, string> = new Map();
 for (const entry of LANGUAGE_REGISTRY) {
   const family = JS_FAMILY_REGISTRY_IDS.has(entry.id) ? 'javascript' : entry.id;
   for (const ext of entry.extensions) {
+    if (AMBIGUOUS_EXTENSIONS.has(ext)) continue;
     _extToLanguageFamily.set(ext, family);
   }
 }

tests/unit/resolve.test.ts

@@ -761,6 +761,14 @@ describe('isSameLanguageFamily (#1783)', () => {
     expect(isSameLanguageFamily('src/a.c', 'src/a.h')).toBe(true);
   });
 
+  it('treats .h as ambiguous with C++ (Greptile follow-up)', () => {
+    // `.h` is real-world ambiguous between C and C++ (LANGUAGE_REGISTRY
+    // assigns it to C alone for grammar-selection purposes), so a `.cpp`
+    // file calling into its own project's `.h` header must not be rejected
+    // as cross-language.
+    expect(isSameLanguageFamily('src/widget.cpp', 'src/widget.h')).toBe(true);
+  });
+
   it('treats C++ source and header extensions as the same family', () => {
     expect(isSameLanguageFamily('src/a.cpp', 'src/a.hpp')).toBe(true);
     expect(isSameLanguageFamily('src/a.cc', 'src/a.cxx')).toBe(true);