codegraph-py 1.0.0__py3-none-any.whl

codegraph/extraction/languages/__init__.py

@@ -0,0 +1,64 @@
+"""
+Language extraction configuration registry.
+
+Maps Language enum values to their corresponding LanguageConfig instances.
+"""
+
+from ...types import Language as LangEnum
+from .base import LanguageConfig
+
+# Import all language configs
+from .python_cfg import PythonConfig
+from .javascript_cfg import JavaScriptConfig
+from .typescript_cfg import TypeScriptConfig
+from .go_cfg import GoConfig
+from .java_cfg import JavaConfig
+from .rust_cfg import RustConfig
+from .c_cfg import CConfig
+from .cpp_cfg import CPPConfig
+from .ruby_cfg import RubyConfig
+from .swift_cfg import SwiftConfig
+from .kotlin_cfg import KotlinConfig
+from .dart_cfg import DartConfig
+from .scala_cfg import ScalaConfig
+from .lua_cfg import LuaConfig
+
+# Registry: maps Language enum -> LanguageConfig instance
+_REGISTRY: dict[LangEnum, LanguageConfig] = {}
+
+def _register(config_cls: type[LanguageConfig], *langs: LangEnum):
+    """Register a config class for one or more language enums."""
+    instance = config_cls()
+    for lang in langs:
+        _REGISTRY[lang] = instance
+
+# Register all supported languages
+_register(PythonConfig, LangEnum.PYTHON)
+_register(JavaScriptConfig, LangEnum.JAVASCRIPT, LangEnum.JSX)
+_register(TypeScriptConfig, LangEnum.TYPESCRIPT, LangEnum.TSX)
+_register(GoConfig, LangEnum.GO)
+_register(JavaConfig, LangEnum.JAVA)
+_register(RustConfig, LangEnum.RUST)
+_register(CConfig, LangEnum.C)
+_register(CPPConfig, LangEnum.CPP)
+_register(RubyConfig, LangEnum.RUBY)
+_register(SwiftConfig, LangEnum.SWIFT)
+_register(KotlinConfig, LangEnum.KOTLIN)
+_register(DartConfig, LangEnum.DART)
+_register(ScalaConfig, LangEnum.SCALA)
+_register(LuaConfig, LangEnum.LUA, LangEnum.LUAU)
+
+
+def get_config(lang: LangEnum) -> LanguageConfig | None:
+    """Get the LanguageConfig for a given Language enum value."""
+    return _REGISTRY.get(lang)
+
+
+def has_config(lang: LangEnum) -> bool:
+    """Check if a language has a tree-sitter extraction config."""
+    return lang in _REGISTRY
+
+
+def supported_languages() -> list[LangEnum]:
+    """Return list of languages with tree-sitter extraction support."""
+    return list(_REGISTRY.keys())

codegraph/extraction/languages/base.py

