feat(fsharp): route .fsi files through the dedicated signature grammar

The tree-sitter-fsharp package ships two distinct grammars: LANGUAGE_FSHARP
for .fs / .fsx source files and LANGUAGE_SIGNATURE for .fsi signature
files. Both engines previously routed all three extensions through the
source grammar, so bare `val` declarations in .fsi files surfaced as
ERROR nodes and yielded no symbols.

This change adds a separate `fsharp-signature` language for .fsi:

* native: new `FSharpSignature` LanguageKind wired to LANGUAGE_SIGNATURE
* WASM: new `fsharp-signature` registry entry using
  tree-sitter-fsharp_signature.wasm (build script now produces it)
* shared F# extractor handles `value_definition` only when its first
  child is the `val` keyword, distinguishing signature `val foo : type`
  from source `let foo = ...`
* function vs variable kind is inferred from the type shape; supports
  both `function_type` (WASM npm 0.1.0) and `curried_spec` (cargo 0.3.0)
  node shapes for engine parity

docs check acknowledged: README's F# row already covers .fs/.fsx/.fsi and
the user-facing language count is unchanged; fsharp-signature is an
internal id that mirrors how ocaml-interface backs .mli files.

Closes #1114

Author: carlos-alm

crates/codegraph-core/src/extractors/fsharp.rs

@@ -24,6 +24,7 @@ fn match_fsharp_node(node: &Node, source: &[u8], symbols: &mut FileSymbols, _dep
         "import_decl" => handle_import_decl(node, source, symbols),
         "application_expression" => handle_application(node, source, symbols),
         "dot_expression" => handle_dot_expression(node, source, symbols),
+        "value_definition" => handle_value_definition(node, source, symbols),
         _ => {}
     }
 }
@@ -300,3 +301,154 @@ fn handle_dot_expression(node: &Node, source: &[u8], symbols: &mut FileSymbols)
         });
     }
 }
+
+/// Handle `val name : type` declarations in `.fsi` signature files.
+///
+/// The signature grammar reuses the `value_definition` node kind for `val`
+/// declarations, distinguished from the source grammar's `let` bindings by
+/// the first child being the literal `val` keyword. Source-file
+/// `value_definition` nodes (which start with `let`) are intentionally
+/// ignored here to preserve `.fs` extractor parity.
+fn handle_value_definition(node: &Node, source: &[u8], symbols: &mut FileSymbols) {
+    let first = match node.child(0) {
+        Some(c) => c,
+        None => return,
+    };
+    if first.kind() != "val" {
+        return;
+    }
+
+    let decl_left = match find_child(node, "value_declaration_left") {
+        Some(n) => n,
+        None => return,
+    };
+    let name = match extract_value_name(&decl_left, source) {
+        Some(n) => n,
+        None => return,
+    };
+
+    let kind = if has_function_type(node) { "function" } else { "variable" };
+    let module_name = enclosing_module_name(node, source);
+    let qualified = match module_name {
+        Some(m) => format!("{}.{}", m, name),
+        None => name,
+    };
+
+    symbols.definitions.push(Definition {
+        name: qualified,
+        kind: kind.to_string(),
+        line: start_line(node),
+        end_line: Some(end_line(node)),
+        decorators: None,
+        complexity: None,
+        cfg: None,
+        children: None,
+    });
+}
+
+fn extract_value_name(decl_left: &Node, source: &[u8]) -> Option<String> {
+    let pattern = find_child(decl_left, "identifier_pattern")?;
+    let ident = find_child(&pattern, "long_identifier_or_op")
+        .and_then(|n| find_child(&n, "identifier"))
+        .or_else(|| find_child(&pattern, "identifier"))?;
+    Some(node_text(&ident, source).to_string())
+}
+
+fn has_function_type(node: &Node) -> bool {
+    // The two grammar versions use different node shapes for type signatures:
+    //
+    //   • WASM (tree-sitter-fsharp npm 0.1.0): `function_type` is the explicit
+    //     function-type kind, only present for `a -> b` types.
+    //   • Native (tree-sitter-fsharp 0.3.0): every type signature is wrapped
+    //     in `curried_spec`. For a function it contains `arguments_spec`
+    //     children; for a plain value (e.g. `val pi : float`) it wraps a
+    //     single `simple_type`.
+    //
+    // Treat both engines consistently by classifying as a function whenever
+    // a function_type node appears OR a curried_spec contains `arguments_spec`.
+    for i in 0..node.child_count() {
+        let Some(child) = node.child(i) else { continue };
+        match child.kind() {
+            "function_type" => return true,
+            "curried_spec" => {
+                for j in 0..child.child_count() {
+                    if let Some(g) = child.child(j) {
+                        if g.kind() == "arguments_spec" {
+                            return true;
+                        }
+                    }
+                }
+            }
+            _ => {}
+        }
+    }
+    false
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use crate::extractors::SymbolExtractor;
+    use tree_sitter::Parser;
+
+    fn parse_source(code: &str) -> FileSymbols {
+        let mut parser = Parser::new();
+        parser
+            .set_language(&tree_sitter_fsharp::LANGUAGE_FSHARP.into())
+            .unwrap();
+        let tree = parser.parse(code.as_bytes(), None).unwrap();
+        FSharpExtractor.extract(&tree, code.as_bytes(), "test.fs")
+    }
+
+    fn parse_signature(code: &str) -> FileSymbols {
+        let mut parser = Parser::new();
+        parser
+            .set_language(&tree_sitter_fsharp::LANGUAGE_SIGNATURE.into())
+            .unwrap();
+        let tree = parser.parse(code.as_bytes(), None).unwrap();
+        FSharpExtractor.extract(&tree, code.as_bytes(), "test.fsi")
+    }
+
+    #[test]
+    fn signature_extracts_val_declarations() {
+        let s = parse_signature("namespace MyApp.Domain\n\nval add : int -> int -> int\nval pi : float\n");
+        let add = s
+            .definitions
+            .iter()
+            .find(|d| d.name == "add")
+            .expect("val add should be extracted");
+        assert_eq!(add.kind, "function");
+        let pi = s
+            .definitions
+            .iter()
+            .find(|d| d.name == "pi")
+            .expect("val pi should be extracted");
+        assert_eq!(pi.kind, "variable");
+    }
+
+    #[test]
+    fn signature_extracts_bare_val_declarations() {
+        let s = parse_signature("val negate : int -> int\nval count : int\n");
+        assert!(s
+            .definitions
+            .iter()
+            .any(|d| d.name == "negate" && d.kind == "function"));
+        assert!(s
+            .definitions
+            .iter()
+            .any(|d| d.name == "count" && d.kind == "variable"));
+    }
+
+    #[test]
+    fn source_grammar_does_not_extract_let_bindings_as_val() {
+        // `let x = 5` is a value_definition in the source grammar but its
+        // first child is `let`, not `val`. Our handler must not extract it
+        // (preserves prior `.fs` extraction parity — only function_declaration_left
+        // produces definitions in source files).
+        let s = parse_source("module M\n\nlet x = 5\n");
+        assert!(
+            s.definitions.iter().all(|d| d.name != "x"),
+            "let bindings in .fs files must not be extracted as val definitions"
+        );
+    }
+}

