raggiecode 0.2.1__py3-none-any.whl

indexing/language_config.py

@@ -0,0 +1,360 @@
+"""
+Language configuration for code indexer.
+Maps languages to their file extensions, tree-sitter grammars, and node types.
+"""
+
+# Language imports
+try:
+    from tree_sitter_python import language as python_language
+except ImportError:
+    python_language = None
+
+try:
+    from tree_sitter_go import language as go_language
+except ImportError:
+    go_language = None
+
+try:
+    from tree_sitter_language_pack import get_language as csharp_language_pack
+
+    c_sharp_language = csharp_language_pack("csharp")
+except ImportError:
+    c_sharp_language = None
+
+try:
+    from tree_sitter_language_pack import get_language as javascript_language_pack
+
+    javascript_language = javascript_language_pack("javascript")
+except ImportError:
+    javascript_language = None
+
+try:
+    from tree_sitter_language_pack import get_language as typescript_language_pack
+
+    typescript_language = typescript_language_pack("typescript")
+except ImportError:
+    typescript_language = None
+
+try:
+    from tree_sitter_language_pack import get_language as tsx_language_pack
+
+    tsx_language = tsx_language_pack("tsx")
+except ImportError:
+    tsx_language = None
+
+try:
+    from tree_sitter_rust import language as rust_language
+except ImportError:
+    rust_language = None
+
+try:
+    from tree_sitter_zig import language as zig_language
+except ImportError:
+    zig_language = None
+
+try:
+    from tree_sitter_elixir import language as elixir_language
+except ImportError:
+    elixir_language = None
+
+try:
+    from tree_sitter_cpp import language as cpp_language
+except ImportError:
+    cpp_language = None
+
+try:
+    from tree_sitter_c import language as c_language
+except ImportError:
+    c_language = None
+
+try:
+    from tree_sitter_php import language_php as php_language
+except ImportError:
+    php_language = None
+
+try:
+    from tree_sitter_language_pack import get_language as dart_language_pack
+
+    dart_language = dart_language_pack("dart")
+except ImportError:
+    dart_language = None
+
+try:
+    from tree_sitter_language_pack import get_language as java_language_pack
+
+    java_language = java_language_pack("java")
+except ImportError:
+    java_language = None
+
+try:
+    from tree_sitter_language_pack import get_language as kotlin_language_pack
+
+    kotlin_language = kotlin_language_pack("kotlin")
+except ImportError:
+    kotlin_language = None
+
+try:
+    from tree_sitter_language_pack import get_language as html_language_pack
+
+    html_language = html_language_pack("html")
+except ImportError:
+    html_language = None
+
+try:
+    from tree_sitter_language_pack import get_language as css_language_pack
+
+    css_language = css_language_pack("css")
+except ImportError:
+    css_language = None
+
+
+LANGUAGE_CONFIG = {
+    "python": {
+        "extensions": [".py"],
+        "language_module": python_language,
+        "node_types": {
+            "function": ["function_definition"],
+            "class": ["class_definition"],
+            "assignment": ["assignment"],
+            "type_alias": ["type_alias"],
+        },
+    },
+    "go": {
+        "extensions": [".go"],
+        "language_module": go_language,
+        "node_types": {
+            "function": ["function_declaration", "method_declaration"],
+            "class": None,
+            "struct": ["type_declaration"],
+            "interface": ["type_declaration"],
+            "method": ["method_declaration"],
+            "assignment": ["assignment_statement", "short_var_declaration"],
+            "type_alias": ["type_declaration"],
+        },
+    },
+    "csharp": {
+        "extensions": [".cs"],
+        "language_module": c_sharp_language,
+        "node_types": {
+            "function": ["method_declaration", "constructor_declaration"],
+            "class": ["class_declaration", "record_declaration", "record_struct_declaration"],
+            "assignment": ["assignment_expression"],
+            "type_alias": None,
+            "public_field": [
+                "property_declaration",
+                "event_declaration",
+                "event_field_declaration",
+            ],
+            "interface": ["interface_declaration"],
+            "struct": ["struct_declaration"],
+            "enum": ["enum_declaration"],
+        },
+    },
+    "javascript": {
+        "extensions": [".js", ".jsx"],
+        "language_module": javascript_language,
+        "node_types": {
+            "function": [
+                "function_declaration",
+                "generator_function_declaration",
+                "method_definition",
+            ],
+            "class": ["class_declaration"],
+            "assignment": ["assignment_expression", "lexical_declaration", "variable_declaration"],
+            "type_alias": None,
+        },
+    },
+    "typescript": {
+        "extensions": [".ts"],
+        "language_module": typescript_language,
+        "node_types": {
+            "function": ["function_declaration"],
+            "class": ["class_declaration", "abstract_class_declaration"],
+            "interface": ["interface_declaration"],
+            "assignment": ["assignment_expression", "lexical_declaration", "variable_declaration"],
+            "type_alias": ["type_alias_declaration"],
+            "method": ["method_definition"],
+            "public_field": ["public_field_definition"],
+            "enum": ["enum_declaration"],
+        },
+    },
+    "tsx": {
+        "extensions": [".tsx"],
+        "language_module": tsx_language,
+        "node_types": {
+            "function": ["function_declaration"],
+            "class": ["class_declaration", "abstract_class_declaration"],
+            "interface": ["interface_declaration"],
+            "assignment": ["assignment_expression"],
+            "type_alias": ["type_alias_declaration"],
+            "method": ["method_definition"],
+            "public_field": ["public_field_definition"],
+            "enum": ["enum_declaration"],
+        },
+    },
+    "rust": {
+        "extensions": [".rs"],
+        "language_module": rust_language,
+        "node_types": {
+            "function": ["function_item"],
+            "class": None,
+            "struct": ["struct_item"],
+            "enum": ["enum_item"],
+            "interface": ["trait_item"],
+            "assignment": ["let_declaration"],
+            "type_alias": ["type_item"],
+        },
+    },
+    "zig": {
+        "extensions": [".zig"],
+        "language_module": zig_language,
+        "node_types": {
+            "function": ["function_declaration"],
+            "class": None,
+            "assignment": ["variable_declaration"],
+            "type_alias": None,
+        },
+    },
+    "elixir": {
+        "extensions": [".ex", ".exs"],
+        "language_module": elixir_language,
+        "node_types": {
+            "function": None,
+            "class": None,
+            "assignment": ["binary_operator"],
+            "type_alias": None,
+        },
+    },
+    "cpp": {
+        "extensions": [".cpp", ".cc", ".cxx", ".hpp", ".h", ".hxx"],
+        "language_module": cpp_language,
+        "node_types": {
+            "function": ["function_definition"],
+            "class": ["class_specifier", "struct_specifier"],
+            "struct": ["struct_specifier"],
+            "enum": ["enum_specifier"],
+            "assignment": ["assignment_expression"],
+            "type_alias": ["type_alias_declaration", "alias_declaration"],
+        },
+    },
+    "c": {
+        "extensions": [".c", ".h"],
+        "language_module": c_language,
+        "node_types": {
+            "function": ["function_definition"],
+            "class": None,
+            "struct": ["struct_specifier"],
+            "enum": ["enum_specifier"],
+            "assignment": ["declaration"],
+            "type_alias": ["type_definition"],
+        },
+    },
+    "php": {
+        "extensions": [".php"],
+        "language_module": php_language,
+        "node_types": {
+            "function": ["function_definition", "method_declaration"],
+            "class": ["class_declaration"],
+            "interface": ["interface_declaration"],
+            "assignment": ["assignment_expression"],
+            "type_alias": None,
+        },
+    },
+    "dart": {
+        "extensions": [".dart"],
+        "language_module": dart_language,
+        "node_types": {
+            "function": [
+                "function_signature",
+                "getter_signature",
+                "setter_signature",
+                "constructor_signature",
+                "method_signature",
+            ],
+            "class": ["class_definition", "mixin_declaration", "extension_declaration"],
+            "assignment": ["assignment_expression"],
+            "type_alias": ["type_alias"],
+        },
+    },
+    "java": {
+        "extensions": [".java"],
+        "language_module": java_language,
+        "node_types": {
+            "function": ["method_declaration", "constructor_declaration"],
+            "class": ["class_declaration", "record_declaration", "annotation_type_declaration"],
+            "interface": ["interface_declaration"],
+            "enum": ["enum_declaration"],
+            "assignment": ["assignment_expression"],
+            "type_alias": None,
+        },
+    },
+    "kotlin": {
+        "extensions": [".kt", ".kts"],
+        "language_module": kotlin_language,
+        "node_types": {
+            "function": ["function_declaration"],
+            "class": ["class_declaration", "object_declaration"],
+            "assignment": ["assignment"],
+            "type_alias": ["type_alias"],
+        },
+    },
+    "html": {
+        "extensions": [".html", ".htm"],
+        "language_module": html_language,
+        "node_types": {
+            "element": ["element", "void_element"],
+            "text": ["text"],
+            "script_element": ["script_element"],
+            "style_element": ["style_element"],
+        },
+    },
+    "css": {
+        "extensions": [".css"],
+        "language_module": css_language,
+        "node_types": {
+            "rule_set": ["rule_set"],
+            "selectors": ["selectors"],
+            "block": ["block"],
+            "declaration": ["declaration"],
+            "import_statement": ["import_statement"],
+            "keyframes_statement": ["keyframes_statement"],
+        },
+    },
+}
+
+
+def get_language_for_extension(file_extension):
+    """Get language name for a given file extension."""
+    file_ext = file_extension.lower()
+    for lang, config in LANGUAGE_CONFIG.items():
+        if file_ext in config["extensions"]:
+            return lang
+    return None
+
+
+def get_extensions_for_languages(languages):
+    """Get all file extensions for a list of languages."""
+    extensions = set()
+    for lang in languages:
+        if lang in LANGUAGE_CONFIG:
+            extensions.update(LANGUAGE_CONFIG[lang]["extensions"])
+    return extensions
+
+
+def is_language_available(language):
+    """Check if a language's tree-sitter grammar is available."""
+    if language not in LANGUAGE_CONFIG:
+        return False
+    return LANGUAGE_CONFIG[language]["language_module"] is not None
+
+
+def get_available_languages():
+    """Get list of languages with available grammars."""
+    return [lang for lang in LANGUAGE_CONFIG.keys() if is_language_available(lang)]
+
+
+def get_node_types(language):
+    """Get node type mapping for a language."""
+    if language in LANGUAGE_CONFIG:
+        return LANGUAGE_CONFIG[language]["node_types"]
+    return {}