@@ -0,0 +1,132 @@
+"""
+Language extraction configuration base types.
+
+Mirrors the TypeScript LanguageExtractor interface from the original CodeGraph,
+adapted for Python tree-sitter bindings.
+"""
+
+from typing import Optional, ClassVar
+from tree_sitter import Node as TSNode
+
+from ...types import NodeKind
+
+
+class ImportInfo:
+    """Information returned by a language's extract_import hook."""
+    __slots__ = ('module_name', 'signature', 'handled_refs')
+
+    def __init__(self, module_name: str, signature: str, handled_refs: bool = False):
+        self.module_name = module_name
+        self.signature = signature
+        self.handled_refs = handled_refs
+
+
+class VariableInfo:
+    """Information about a variable within a declaration."""
+    __slots__ = ('name', 'kind', 'signature')
+
+    def __init__(self, name: str, kind: str, signature: Optional[str] = None):
+        self.name = name
+        self.kind = kind
+        self.signature = signature
+
+
+class LanguageConfig:
+    """
+    Language-specific extraction configuration.
+
+    Each supported language defines class-level attributes for node type
+    mappings and optional hooks. Subclasses automatically inherit and
+    override parent config.
+    """
+
+    # --- Node type mappings ---
+    function_types: ClassVar[list[str]] = []
+    class_types: ClassVar[list[str]] = []
+    method_types: ClassVar[list[str]] = []
+    interface_types: ClassVar[list[str]] = []
+    struct_types: ClassVar[list[str]] = []
+    enum_types: ClassVar[list[str]] = []
+    enum_member_types: ClassVar[list[str]] = []
+    type_alias_types: ClassVar[list[str]] = []
+    import_types: ClassVar[list[str]] = []
+    call_types: ClassVar[list[str]] = []
+    variable_types: ClassVar[list[str]] = []
+    field_types: ClassVar[list[str]] = []
+    property_types: ClassVar[list[str]] = []
+    statement_types: ClassVar[list[str]] = []
+
+    # --- Field name mappings ---
+    name_field: ClassVar[str] = 'name'
+    body_field: ClassVar[str] = 'body'
+    params_field: ClassVar[str] = 'parameters'
+    return_field: ClassVar[Optional[str]] = None
+
+    # --- Language identity ---
+    language_id: ClassVar[str] = ''
+    """The tree-sitter language identifier (e.g. 'python', 'javascript')."""
+
+    # ============================================================
+    # Hooks — override in subclass for language-specific behaviour
+    # ============================================================
+
+    def get_signature(self, node: TSNode, source: bytes) -> Optional[str]:
+        """Extract function/method signature."""
+        return None
+
+    def get_visibility(self, node: TSNode) -> Optional[str]:
+        """Extract visibility (public/private/protected)."""
+        return None
+
+    def is_exported(self, node: TSNode, source: bytes) -> bool:
+        """Check if node is exported."""
+        return False
+
+    def is_async(self, node: TSNode) -> bool:
+        """Check if node is async."""
+        return False
+
+    def is_static(self, node: TSNode) -> bool:
+        """Check if node is static."""
+        return False
+
+    def is_const(self, node: TSNode) -> bool:
+        """Check if variable declaration is a constant."""
+        return False
+
+    def extract_import(self, node: TSNode, source: bytes) -> Optional[ImportInfo]:
+        """Extract import information from an import node."""
+        return None
+
+    def extract_variables(self, node: TSNode, source: bytes) -> list:
+        """Extract variable declarations from a variable node."""
+        return []
+
+    def extract_modifiers(self, node: TSNode) -> list[str]:
+        """Extract extra modifier keywords."""
+        return []
+
+    def classify_class_node(self, node: TSNode) -> str:
+        """Classify a class_declaration node: 'class', 'struct', 'enum', 'interface', 'trait'."""
+        return 'class'
+
+    @staticmethod
+    def should_skip_type(node_type: str) -> bool:
+        """Check if a node type should be skipped during traversal."""
+        return node_type in (
+            'comment', 'string', 'string_content', 'escape_sequence',
+            'interpolation',
+        )
+
+    # ============================================================
+    # Convenience
+    # ============================================================
+
+    def all_symbol_types(self) -> set[str]:
+        """Return the set of all AST node types that represent symbols."""
+        return set(
+            self.function_types + self.class_types + self.method_types
+            + self.interface_types + self.struct_types + self.enum_types
+            + self.type_alias_types + self.import_types + self.call_types
+            + self.variable_types
+        )

codegraph/extraction/languages/c_cfg.py

