feat: Add C# language support for namespaces, classes, and interfaces, improve inheritance parsing, and update the default LLM.

Author: Pavel Sergeev

codebase_rag/constants.py

@@ -120,7 +120,7 @@ class FileAction(StrEnum):
 PKG_CONANFILE = "conanfile.txt"
 
 DEFAULT_REGION = "us-central1"
-DEFAULT_MODEL = "llama3.2"
+DEFAULT_MODEL = "qwen2.5-coder:7b"
 DEFAULT_API_KEY = "ollama"
 
 ENV_OPENAI_API_KEY = "OPENAI_API_KEY"
@@ -198,13 +198,18 @@ class GoogleProviderType(StrEnum):
 ONEOF_PACKAGE = "package"
 ONEOF_FOLDER = "folder"
 ONEOF_MODULE = "module"
+ONEOF_NAMESPACE = "namespace"  # C# namespace
 ONEOF_CLASS = "class_node"
 ONEOF_FUNCTION = "function"
 ONEOF_METHOD = "method"
 ONEOF_FILE = "file"
 ONEOF_EXTERNAL_PACKAGE = "external_package"
 ONEOF_MODULE_IMPLEMENTATION = "module_implementation"
 ONEOF_MODULE_INTERFACE = "module_interface"
+ONEOF_INTERFACE = "interface_node"  # Interface (C#, Java, TypeScript)
+ONEOF_ENUM = "enum_node"  # Enum type
+ONEOF_TYPE_ALIAS = "type_alias"  # Type alias
+ONEOF_UNION = "union_node"  # Union type (C/C++)
 
 # (H) CLI error and info messages
 CLI_ERR_OUTPUT_REQUIRES_UPDATE = (
@@ -320,6 +325,7 @@ class NodeLabel(StrEnum):
     FOLDER = "Folder"
     FILE = "File"
     MODULE = "Module"
+    NAMESPACE = "Namespace"  # C# namespace
     CLASS = "Class"
     FUNCTION = "Function"
     METHOD = "Method"
@@ -338,6 +344,7 @@ class NodeLabel(StrEnum):
     NodeLabel.FOLDER: UniqueKeyType.PATH,
     NodeLabel.FILE: UniqueKeyType.PATH,
     NodeLabel.MODULE: UniqueKeyType.QUALIFIED_NAME,
+    NodeLabel.NAMESPACE: UniqueKeyType.QUALIFIED_NAME,  # C# namespace
     NodeLabel.CLASS: UniqueKeyType.QUALIFIED_NAME,
     NodeLabel.FUNCTION: UniqueKeyType.QUALIFIED_NAME,
     NodeLabel.METHOD: UniqueKeyType.QUALIFIED_NAME,
@@ -363,6 +370,7 @@ class RelationshipType(StrEnum):
     CONTAINS_FOLDER = "CONTAINS_FOLDER"
     CONTAINS_FILE = "CONTAINS_FILE"
     CONTAINS_MODULE = "CONTAINS_MODULE"
+    CONTAINS_NAMESPACE = "CONTAINS_NAMESPACE"  # Module declares namespace
     DEFINES = "DEFINES"
     DEFINES_METHOD = "DEFINES_METHOD"
     IMPORTS = "IMPORTS"
@@ -1735,6 +1743,16 @@ class CppNodeType(StrEnum):
 TS_JAVA_ANNOTATION_TYPE_DECLARATION = "annotation_type_declaration"
 
 TS_BASE_CLASS_CLAUSE = "base_class_clause"
+TS_CS_BASE_LIST = "base_list"  # C# base class/interface list
+TS_CS_USING_DIRECTIVE = "using_directive"  # C# using statement
+TS_CS_EQUALS = "="  # C# equals sign for using alias
+TS_QUALIFIED_NAME = "qualified_name"  # Dotted name like System.Collections.Generic
+TS_CS_PROPERTY_DECLARATION = "property_declaration"  # C# property (get/set accessor)
+TS_CS_INDEXER_DECLARATION = "indexer_declaration"  # C# indexer (this[])
+TS_CS_EVENT_FIELD_DECLARATION = "event_field_declaration"  # C# event field
+TS_CS_OPERATOR_DECLARATION = "operator_declaration"  # C# operator overload
+TS_CS_NAMESPACE_DECLARATION = "namespace_declaration"  # C# namespace
+TS_CS_FILE_SCOPED_NAMESPACE = "file_scoped_namespace_declaration"  # C# 10+ file-scoped namespace
 TS_TEMPLATE_TYPE = "template_type"
 TS_ACCESS_SPECIFIER = "access_specifier"
 TS_VIRTUAL = "virtual"
@@ -2723,6 +2741,10 @@ class MCPParamName(StrEnum):
     TS_CS_ANONYMOUS_METHOD_EXPRESSION,
     TS_CS_LAMBDA_EXPRESSION,
     TS_METHOD_DECLARATION,
+    TS_CS_PROPERTY_DECLARATION,  # C# properties (get/set)
+    TS_CS_INDEXER_DECLARATION,  # C# indexers (this[])
+    TS_CS_EVENT_FIELD_DECLARATION,  # C# events
+    TS_CS_OPERATOR_DECLARATION,  # C# operator overloads
 )
 SPEC_CS_CLASS_TYPES = (
     TS_CLASS_DECLARATION,

codebase_rag/cypher_queries.py

@@ -59,6 +59,14 @@
 WHERE caller.name = 'main'
 RETURN caller.name AS caller, callee.name AS callee, callee.qualified_name AS qualified_name"""
 
+CYPHER_EXAMPLE_CLASS_BY_NAME_SUFFIX = """MATCH (c:Class)
+WHERE c.name ENDS WITH 'Controller'
+RETURN c.qualified_name AS qualified_name, c.name AS name, labels(c) AS type"""
+
+CYPHER_EXAMPLE_CLASS_BY_NAME_CONTAINS = """MATCH (c:Class)
+WHERE toLower(c.name) CONTAINS 'service'
+RETURN c.qualified_name AS qualified_name, c.name AS name, labels(c) AS type"""
+
 CYPHER_EXPORT_NODES = """
 MATCH (n)
 RETURN id(n) as node_id, labels(n) as labels, properties(n) as properties

codebase_rag/graph_updater.py

@@ -273,6 +273,11 @@ def run(self) -> None:
         logger.info(ls.PASS_2_FILES)
         self._process_files()
 
+        # Create deferred IMPLEMENTS relationships after all interfaces are known
+        self.factory.definition_processor.process_deferred_implements()
+        # Create deferred INHERITS relationships for C# after all classes are known
+        self.factory.definition_processor.process_deferred_inherits()
+
         logger.info(ls.FOUND_FUNCTIONS.format(count=len(self.function_registry)))
         logger.info(ls.PASS_3_CALLS)
         self._process_function_calls()

codebase_rag/logs.py

@@ -35,6 +35,7 @@
 DEF_PARSE_FAILED = "Failed to parse or ingest {path}: {error}"
 DEF_PARSING_DEPENDENCY = "  Parsing dependency file: {path}"
 DEF_FOUND_DEPENDENCY = "    Found dependency: {name} (spec: {spec})"
+DEF_FOUND_NAMESPACE = "  Found namespace: {name} (qn: {qn})"
 
 # (H) Semantic/embedding logs
 SEMANTIC_NOT_AVAILABLE = (
@@ -408,6 +409,9 @@
 IMP_CPP_MODULE_IMPL = "C++20 module implementation: {name}"
 IMP_CPP_MODULE_IFACE = "C++20 module interface: {name}"
 IMP_CPP_PARTITION = "C++20 module partition import: {partition} -> {full}"
+IMP_CS_USING = "C# using: {name} -> {namespace}"
+IMP_CS_ALIAS = "C# using alias: {alias} -> {namespace}"
+IMP_CS_STATIC = "C# using static: {name} -> {namespace}"
 IMP_GENERIC = "Generic import parsing for {language}: {node_type}"
 
 # (H) Structure processor logs
@@ -418,6 +422,9 @@
 CLASS_CPP_MODULE_INTERFACE = "  Found C++ Module Interface: {qn}"
 CLASS_CPP_MODULE_IMPL = "  Found C++ Module Implementation: {qn}"
 CLASS_FOUND_INTERFACE = "  Found Interface: {name} (qn: {qn})"
+CLASS_FOUND_BASE_CLASS = "  Found C# Base Class: {name} (qn: {qn})"
+CLASS_DEFERRED_IMPLEMENTS = "  Creating deferred IMPLEMENTS: {class_qn} -> {interface_qn}"
+CLASS_DEFERRED_INHERITS = "  Creating deferred INHERITS: {class_qn} -> {base_class_qn}"
 CLASS_FOUND_ENUM = "  Found Enum: {name} (qn: {qn})"
 CLASS_FOUND_TYPE = "  Found Type: {name} (qn: {qn})"
 CLASS_FOUND_STRUCT = "  Found Struct: {name} (qn: {qn})"

codebase_rag/parsers/class_ingest/mixin.py

@@ -40,6 +40,10 @@ class ClassIngestMixin:
     module_qn_to_file_path: dict[str, Path]
     import_processor: ImportProcessor
     class_inheritance: dict[str, list[str]]
+    # Deferred IMPLEMENTS relationships: list of (class_type, class_qn, interface_name, module_qn)
+    pending_implements: list[tuple[str, str, str, str]]
+    # Deferred INHERITS relationships: list of (class_type, class_qn, base_class_name, module_qn)
+    pending_inherits: list[tuple[str, str, str, str]]
 
     @abstractmethod
     def _get_docstring(self, node: ASTNode) -> str | None: ...
@@ -160,6 +164,25 @@ def _process_class_node(
             self._resolve_to_qn,
             self.function_registry,
         )
+
+        # Collect IMPLEMENTS relationships for deferred processing
+        # This ensures interfaces are in function_registry before resolution
+        if class_node.type == cs.TS_CLASS_DECLARATION:
+            from . import parent_extraction as pe
+
+            for interface_name in pe.extract_interface_names_raw(class_node):
+                self.pending_implements.append(
+                    (node_type, class_qn, interface_name, module_qn)
+                )
+
+            # Collect INHERITS relationships for deferred processing (C# only)
+            # This ensures parent classes are in function_registry before resolution
+            if language == cs.SupportedLanguage.CSHARP:
+                for base_class_name in pe.extract_base_class_names_raw(class_node):
+                    self.pending_inherits.append(
+                        (node_type, class_qn, base_class_name, module_qn)
+                    )
+
         self._ingest_class_methods(class_node, class_qn, language, lang_queries)
 
     def _ingest_rust_impl_methods(
@@ -274,6 +297,40 @@ def process_all_method_overrides(self) -> None:
             self.ingestor,
         )
 
+    def process_deferred_implements(self) -> None:
+        """Create IMPLEMENTS relationships after all files are processed.
+
+        This ensures that interfaces are already in function_registry
+        so we can resolve their qualified names correctly.
+        """
+        for class_type, class_qn, interface_name, module_qn in self.pending_implements:
+            interface_qn = self._resolve_to_qn(interface_name, module_qn)
+            logger.debug(
+                logs.CLASS_DEFERRED_IMPLEMENTS.format(
+                    class_qn=class_qn, interface_qn=interface_qn
+                )
+            )
+            rel.create_implements_relationship(
+                class_type, class_qn, interface_qn, self.ingestor
+            )
+
+    def process_deferred_inherits(self) -> None:
+        """Create INHERITS relationships for C# after all files are processed.
+
+        This ensures that parent classes are already in function_registry
+        so we can resolve their qualified names correctly.
+        """
+        for class_type, class_qn, base_class_name, module_qn in self.pending_inherits:
+            base_class_qn = self._resolve_to_qn(base_class_name, module_qn)
+            logger.debug(
+                logs.CLASS_DEFERRED_INHERITS.format(
+                    class_qn=class_qn, base_class_qn=base_class_qn
+                )
+            )
+            rel.create_inheritance_relationship(
+                class_type, class_qn, base_class_qn, self.function_registry, self.ingestor
+            )
+
     def _resolve_class_name(self, class_name: str, module_qn: str) -> str | None:
         return resolve_class_name(
             class_name, module_qn, self.import_processor, self.function_registry

codebase_rag/parsers/class_ingest/parent_extraction.py

@@ -52,6 +52,12 @@ def extract_parent_classes(
             )
         )
 
+    # C#: extract base class from base_list (not interfaces)
+    if class_node.type == cs.TS_CLASS_DECLARATION:
+        parent_classes.extend(
+            extract_csharp_base_class(class_node, module_qn, resolve_to_qn)
+        )
+
     return parent_classes
 
 
@@ -297,19 +303,86 @@ def resolve_js_ts_parent_class(
     return resolve_to_qn(parent_name, module_qn)
 
 
+def extract_interface_names_raw(class_node: Node) -> list[str]:
+    """Extract raw interface names without qualified name resolution.
+
+    Used for deferred IMPLEMENTS relationship creation where resolution
+    happens after all files are processed.
+    """
+    interface_names: list[str] = []
+
+    # Java: uses 'interfaces' field
+    interfaces_node = class_node.child_by_field_name(cs.FIELD_INTERFACES)
+    if interfaces_node:
+        for child in interfaces_node.children:
+            if child.type == cs.TS_TYPE_LIST:
+                for type_child in child.children:
+                    if type_child.type == cs.TS_TYPE_IDENTIFIER and type_child.text:
+                        if name := safe_decode_text(type_child):
+                            interface_names.append(name)
+
+    # C#: uses 'base_list' child node (contains both base class and interfaces)
+    for child in class_node.children:
+        if child.type == cs.TS_CS_BASE_LIST:
+            for subchild in child.children:
+                if subchild.type == cs.TS_IDENTIFIER and subchild.text:
+                    if name := safe_decode_text(subchild):
+                        # C# convention: interfaces start with 'I' followed by uppercase
+                        if len(name) > 1 and name.startswith("I") and name[1].isupper():
+                            interface_names.append(name)
+            break
+
+    return interface_names
+
+
+def extract_base_class_names_raw(class_node: Node) -> list[str]:
+    """Extract raw base class names without qualified name resolution.
+
+    Used for deferred INHERITS relationship creation where resolution
+    happens after all files are processed.
+
+    For C#, extracts non-interface identifiers from base_list.
+    """
+    base_class_names: list[str] = []
+
+    # C#: uses 'base_list' child node (contains both base class and interfaces)
+    for child in class_node.children:
+        if child.type == cs.TS_CS_BASE_LIST:
+            for subchild in child.children:
+                if subchild.type == cs.TS_IDENTIFIER and subchild.text:
+                    if name := safe_decode_text(subchild):
+                        # Skip interfaces (start with 'I' followed by uppercase)
+                        if len(name) > 1 and name.startswith("I") and name[1].isupper():
+                            continue
+                        # This is a base class
+                        base_class_names.append(name)
+            break
+
+    return base_class_names
+
+
 def extract_implemented_interfaces(
     class_node: Node,
     module_qn: str,
     resolve_to_qn: Callable[[str, str], str],
 ) -> list[str]:
     implemented_interfaces: list[str] = []
 
+    # Java: uses 'interfaces' field
     interfaces_node = class_node.child_by_field_name(cs.FIELD_INTERFACES)
     if interfaces_node:
         extract_java_interface_names(
             interfaces_node, implemented_interfaces, module_qn, resolve_to_qn
         )
 
+    # C#: uses 'base_list' child node (contains both base class and interfaces)
+    for child in class_node.children:
+        if child.type == cs.TS_CS_BASE_LIST:
+            extract_csharp_interface_names(
+                child, implemented_interfaces, module_qn, resolve_to_qn
+            )
+            break
+
     return implemented_interfaces
 
 
@@ -325,3 +398,59 @@ def extract_java_interface_names(
                 if type_child.type == cs.TS_TYPE_IDENTIFIER and type_child.text:
                     if interface_name := safe_decode_text(type_child):
                         interface_list.append(resolve_to_qn(interface_name, module_qn))
+
+
+def extract_csharp_interface_names(
+    base_list_node: Node,
+    interface_list: list[str],
+    module_qn: str,
+    resolve_to_qn: Callable[[str, str], str],
+) -> None:
+    """Extract interface names from C# base_list.
+
+    In C#, base_list contains both base class and interfaces:
+    - class Foo : BaseClass, IInterface1, IInterface2
+    - By convention, interfaces start with 'I'
+    - We extract names starting with 'I' as interfaces
+    """
+    for child in base_list_node.children:
+        if child.type == cs.TS_IDENTIFIER and child.text:
+            if name := safe_decode_text(child):
+                # C# convention: interfaces start with 'I' followed by uppercase
+                if len(name) > 1 and name.startswith("I") and name[1].isupper():
+                    interface_list.append(resolve_to_qn(name, module_qn))
+                    logger.debug(logs.CLASS_FOUND_INTERFACE.format(name=name, qn=resolve_to_qn(name, module_qn)))
+
+
+def extract_csharp_base_class(
+    class_node: Node,
+    module_qn: str,
+    resolve_to_qn: Callable[[str, str], str],
+) -> list[str]:
+    """Extract base class name from C# class declaration.
+
+    In C#, base_list contains both base class and interfaces:
+    - class Foo : BaseClass, IInterface1, IInterface2
+    - The base class is the first non-interface identifier
+    - By convention, interfaces start with 'I' followed by uppercase
+    """
+    parent_classes: list[str] = []
+
+    for child in class_node.children:
+        if child.type == cs.TS_CS_BASE_LIST:
+            for subchild in child.children:
+                if subchild.type == cs.TS_IDENTIFIER and subchild.text:
+                    if name := safe_decode_text(subchild):
+                        # Skip interfaces (start with 'I' followed by uppercase)
+                        if len(name) > 1 and name.startswith("I") and name[1].isupper():
+                            continue
+                        # This is a base class
+                        parent_classes.append(resolve_to_qn(name, module_qn))
+                        logger.debug(
+                            logs.CLASS_FOUND_BASE_CLASS.format(
+                                name=name, qn=resolve_to_qn(name, module_qn)
+                            )
+                        )
+            break
+
+    return parent_classes