crates/codegraph-core/src/extractors/mod.rs

@@ -140,7 +140,7 @@ pub fn extract_symbols_with_opts(
         LanguageKind::Ocaml | LanguageKind::OcamlInterface => {
             ocaml::OcamlExtractor.extract_with_opts(tree, source, file_path, include_ast_nodes)
         }
-        LanguageKind::FSharp => {
+        LanguageKind::FSharp | LanguageKind::FSharpSignature => {
             fsharp::FSharpExtractor.extract_with_opts(tree, source, file_path, include_ast_nodes)
         }
         LanguageKind::ObjC => {

crates/codegraph-core/src/parser_registry.rs

@@ -28,6 +28,7 @@ pub enum LanguageKind {
     Ocaml,
     OcamlInterface,
     FSharp,
+    FSharpSignature,
     ObjC,
     Gleam,
     Julia,
@@ -70,6 +71,7 @@ impl LanguageKind {
             Self::Ocaml => "ocaml",
             Self::OcamlInterface => "ocaml-interface",
             Self::FSharp => "fsharp",
+            Self::FSharpSignature => "fsharp-signature",
             Self::ObjC => "objc",
             Self::Gleam => "gleam",
             Self::Julia => "julia",
@@ -120,7 +122,8 @@ impl LanguageKind {
             "hs" => Some(Self::Haskell),
             "ml" => Some(Self::Ocaml),
             "mli" => Some(Self::OcamlInterface),
-            "fs" | "fsx" | "fsi" => Some(Self::FSharp),
+            "fs" | "fsx" => Some(Self::FSharp),
+            "fsi" => Some(Self::FSharpSignature),
             "m" => Some(Self::ObjC),
             "gleam" => Some(Self::Gleam),
             "jl" => Some(Self::Julia),
@@ -165,6 +168,7 @@ impl LanguageKind {
             "ocaml" => Some(Self::Ocaml),
             "ocaml-interface" => Some(Self::OcamlInterface),
             "fsharp" => Some(Self::FSharp),
+            "fsharp-signature" => Some(Self::FSharpSignature),
             "objc" => Some(Self::ObjC),
             "gleam" => Some(Self::Gleam),
             "julia" => Some(Self::Julia),
@@ -207,6 +211,7 @@ impl LanguageKind {
             Self::Ocaml => tree_sitter_ocaml::LANGUAGE_OCAML.into(),
             Self::OcamlInterface => tree_sitter_ocaml::LANGUAGE_OCAML_INTERFACE.into(),
             Self::FSharp => tree_sitter_fsharp::LANGUAGE_FSHARP.into(),
+            Self::FSharpSignature => tree_sitter_fsharp::LANGUAGE_SIGNATURE.into(),
             Self::ObjC => tree_sitter_objc::LANGUAGE.into(),
             Self::Gleam => tree_sitter_gleam::LANGUAGE.into(),
             Self::Julia => tree_sitter_julia::LANGUAGE.into(),
@@ -232,8 +237,8 @@ impl LanguageKind {
         &[
             JavaScript, TypeScript, Tsx, Python, Go, Rust, Java, CSharp, Ruby, Php, Hcl, C,
             Cpp, Kotlin, Swift, Scala, Bash, Elixir, Lua, Dart, Zig, Haskell, Ocaml,
-            OcamlInterface, FSharp, ObjC, Gleam, Julia, Cuda, Clojure, Erlang, Groovy, R, Solidity,
-            Verilog,
+            OcamlInterface, FSharp, FSharpSignature, ObjC, Gleam, Julia, Cuda, Clojure, Erlang,
+            Groovy, R, Solidity, Verilog,
         ]
     }
 }
@@ -304,6 +309,7 @@ mod tests {
             | LanguageKind::Ocaml
             | LanguageKind::OcamlInterface
             | LanguageKind::FSharp
+            | LanguageKind::FSharpSignature
             | LanguageKind::ObjC
             | LanguageKind::Gleam
             | LanguageKind::Julia
@@ -320,7 +326,7 @@ mod tests {
         // Because both checks require the same manual update, they reinforce
         // each other: a developer who updates the match is reminded to also
         // update `all()` and this count.
-        const EXPECTED_LEN: usize = 35;
+        const EXPECTED_LEN: usize = 36;
         assert_eq!(
             LanguageKind::all().len(),
             EXPECTED_LEN,

scripts/build-wasm.ts

@@ -206,6 +206,7 @@ const grammars = [
   { name: 'tree-sitter-ocaml', pkg: 'tree-sitter-ocaml', sub: 'grammars/ocaml' },
   { name: 'tree-sitter-ocaml_interface', pkg: 'tree-sitter-ocaml', sub: 'grammars/interface' },
   { name: 'tree-sitter-fsharp', pkg: 'tree-sitter-fsharp', sub: 'fsharp' },
+  { name: 'tree-sitter-fsharp_signature', pkg: 'tree-sitter-fsharp', sub: 'fsharp_signature' },
   { name: 'tree-sitter-gleam', pkg: 'tree-sitter-gleam', sub: null },
   { name: 'tree-sitter-clojure', pkg: 'tree-sitter-clojure', sub: null },
   { name: 'tree-sitter-julia', pkg: 'tree-sitter-julia', sub: null },

src/ast-analysis/rules/index.ts

@@ -233,6 +233,7 @@ export const AST_TYPE_MAPS: Map<string, Record<string, string>> = new Map([
   ['ocaml', OCAML_AST_TYPES],
   ['ocaml-interface', OCAML_AST_TYPES],
   ['fsharp', FSHARP_AST_TYPES],
+  ['fsharp-signature', FSHARP_AST_TYPES],
   ['objc', OBJC_AST_TYPES],
   ['gleam', GLEAM_AST_TYPES],
   ['julia', JULIA_AST_TYPES],
@@ -313,6 +314,7 @@ export const AST_STRING_CONFIGS: Map<string, AstStringConfig> = new Map([
   ['ocaml', OCAML_STRING_CONFIG],
   ['ocaml-interface', OCAML_STRING_CONFIG],
   ['fsharp', FSHARP_STRING_CONFIG],
+  ['fsharp-signature', FSHARP_STRING_CONFIG],
   ['objc', OBJC_STRING_CONFIG],
   ['gleam', GLEAM_STRING_CONFIG],
   ['julia', JULIA_STRING_CONFIG],

src/domain/parser.ts

@@ -831,11 +831,18 @@ export const LANGUAGE_REGISTRY: LanguageRegistryEntry[] = [
   },
   {
     id: 'fsharp',
-    extensions: ['.fs', '.fsx', '.fsi'],
+    extensions: ['.fs', '.fsx'],
     grammarFile: 'tree-sitter-fsharp.wasm',
     extractor: extractFSharpSymbols,
     required: false,
   },
+  {
+    id: 'fsharp-signature',
+    extensions: ['.fsi'],
+    grammarFile: 'tree-sitter-fsharp_signature.wasm',
+    extractor: extractFSharpSymbols,
+    required: false,
+  },
   {
     id: 'gleam',
     extensions: ['.gleam'],

src/domain/wasm-worker-entry.ts

@@ -306,11 +306,18 @@ const LANGUAGE_REGISTRY: LanguageRegistryEntry[] = [
   },
   {
     id: 'fsharp',
-    extensions: ['.fs', '.fsx', '.fsi'],
+    extensions: ['.fs', '.fsx'],
     grammarFile: 'tree-sitter-fsharp.wasm',
     extractor: extractFSharpSymbols,
     required: false,
   },
+  {
+    id: 'fsharp-signature',
+    extensions: ['.fsi'],
+    grammarFile: 'tree-sitter-fsharp_signature.wasm',
+    extractor: extractFSharpSymbols,
+    required: false,
+  },
   {
     id: 'gleam',
     extensions: ['.gleam'],

src/extractors/fsharp.ts

@@ -57,6 +57,9 @@ function walkFSharpNode(
     case 'dot_expression':
       handleDotExpression(node, ctx);
       break;
+    case 'value_definition':
+      handleValueDefinition(node, ctx, currentModule);
+      break;
   }
 
   for (let i = 0; i < node.childCount; i++) {
@@ -251,3 +254,65 @@ function handleDotExpression(node: TreeSitterNode, ctx: ExtractorOutput): void {
     ctx.calls.push(call);
   }
 }
+
+// Handle `val name : type` declarations in `.fsi` signature files.
+// The signature grammar reuses `value_definition` for `val` bindings,
+// distinguished from the source grammar's `let` bindings by the first
+// child being the literal `val` keyword. Source-file `value_definition`
+// nodes (which start with `let`) are intentionally ignored to preserve
+// `.fs` extractor parity.
+function handleValueDefinition(
+  node: TreeSitterNode,
+  ctx: ExtractorOutput,
+  currentModule: string | null,
+): void {
+  const first = node.child(0);
+  if (!first || first.type !== 'val') return;
+
+  const declLeft = findChild(node, 'value_declaration_left');
+  if (!declLeft) return;
+
+  const pattern = findChild(declLeft, 'identifier_pattern');
+  if (!pattern) return;
+
+  const ident =
+    findChild(findChild(pattern, 'long_identifier_or_op') ?? pattern, 'identifier') ??
+    findChild(pattern, 'identifier');
+  if (!ident) return;
+
+  // The two grammar versions use different shapes for type signatures:
+  //   • WASM (npm tree-sitter-fsharp 0.1.0): `function_type` is the explicit
+  //     function-type kind, only present for `a -> b` types.
+  //   • Native (cargo tree-sitter-fsharp 0.3.0): every type signature is
+  //     wrapped in `curried_spec`. For a function it contains `arguments_spec`
+  //     children; for a plain value (e.g. `val pi : float`) it wraps a single
+  //     `simple_type`.
+  // Treat both engines consistently by classifying as a function whenever
+  // function_type appears OR a curried_spec contains an arguments_spec child.
+  let hasFunctionType = false;
+  for (let i = 0; i < node.childCount; i++) {
+    const c = node.child(i);
+    if (!c) continue;
+    if (c.type === 'function_type') {
+      hasFunctionType = true;
+      break;
+    }
+    if (c.type === 'curried_spec') {
+      for (let j = 0; j < c.childCount; j++) {
+        if (c.child(j)?.type === 'arguments_spec') {
+          hasFunctionType = true;
+          break;
+        }
+      }
+      if (hasFunctionType) break;
+    }
+  }
+
+  const name = currentModule ? `${currentModule}.${ident.text}` : ident.text;
+  ctx.definitions.push({
+    name,
+    kind: hasFunctionType ? 'function' : 'variable',
+    line: node.startPosition.row + 1,
+    endLine: nodeEndLine(node),
+  });
+}

src/types.ts

@@ -99,6 +99,7 @@ export type LanguageId =
   | 'ocaml'
   | 'ocaml-interface'
   | 'fsharp'
+  | 'fsharp-signature'
   | 'gleam'
   | 'clojure'
   | 'julia'