@@ -0,0 +1,53 @@
+"""
+C language extraction configuration.
+"""
+from tree_sitter import Node as TSNode
+from .base import LanguageConfig, ImportInfo
+
+
+class CConfig(LanguageConfig):
+    """C extraction configuration."""
+
+    language_id = 'c'
+
+    function_types = ['function_definition']
+    class_types = []
+    method_types = []
+    interface_types = []
+    struct_types = ['struct_specifier']
+    enum_types = ['enum_specifier']
+    type_alias_types = ['type_definition']
+    import_types = ['preproc_include', 'include_directive']
+    call_types = ['call_expression']
+    variable_types = ['declaration']
+    field_types = ['field_declaration']
+    property_types = []
+
+    name_field = 'name'
+    body_field = 'body'
+    params_field = 'parameters'
+    return_field = 'type'
+
+    def get_signature(self, node: TSNode, source: bytes) -> str | None:
+        params = node.child_by_field_name('parameters')
+        if not params:
+            return None
+        sig = source[params.start_byte:params.end_byte].decode('utf-8', errors='replace')
+        return_type = node.child_by_field_name('type')
+        if return_type:
+            ret = source[return_type.start_byte:return_type.end_byte].decode('utf-8', errors='replace')
+            sig = f'{ret} {sig}'
+        return sig
+
+    def extract_import(self, node: TSNode, source: bytes) -> ImportInfo | None:
+        if node.type in ('preproc_include', 'include_directive'):
+            text = source[node.start_byte:node.end_byte].decode('utf-8', errors='replace').strip()
+            path_node = node.child_by_field_name('path')
+            if path_node:
+                module_name = source[path_node.start_byte:path_node.end_byte].decode('utf-8', errors='replace')
+                module_name = module_name.strip('<>"')
+                return ImportInfo(module_name=module_name, signature=text)
+        return None
+
+    def is_exported(self, node: TSNode, source: bytes) -> bool:
+        return True  # All C functions at file scope are effectively exported

codegraph/extraction/languages/cpp_cfg.py

@@ -0,0 +1,60 @@
+"""
+C++ language extraction configuration.
+"""
+from tree_sitter import Node as TSNode
+from .base import LanguageConfig, ImportInfo
+
+
+class CPPConfig(LanguageConfig):
+    """C++ extraction configuration."""
+
+    language_id = 'cpp'
+
+    function_types = ['function_definition']
+    class_types = ['class_specifier']
+    method_types = ['function_definition']  # Functions inside class bodies
+    interface_types = []
+    struct_types = ['struct_specifier']
+    enum_types = ['enum_specifier']
+    type_alias_types = ['type_definition', 'alias_declaration']
+    import_types = ['preproc_include', 'include_directive', 'using_declaration']
+    call_types = ['call_expression']
+    variable_types = ['declaration']
+    field_types = ['field_declaration']
+    property_types = []
+
+    name_field = 'name'
+    body_field = 'body'
+    params_field = 'parameters'
+    return_field = 'type'
+
+    def get_signature(self, node: TSNode, source: bytes) -> str | None:
+        params = node.child_by_field_name('parameters')
+        if not params:
+            return None
+        sig = source[params.start_byte:params.end_byte].decode('utf-8', errors='replace')
+        return_type = node.child_by_field_name('type')
+        if return_type:
+            ret = source[return_type.start_byte:return_type.end_byte].decode('utf-8', errors='replace')
+            sig = f'{ret} {sig}'
+        return sig
+
+    def extract_import(self, node: TSNode, source: bytes) -> ImportInfo | None:
+        if node.type in ('preproc_include', 'include_directive'):
+            text = source[node.start_byte:node.end_byte].decode('utf-8', errors='replace').strip()
+            path_node = node.child_by_field_name('path')
+            if path_node:
+                module_name = source[path_node.start_byte:path_node.end_byte].decode('utf-8', errors='replace')
+                module_name = module_name.strip('<>"')
+                return ImportInfo(module_name=module_name, signature=text)
+        elif node.type == 'using_declaration':
+            text = source[node.start_byte:node.end_byte].decode('utf-8', errors='replace').strip()
+            # Extract namespace from 'using namespace X;'
+            args = node.child_by_field_name('argument')
+            if args:
+                module_name = source[args.start_byte:args.end_byte].decode('utf-8', errors='replace')
+                return ImportInfo(module_name=module_name, signature=text)
+        return None
+
+    def is_exported(self, node: TSNode, source: bytes) -> bool:
+        return True  # C++ functions at file scope are exported