indexing/models.py

@@ -0,0 +1,284 @@
+#!/usr/bin/env python3
+"""
+Data models for the Code Index SDK.
+Dataclasses representing code entities stored in the SQLite index.
+"""
+
+import json
+import sqlite3
+from typing import List, Dict, Optional
+from dataclasses import dataclass
+
+
+@dataclass
+class Location:
+    """Source code location."""
+    start_line: int
+    start_column: int
+    end_line: int
+    end_column: int
+    start_byte: Optional[int] = None
+    end_byte: Optional[int] = None
+    
+    @classmethod
+    def from_dict(cls, data: Dict) -> 'Location':
+        known = {f.name for f in cls.__dataclass_fields__.values()}
+        return cls(**{k: v for k, v in data.items() if k in known})
+
+
+@dataclass
+class Function:
+    """Function or method definition."""
+    id: int
+    name: str
+    type: str  # 'function' or 'method'
+    file_id: int
+    file_path: str
+    location: Location
+    parameters: List[Dict]
+    return_type: Optional[str]
+    docstring: Optional[str]
+    description: Optional[str] = None
+    receiver: Optional[str] = None
+    parent_id: Optional[int] = None
+    parent_type: Optional[str] = None
+    branch_count: int = 0
+    
+    @classmethod
+    def from_row(cls, row: sqlite3.Row, file_path: str) -> 'Function':
+        return cls(
+            id=row['id'],
+            name=row['name'],
+            type=row['type'],
+            file_id=row['file_id'],
+            file_path=file_path,
+            location=Location.from_dict(json.loads(row['location'])),
+            parameters=json.loads(row['parameters']),
+            return_type=row['return_type'],
+            docstring=row['docstring'],
+            description=row['description'] if 'description' in row.keys() else None,
+            receiver=row['receiver'],
+            parent_id=row['parent_id'],
+            parent_type=row['parent_type'],
+            branch_count=row['branch_count'] if 'branch_count' in row.keys() else 0
+        )
+
+
+@dataclass
+class Class:
+    """Class definition."""
+    id: int
+    name: str
+    file_id: int
+    file_path: str
+    location: Location
+    base_classes: List[str]
+    docstring: Optional[str]
+    description: Optional[str] = None
+    parent_id: Optional[int] = None
+    namespace: Optional[str] = None
+    
+    @classmethod
+    def from_row(cls, row: sqlite3.Row, file_path: str) -> 'Class':
+        return cls(
+            id=row['id'],
+            name=row['name'],
+            file_id=row['file_id'],
+            file_path=file_path,
+            location=Location.from_dict(json.loads(row['location'])),
+            base_classes=json.loads(row['base_classes']),
+            docstring=row['docstring'],
+            description=row['description'] if 'description' in row.keys() else None,
+            parent_id=row['parent_id'],
+            namespace=row['namespace'] if 'namespace' in row.keys() else None
+        )
+
+
+@dataclass
+class Variable:
+    """Variable or attribute definition."""
+    id: int
+    name: str
+    type: str  # 'variable' or 'attribute'
+    file_id: int
+    file_path: str
+    location: Location
+    field_type: Optional[str] = None
+    description: Optional[str] = None
+    parent_id: Optional[int] = None
+    parent_type: Optional[str] = None
+    
+    @classmethod
+    def from_row(cls, row: sqlite3.Row, file_path: str) -> 'Variable':
+        return cls(
+            id=row['id'],
+            name=row['name'],
+            type=row['type'],
+            file_id=row['file_id'],
+            file_path=file_path,
+            location=Location.from_dict(json.loads(row['location'])),
+            field_type=row['field_type'],
+            description=row['description'] if 'description' in row.keys() else None,
+            parent_id=row['parent_id'],
+            parent_type=row['parent_type']
+        )
+
+
+@dataclass
+class TypeAlias:
+    """Type alias definition."""
+    id: int
+    name: str
+    file_id: int
+    file_path: str
+    location: Location
+    type_definition: Optional[str]
+    description: Optional[str] = None
+    
+    @classmethod
+    def from_row(cls, row: sqlite3.Row, file_path: str) -> 'TypeAlias':
+        return cls(
+            id=row['id'],
+            name=row['name'],
+            file_id=row['file_id'],
+            file_path=file_path,
+            location=Location.from_dict(json.loads(row['location'])),
+            type_definition=row['type_definition'],
+            description=row['description'] if 'description' in row.keys() else None
+        )
+
+
+@dataclass
+class Struct:
+    """Struct definition (Go, Rust, C, etc.)."""
+    id: int
+    name: str
+    file_id: int
+    file_path: str
+    location: Location
+    description: Optional[str] = None
+    
+    @classmethod
+    def from_row(cls, row: sqlite3.Row, file_path: str) -> 'Struct':
+        return cls(
+            id=row['id'],
+            name=row['name'],
+            file_id=row['file_id'],
+            file_path=file_path,
+            location=Location.from_dict(json.loads(row['location'])),
+            description=row['description'] if 'description' in row.keys() else None
+        )
+
+
+@dataclass
+class Interface:
+    """Interface/trait definition (Go, Rust, TypeScript, etc.)."""
+    id: int
+    name: str
+    file_id: int
+    file_path: str
+    location: Location
+    description: Optional[str] = None
+    
+    @classmethod
+    def from_row(cls, row: sqlite3.Row, file_path: str) -> 'Interface':
+        return cls(
+            id=row['id'],
+            name=row['name'],
+            file_id=row['file_id'],
+            file_path=file_path,
+            location=Location.from_dict(json.loads(row['location'])),
+            description=row['description'] if 'description' in row.keys() else None
+        )
+
+
+@dataclass
+class Enum:
+    """Enum definition (Rust, etc.)."""
+    id: int
+    name: str
+    file_id: int
+    file_path: str
+    location: Location
+    description: Optional[str] = None
+    
+    @classmethod
+    def from_row(cls, row: sqlite3.Row, file_path: str) -> 'Enum':
+        return cls(
+            id=row['id'],
+            name=row['name'],
+            file_id=row['file_id'],
+            file_path=file_path,
+            location=Location.from_dict(json.loads(row['location'])),
+            description=row['description'] if 'description' in row.keys() else None
+        )
+
+
+@dataclass
+class Namespace:
+    """Namespace definition (C#, etc.)."""
+    id: int
+    name: str
+    file_id: int
+    file_path: str
+    location: Location
+    description: Optional[str] = None
+    
+    @classmethod
+    def from_row(cls, row: sqlite3.Row, file_path: str) -> 'Namespace':
+        return cls(
+            id=row['id'],
+            name=row['name'],
+            file_id=row['file_id'],
+            file_path=file_path,
+            location=Location.from_dict(json.loads(row['location'])),
+            description=row['description'] if 'description' in row.keys() else None
+        )
+
+
+@dataclass
+class File:
+    """File information."""
+    id: int
+    path: str
+    absolute_path: str
+    language: str
+    
+    @classmethod
+    def from_row(cls, row: sqlite3.Row) -> 'File':
+        return cls(
+            id=row['id'],
+            path=row['path'],
+            absolute_path=row['absolute_path'],
+            language=row['language']
+        )
+
+
+@dataclass
+class Dependency:
+    """Dependency information (imports and function calls)."""
+    id: int
+    file_id: int
+    file_path: str
+    dependency_type: str  # 'import' or 'function_call'
+    name: str
+    source_function_id: Optional[int] = None
+    target_function_id: Optional[int] = None
+    target_class_id: Optional[int] = None
+    location: Optional[Location] = None
+    is_external: bool = True  # True for external dependencies, False for internal
+
+    @classmethod
+    def from_row(cls, row: sqlite3.Row, file_path: str) -> 'Dependency':
+        return cls(
+            id=row['id'],
+            file_id=row['file_id'],
+            file_path=file_path,
+            dependency_type=row['dependency_type'],
+            name=row['name'],
+            source_function_id=row['source_function_id'],
+            target_function_id=row['target_function_id'] if 'target_function_id' in row.keys() else None,
+            target_class_id=row['target_class_id'] if 'target_class_id' in row.keys() else None,
+            location=Location.from_dict(json.loads(row['location'])) if row['location'] else None,
+            is_external=bool(row['is_external']) if 'is_external' in row.keys() else True
+        )