codegraph/extraction/languages/dart_cfg.py

@@ -0,0 +1,53 @@
+"""
+Dart language extraction configuration.
+"""
+from tree_sitter import Node as TSNode
+from .base import LanguageConfig, ImportInfo
+
+
+class DartConfig(LanguageConfig):
+    """Dart extraction configuration."""
+
+    language_id = 'dart'
+
+    function_types = ['function_declaration']
+    class_types = ['class_declaration']
+    method_types = ['method_declaration']
+    interface_types = ['interface_type']  # Dart uses abstract classes + implements
+    struct_types = []
+    enum_types = ['enum_declaration']
+    type_alias_types = ['type_alias']
+    import_types = ['import_directive', 'export_directive']
+    call_types = ['function_expression']
+    variable_types = ['variable_declaration']
+    field_types = ['field_declaration']
+    property_types = []
+
+    name_field = 'name'
+    body_field = 'body'
+    params_field = 'parameters'
+    return_field = 'return_type'
+
+    def get_signature(self, node: TSNode, source: bytes) -> str | None:
+        params = node.child_by_field_name('parameters')
+        if not params:
+            return None
+        sig = source[params.start_byte:params.end_byte].decode('utf-8', errors='replace')
+        return_type = node.child_by_field_name('return_type')
+        if return_type:
+            ret = source[return_type.start_byte:return_type.end_byte].decode('utf-8', errors='replace')
+            sig += f' -> {ret}'
+        return sig
+
+    def extract_import(self, node: TSNode, source: bytes) -> ImportInfo | None:
+        if node.type in ('import_directive', 'export_directive'):
+            text = source[node.start_byte:node.end_byte].decode('utf-8', errors='replace').strip()
+            uri_node = node.child_by_field_name('uri')
+            if uri_node:
+                module_name = source[uri_node.start_byte:uri_node.end_byte].decode('utf-8', errors='replace')
+                module_name = module_name.strip('\'"')
+                return ImportInfo(module_name=module_name, signature=text)
+        return None
+
+    def is_exported(self, node: TSNode, source: bytes) -> bool:
+        return True  # Exported via library/part directives

codegraph/extraction/languages/go_cfg.py

@@ -0,0 +1,70 @@
+"""
+Go language extraction configuration.
+"""
+from tree_sitter import Node as TSNode
+from .base import LanguageConfig, ImportInfo
+
+
+class GoConfig(LanguageConfig):
+    """Go extraction configuration."""
+
+    language_id = 'go'
+
+    function_types = ['function_declaration']
+    class_types = []
+    method_types = ['method_declaration']
+    interface_types = ['interface_type']
+    struct_types = ['struct_type']
+    enum_types = []
+    type_alias_types = ['type_spec']  # Go uses type_spec for type aliases and type definitions
+    import_types = ['import_declaration', 'import_spec']
+    call_types = ['call_expression']
+    variable_types = ['var_declaration', 'short_var_declaration']
+    field_types = ['field_declaration']
+    property_types = []
+
+    name_field = 'name'
+    body_field = 'body'
+    params_field = 'parameters'
+    return_field = 'result'
+
+    def get_signature(self, node: TSNode, source: bytes) -> str | None:
+        params = node.child_by_field_name('parameters')
+        if not params:
+            return None
+        sig = source[params.start_byte:params.end_byte].decode('utf-8', errors='replace')
+        result = node.child_by_field_name('result')
+        if result:
+            sig += ' ' + source[result.start_byte:result.end_byte].decode('utf-8', errors='replace')
+        return sig
+
+    def extract_import(self, node: TSNode, source: bytes) -> ImportInfo | None:
+        if node.type == 'import_spec':
+            path_node = node.child_by_field_name('path')
+            if path_node:
+                module_name = source[path_node.start_byte:path_node.end_byte].decode('utf-8', errors='replace')
+                module_name = module_name.strip('"')
+                return ImportInfo(
+                    module_name=module_name,
+                    signature=source[node.start_byte:node.end_byte].decode('utf-8', errors='replace').strip(),
+                )
+        elif node.type == 'import_declaration':
+            # Return parent container info
+            return ImportInfo(module_name='', signature='import (...)')
+        return None
+
+    def is_exported(self, node: TSNode, source: bytes) -> bool:
+        name = self._extract_name(node)
+        return name is not None and name[0].isupper() if name else False
+
+    def _extract_name(self, node: TSNode) -> str | None:
+        name_node = node.child_by_field_name('name')
+        if name_node:
+            try:
+                t = name_node.text
+                if isinstance(t, bytes):
+                    return t.decode('utf-8', errors='replace')
+                return str(t)
+            except Exception:
+                pass
+        return None

codegraph/extraction/languages/java_cfg.py

@@ -0,0 +1,62 @@
+"""
+Java language extraction configuration.
+"""
+from tree_sitter import Node as TSNode
+from .base import LanguageConfig, ImportInfo
+
+
+class JavaConfig(LanguageConfig):
+    """Java extraction configuration."""
+
+    language_id = 'java'
+
+    function_types = []
+    class_types = ['class_declaration']
+    method_types = ['method_declaration']
+    interface_types = ['interface_declaration']
+    struct_types = []
+    enum_types = ['enum_declaration']
+    type_alias_types = []
+    import_types = ['import_declaration']
+    call_types = ['method_invocation']
+    variable_types = ['variable_declaration', 'local_variable_declaration']
+    field_types = ['field_declaration']
+    property_types = []
+
+    name_field = 'name'
+    body_field = 'body'
+    params_field = 'parameters'
+    return_field = 'type'
+
+    def get_signature(self, node: TSNode, source: bytes) -> str | None:
+        params = node.child_by_field_name('parameters')
+        if not params:
+            return None
+        sig = source[params.start_byte:params.end_byte].decode('utf-8', errors='replace')
+        return_type = node.child_by_field_name('type')
+        if return_type:
+            type_text = source[return_type.start_byte:return_type.end_byte].decode('utf-8', errors='replace')
+            sig = type_text + ' ' + sig
+        return sig
+
+    def extract_import(self, node: TSNode, source: bytes) -> ImportInfo | None:
+        if node.type == 'import_declaration':
+            text = source[node.start_byte:node.end_byte].decode('utf-8', errors='replace').strip()
+            name = text.replace('import ', '').replace(';', '').strip()
+            return ImportInfo(module_name=name, signature=text) if name else None
+        return None
+
+    def get_visibility(self, node: TSNode) -> str | None:
+        # Walk previous siblings looking for modifier keywords
+        prev = node.prev_sibling
+        while prev is not None:
+            if prev.type == 'public':
+                return 'public'
+            if prev.type == 'private':
+                return 'private'
+            if prev.type == 'protected':
+                return 'protected'
+            if prev.is_named:
+                break
+            prev = prev.prev_sibling
+        return None

codegraph/extraction/languages/javascript_cfg.py

@@ -0,0 +1,84 @@
+"""
+JavaScript/JSX language extraction configuration.
+"""
+from tree_sitter import Node as TSNode
+from .base import LanguageConfig, ImportInfo
+
+
+def _node_text(node: TSNode) -> str:
+    try:
+        t = node.text
+        if isinstance(t, bytes):
+            return t.decode('utf-8', errors='replace')
+        return str(t)
+    except Exception:
+        return ''
+
+
+class JavaScriptConfig(LanguageConfig):
+    """JavaScript/JSX extraction configuration."""
+
+    language_id = 'javascript'
+
+    function_types = ['function_declaration', 'arrow_function', 'generator_function_declaration']
+    class_types = ['class_declaration']
+    method_types = ['method_definition']
+    interface_types = []
+    struct_types = []
+    enum_types = []
+    type_alias_types = []
+    import_types = ['import_statement', 'import_specifier']
+    call_types = ['call_expression']
+    variable_types = ['variable_declaration', 'lexical_declaration']
+    field_types = ['field_definition']
+    property_types = ['property_identifier']
+
+    name_field = 'name'
+    body_field = 'body'
+    params_field = 'parameters'
+    return_field = 'return_type'
+
+    def get_signature(self, node: TSNode, source: bytes) -> str | None:
+        params = node.child_by_field_name('parameters')
+        if not params:
+            return None
+        return source[params.start_byte:params.end_byte].decode('utf-8', errors='replace')
+
+    def extract_import(self, node: TSNode, source: bytes) -> ImportInfo | None:
+        text = source[node.start_byte:node.end_byte].decode('utf-8', errors='replace').strip()
+        if node.type == 'import_statement':
+            source_node = node.child_by_field_name('source')
+            if source_node:
+                module_name = source[source_node.start_byte:source_node.end_byte].decode('utf-8', errors='replace')
+                module_name = module_name.strip('\'"')
+                return ImportInfo(module_name=module_name, signature=text)
+        return None
+
+    def is_exported(self, node: TSNode, source: bytes) -> bool:
+        # Check if preceded by 'export' keyword
+        prev = node.prev_sibling
+        while prev is not None:
+            if prev.type == 'export':
+                return True
+            if prev.is_named or prev.type in (';', '\n'):
+                break
+            prev = prev.prev_sibling
+        return False
+
+    def is_async(self, node: TSNode) -> bool:
+        prev = node.prev_sibling
+        while prev is not None:
+            if prev.type == 'async':
+                return True
+            if prev.is_named:
+                break
+            prev = prev.prev_sibling
+        return False
+
+    def is_const(self, node: TSNode) -> bool:
+        # Check variable_declarator for const keyword
+        parent = node.parent
+        if parent and parent.type == 'variable_declaration':
+            kind = _node_text(parent.child(0)) if parent.child(0) else ''
+            return kind == 'const'
+        return False

codegraph/extraction/languages/kotlin_cfg.py

@@ -0,0 +1,52 @@
+"""
+Kotlin language extraction configuration.
+"""
+from tree_sitter import Node as TSNode
+from .base import LanguageConfig, ImportInfo
+
+
+class KotlinConfig(LanguageConfig):
+    """Kotlin extraction configuration."""
+
+    language_id = 'kotlin'
+
+    function_types = ['function_declaration']
+    class_types = ['class_declaration']
+    method_types = ['function_declaration']  # Functions inside class bodies
+    interface_types = ['interface_declaration']
+    struct_types = []
+    enum_types = ['enum_entry']
+    type_alias_types = ['type_alias']
+    import_types = ['import_header']
+    call_types = ['call_expression']
+    variable_types = ['property_declaration', 'variable_declaration']
+    field_types = ['property_declaration']
+    property_types = []
+
+    name_field = 'name'
+    body_field = 'body'
+    params_field = 'parameters'
+    return_field = 'type'
+
+    def get_signature(self, node: TSNode, source: bytes) -> str | None:
+        params = node.child_by_field_name('parameters')
+        if not params:
+            return None
+        sig = source[params.start_byte:params.end_byte].decode('utf-8', errors='replace')
+        return_type = node.child_by_field_name('type')
+        if return_type:
+            ret = source[return_type.start_byte:return_type.end_byte].decode('utf-8', errors='replace')
+            sig += f': {ret}'
+        return sig
+
+    def extract_import(self, node: TSNode, source: bytes) -> ImportInfo | None:
+        if node.type == 'import_header':
+            text = source[node.start_byte:node.end_byte].decode('utf-8', errors='replace').strip()
+            path_node = node.child_by_field_name('path')
+            if path_node:
+                module_name = source[path_node.start_byte:path_node.end_byte].decode('utf-8', errors='replace')
+                return ImportInfo(module_name=module_name, signature=text)
+        return None
+
+    def is_exported(self, node: TSNode, source: bytes) -> bool:
+        return True  # Kotlin functions are public by default