codegraphcontext 0.1.27__tar.gz → 0.1.28__tar.gz

{codegraphcontext-0.1.27/src/codegraphcontext.egg-info → codegraphcontext-0.1.28}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: codegraphcontext
-Version: 0.1.27
+Version: 0.1.28
 Summary: An MCP server that indexes local code into a graph database to provide context to AI assistants.
 Author-email: Shashank Shekhar Singh <shashankshekharsingh1205@gmail.com>
 License: MIT License
@@ -91,7 +91,7 @@ A powerful **MCP server** and **CLI toolkit** that indexes local code into a gra
 ![Using the MCP server](https://github.com/Shashankss1205/CodeGraphContext/blob/main/images/Usecase.gif)
 
 ## Project Details
-- **Version:** 0.1.27
+- **Version:** 0.1.28
 - **Authors:** Shashank Shekhar Singh <shashankshekharsingh1205@gmail.com>
 - **License:** MIT License (See [LICENSE](LICENSE) for details)
 - **Website:** [CodeGraphContext](http://codegraphcontext.vercel.app/)

{codegraphcontext-0.1.27 → codegraphcontext-0.1.28}/README.md

@@ -29,7 +29,7 @@ A powerful **MCP server** and **CLI toolkit** that indexes local code into a gra
 ![Using the MCP server](https://github.com/Shashankss1205/CodeGraphContext/blob/main/images/Usecase.gif)
 
 ## Project Details
-- **Version:** 0.1.27
+- **Version:** 0.1.28
 - **Authors:** Shashank Shekhar Singh <shashankshekharsingh1205@gmail.com>
 - **License:** MIT License (See [LICENSE](LICENSE) for details)
 - **Website:** [CodeGraphContext](http://codegraphcontext.vercel.app/)

{codegraphcontext-0.1.27 → codegraphcontext-0.1.28}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "codegraphcontext"
-version = "0.1.27"
+version = "0.1.28"
 description = "An MCP server that indexes local code into a graph database to provide context to AI assistants."
 authors = [{ name = "Shashank Shekhar Singh", email = "shashankshekharsingh1205@gmail.com" }]
 readme = "README.md"

{codegraphcontext-0.1.27 → codegraphcontext-0.1.28}/src/codegraphcontext/cli/main.py

@@ -708,12 +708,15 @@ def find_by_name(
             # Search all
             funcs = code_finder.find_by_function_name(name, fuzzy_search=False)
             classes = code_finder.find_by_class_name(name, fuzzy_search=False)
+            variables = code_finder.find_by_variable_name(name)
             
             for f in funcs: f['type'] = 'Function'
             for c in classes: c['type'] = 'Class'
+            for v in variables: v['type'] = 'Variable'
             
             results.extend(funcs)
             results.extend(classes)
+            results.extend(variables)
         
         elif type.lower() == 'function':
             results = code_finder.find_by_function_name(name, fuzzy_search=False)
@@ -723,6 +726,10 @@ def find_by_name(
             results = code_finder.find_by_class_name(name, fuzzy_search=False)
             for r in results: r['type'] = 'Class'
             
+        elif type.lower() == 'variable':
+            results = code_finder.find_by_variable_name(name)
+            for r in results: r['type'] = 'Variable'
+            
         elif type.lower() == 'file':
             # Quick query for file
             with db_manager.get_driver().session() as session:
@@ -780,7 +787,7 @@ def find_by_pattern(
             if not case_sensitive:
                 query = """
                     MATCH (n)
-                    WHERE (n:Function OR n:Class OR n:Module) AND toLower(n.name) CONTAINS toLower($pattern)
+                    WHERE (n:Function OR n:Class OR n:Module OR n:Variable) AND toLower(n.name) CONTAINS toLower($pattern)
                     RETURN 
                         labels(n)[0] as type,
                         n.name as name,
@@ -793,7 +800,7 @@ def find_by_pattern(
             else:
                  query = """
                     MATCH (n)
-                    WHERE (n:Function OR n:Class OR n:Module) AND n.name CONTAINS $pattern
+                    WHERE (n:Function OR n:Class OR n:Module OR n:Variable) AND n.name CONTAINS $pattern
                     RETURN 
                         labels(n)[0] as type,
                         n.name as name,
@@ -882,6 +889,194 @@ def find_by_type(
     finally:
         db_manager.close_driver()
 
+@find_app.command("variable")
+def find_by_variable(
+    name: str = typer.Argument(..., help="Variable name to search for")
+):
+    """
+    Find variables by name.
+    
+    Examples:
+        cgc find variable MAX_RETRIES
+        cgc find variable config
+    """
+    _load_credentials()
+    services = _initialize_services()
+    if not all(services):
+        return
+    db_manager, graph_builder, code_finder = services
+    
+    try:
+        results = code_finder.find_by_variable_name(name)
+        
+        if not results:
+            console.print(f"[yellow]No variables found with name '{name}'[/yellow]")
+            return
+            
+        table = Table(show_header=True, header_style="bold magenta", box=box.ROUNDED)
+        table.add_column("Name", style="cyan")
+        table.add_column("File", style="dim", overflow="fold")
+        table.add_column("Line", style="green", justify="right")
+        table.add_column("Context", style="yellow")
+        
+        for res in results:
+            table.add_row(
+                res.get('name', ''),
+                res.get('file_path', ''),
+                str(res.get('line_number', '')),
+                res.get('context', '') or 'module'
+            )
+            
+        console.print(f"[cyan]Found {len(results)} variable(s) named '{name}':[/cyan]")
+        console.print(table)
+    finally:
+        db_manager.close_driver()
+
+@find_app.command("content")
+def find_by_content_search(
+    query: str = typer.Argument(..., help="Text to search for in source code and docstrings")
+):
+    """
+    Search code content (source and docstrings) using full-text index.
+    
+    Examples:
+        cgc find content "error 503"
+        cgc find content "TODO: refactor"
+    """
+    _load_credentials()
+    services = _initialize_services()
+    if not all(services):
+        return
+    db_manager, graph_builder, code_finder = services
+    
+    try:
+        try:
+            results = code_finder.find_by_content(query)
+        except Exception as e:
+            error_msg = str(e).lower()
+            if 'fulltext' in error_msg or 'db.index.fulltext' in error_msg:
+                console.print("\n[bold red]❌ Full-text search is not supported on FalkorDB[/bold red]\n")
+                console.print("[yellow]💡 You have two options:[/yellow]\n")
+                console.print("  1. [cyan]Switch to Neo4j:[/cyan]")
+                console.print(f"     [dim]cgc --database neo4j find content \"{query}\"[/dim]\n")
+                console.print("  2. [cyan]Use pattern search instead:[/cyan]")
+                console.print(f"     [dim]cgc find pattern \"{query}\"[/dim]")
+                console.print("     [dim](searches in names only, not source code)[/dim]\n")
+                return
+            else:
+                # Re-raise if it's a different error
+                raise
+        
+        if not results:
+            console.print(f"[yellow]No content matches found for '{query}'[/yellow]")
+            return
+            
+        table = Table(show_header=True, header_style="bold magenta", box=box.ROUNDED)
+        table.add_column("Name", style="cyan")
+        table.add_column("Type", style="blue")
+        table.add_column("File", style="dim", overflow="fold")
+        table.add_column("Line", style="green", justify="right")
+        
+        for res in results:
+            table.add_row(
+                res.get('name', ''),
+                res.get('type', 'Unknown'),
+                res.get('file_path', ''),
+                str(res.get('line_number', ''))
+            )
+            
+        console.print(f"[cyan]Found {len(results)} content match(es) for '{query}':[/cyan]")
+        console.print(table)
+    finally:
+        db_manager.close_driver()
+
+@find_app.command("decorator")
+def find_by_decorator_search(
+    decorator: str = typer.Argument(..., help="Decorator name to search for"),
+    file: Optional[str] = typer.Option(None, "--file", "-f", help="Specific file path")
+):
+    """
+    Find functions with a specific decorator.
+    
+    Examples:
+        cgc find decorator app.route
+        cgc find decorator test --file tests/test_main.py
+    """
+    _load_credentials()
+    services = _initialize_services()
+    if not all(services):
+        return
+    db_manager, graph_builder, code_finder = services
+    
+    try:
+        results = code_finder.find_functions_by_decorator(decorator, file)
+        
+        if not results:
+            console.print(f"[yellow]No functions found with decorator '@{decorator}'[/yellow]")
+            return
+            
+        table = Table(show_header=True, header_style="bold magenta", box=box.ROUNDED)
+        table.add_column("Function", style="cyan")
+        table.add_column("File", style="dim", overflow="fold")
+        table.add_column("Line", style="green", justify="right")
+        table.add_column("Decorators", style="yellow")
+        
+        for res in results:
+            decorators_str = ", ".join(res.get('decorators', []))
+            table.add_row(
+                res.get('function_name', ''),
+                res.get('file_path', ''),
+                str(res.get('line_number', '')),
+                decorators_str
+            )
+            
+        console.print(f"[cyan]Found {len(results)} function(s) with decorator '@{decorator}':[/cyan]")
+        console.print(table)
+    finally:
+        db_manager.close_driver()
+
+@find_app.command("argument")
+def find_by_argument_search(
+    argument: str = typer.Argument(..., help="Argument/parameter name to search for"),
+    file: Optional[str] = typer.Option(None, "--file", "-f", help="Specific file path")
+):
+    """
+    Find functions that take a specific argument/parameter.
+    
+    Examples:
+        cgc find argument password
+        cgc find argument user_id --file src/auth.py
+    """
+    _load_credentials()
+    services = _initialize_services()
+    if not all(services):
+        return
+    db_manager, graph_builder, code_finder = services
+    
+    try:
+        results = code_finder.find_functions_by_argument(argument, file)
+        
+        if not results:
+            console.print(f"[yellow]No functions found with argument '{argument}'[/yellow]")
+            return
+            
+        table = Table(show_header=True, header_style="bold magenta", box=box.ROUNDED)
+        table.add_column("Function", style="cyan")
+        table.add_column("File", style="dim", overflow="fold")
+        table.add_column("Line", style="green", justify="right")
+        
+        for res in results:
+            table.add_row(
+                res.get('function_name', ''),
+                res.get('file_path', ''),
+                str(res.get('line_number', ''))
+            )
+            
+        console.print(f"[cyan]Found {len(results)} function(s) with argument '{argument}':[/cyan]")
+        console.print(table)
+    finally:
+        db_manager.close_driver()
+
 
 # ============================================================================
 # ANALYZE COMMAND GROUP - Code Analysis & Relationships
@@ -1232,6 +1427,114 @@ def analyze_dead_code(
     finally:
         db_manager.close_driver()
 
+@analyze_app.command("overrides")
+def analyze_overrides(
+    function_name: str = typer.Argument(..., help="Function/method name to find implementations of")
+):
+    """
+    Find all implementations of a function across different classes.
+    
+    Useful for finding polymorphic implementations and method overrides.
+    
+    Example:
+        cgc analyze overrides area
+        cgc analyze overrides process
+    """
+    _load_credentials()
+    services = _initialize_services()
+    if not all(services):
+        return
+    db_manager, graph_builder, code_finder = services
+    
+    try:
+        results = code_finder.find_function_overrides(function_name)
+        
+        if not results:
+            console.print(f"[yellow]No implementations found for function '{function_name}'[/yellow]")
+            return
+        
+        table = Table(show_header=True, header_style="bold magenta", box=box.ROUNDED)
+        table.add_column("Class", style="cyan")
+        table.add_column("Function", style="green")
+        table.add_column("File", style="dim", overflow="fold")
+        table.add_column("Line", style="yellow", justify="right")
+        
+        for res in results:
+            table.add_row(
+                res.get('class_name', ''),
+                res.get('function_name', ''),
+                res.get('class_file_path', ''),
+                str(res.get('function_line_number', ''))
+            )
+        
+        console.print(f"\n[bold cyan]Found {len(results)} implementation(s) of '{function_name}':[/bold cyan]")
+        console.print(table)
+    finally:
+        db_manager.close_driver()
+
+@analyze_app.command("variable")
+def analyze_variable_usage(
+    variable_name: str = typer.Argument(..., help="Variable name to analyze")
+):
+    """
+    Analyze where a variable is defined and used across the codebase.
+    
+    Shows all instances of the variable and their scope (function, class, module).
+    
+    Example:
+        cgc analyze variable MAX_RETRIES
+        cgc analyze variable config
+    """
+    _load_credentials()
+    services = _initialize_services()
+    if not all(services):
+        return
+    db_manager, graph_builder, code_finder = services
+    
+    try:
+        # Get variable usage scope
+        scope_results = code_finder.find_variable_usage_scope(variable_name)
+        instances = scope_results.get('instances', [])
+        
+        if not instances:
+            console.print(f"[yellow]No instances found for variable '{variable_name}'[/yellow]")
+            return
+        
+        console.print(f"\n[bold cyan]Variable '{variable_name}' Usage Analysis:[/bold cyan]\n")
+        
+        # Group by scope type
+        by_scope = {}
+        for inst in instances:
+            scope_type = inst.get('scope_type', 'unknown')
+            if scope_type not in by_scope:
+                by_scope[scope_type] = []
+            by_scope[scope_type].append(inst)
+        
+        # Display by scope
+        for scope_type, items in by_scope.items():
+            console.print(f"[bold yellow]{scope_type.upper()} Scope ({len(items)} instance(s)):[/bold yellow]")
+            
+            table = Table(show_header=True, header_style="bold magenta", box=box.ROUNDED)
+            table.add_column("Scope Name", style="cyan")
+            table.add_column("File", style="dim", overflow="fold")
+            table.add_column("Line", style="green", justify="right")
+            table.add_column("Value", style="yellow")
+            
+            for item in items:
+                table.add_row(
+                    item.get('scope_name', ''),
+                    item.get('file_path', ''),
+                    str(item.get('line_number', '')),
+                    str(item.get('variable_value', ''))[:50] if item.get('variable_value') else '-'
+                )
+            
+            console.print(table)
+            console.print()
+        
+        console.print(f"[dim]Total: {len(instances)} instance(s) across {len(by_scope)} scope type(s)[/dim]")
+    finally:
+        db_manager.close_driver()
+
 
 # ============================================================================
 # QUERY COMMAND - Raw Cypher Queries

{codegraphcontext-0.1.27 → codegraphcontext-0.1.28}/src/codegraphcontext/tools/code_finder.py

@@ -68,12 +68,12 @@ class CodeFinder:
         with self.driver.session() as session:
             result = session.run("""
                 MATCH (v:Variable)
-                WHERE v.name CONTAINS $search_term OR v.name =~ $regex_pattern
+                WHERE v.name CONTAINS $search_term
                 RETURN v.name as name, v.file_path as file_path, v.line_number as line_number,
                        v.value as value, v.context as context, v.is_dependency as is_dependency
                 ORDER BY v.is_dependency ASC, v.name
                 LIMIT 20
-            """, search_term=search_term, regex_pattern=f"(?i).*{re.escape(search_term)}.*")
+            """, search_term=search_term)
             
             return result.data()
 

{codegraphcontext-0.1.27 → codegraphcontext-0.1.28}/src/codegraphcontext/tools/graph_builder.py

@@ -64,6 +64,9 @@ class TreeSitterParser:
         elif self.language_name == 'kotlin':
             from .languages.kotlin import KotlinTreeSitterParser
             self.language_specific_parser = KotlinTreeSitterParser(self)
+        elif self.language_name == 'scala':
+            from .languages.scala import ScalaTreeSitterParser
+            self.language_specific_parser = ScalaTreeSitterParser(self)
 
 
 
@@ -105,6 +108,8 @@ class GraphBuilder:
             '.cs': TreeSitterParser('c_sharp'),
             '.php': TreeSitterParser('php'),
             '.kt': TreeSitterParser('kotlin'),
+            '.scala': TreeSitterParser('scala'),
+            '.sc': TreeSitterParser('scala'),
         }
         self.create_schema()
 
@@ -213,6 +218,12 @@ class GraphBuilder:
         if '.kt' in files_by_lang:
             from .languages import kotlin as kotlin_lang_module
             imports_map.update(kotlin_lang_module.pre_scan_kotlin(files_by_lang['.kt'], self.parsers['.kt']))
+        if '.scala' in files_by_lang:
+            from .languages import scala as scala_lang_module
+            imports_map.update(scala_lang_module.pre_scan_scala(files_by_lang['.scala'], self.parsers['.scala']))
+        if '.sc' in files_by_lang:
+            from .languages import scala as scala_lang_module
+            imports_map.update(scala_lang_module.pre_scan_scala(files_by_lang['.sc'], self.parsers['.sc']))
             
         return imports_map
 

{codegraphcontext-0.1.27 → codegraphcontext-0.1.28}/src/codegraphcontext/tools/languages/python.py

@@ -209,11 +209,27 @@ class PythonTreeSitterParser:
                     for p in params_node.children:
                         arg_text = None
                         if p.type == 'identifier':
+                            # Simple parameter: def foo(x)
                             arg_text = self._get_node_text(p)
                         elif p.type == 'default_parameter':
+                            # Parameter with default: def foo(x=5)
                             name_node = p.child_by_field_name('name')
                             if name_node:
                                 arg_text = self._get_node_text(name_node)
+                        elif p.type == 'typed_parameter':
+                            # Typed parameter: def foo(x: int)
+                            name_node = p.child_by_field_name('name')
+                            if name_node:
+                                arg_text = self._get_node_text(name_node)
+                        elif p.type == 'typed_default_parameter':
+                            # Typed parameter with default: def foo(x: int = 5) or def foo(x: str = typer.Argument(...))
+                            name_node = p.child_by_field_name('name')
+                            if name_node:
+                                arg_text = self._get_node_text(name_node)
+                        elif p.type == 'list_splat_pattern' or p.type == 'dictionary_splat_pattern':
+                            # *args or **kwargs
+                            arg_text = self._get_node_text(p)
+                        
                         if arg_text:
                             args.append(arg_text)
 

codegraphcontext-0.1.28/src/codegraphcontext/tools/languages/scala.py

@@ -0,0 +1,510 @@
+from pathlib import Path
+from typing import Any, Dict, Optional, Tuple, List
+import re
+from codegraphcontext.utils.debug_log import debug_log, info_logger, error_logger, warning_logger
+from codegraphcontext.utils.tree_sitter_manager import execute_query
+
+SCALA_QUERIES = {
+    "functions": """
+        (function_definition
+            name: (identifier) @name
+            parameters: (parameters) @params
+        ) @function_node
+    """,
+    "classes": """
+        [
+            (class_definition name: (identifier) @name)
+            (object_definition name: (identifier) @name)
+            (trait_definition name: (identifier) @name)
+        ] @class
+    """,
+    "imports": """
+        (import_declaration) @import
+    """,
+    "calls": """
+        (call_expression) @call_node
+        (generic_function
+             function: (identifier) @name
+        ) @call_node
+    """,
+    "variables": """
+        (val_definition
+            pattern: (identifier) @name
+        ) @variable
+        
+        (var_definition
+            pattern: (identifier) @name
+        ) @variable
+    """,
+}
+
+class ScalaTreeSitterParser:
+    def __init__(self, generic_parser_wrapper: Any):
+        self.generic_parser_wrapper = generic_parser_wrapper
+        self.language_name = "scala"
+        self.language = generic_parser_wrapper.language
+        self.parser = generic_parser_wrapper.parser
+
+    def parse(self, file_path: Path, is_dependency: bool = False) -> Dict[str, Any]:
+        try:
+            with open(file_path, 'r', encoding='utf-8', errors='ignore') as f:
+                source_code = f.read()
+
+            if not source_code.strip():
+                warning_logger(f"Empty or whitespace-only file: {file_path}")
+                return {
+                    "file_path": str(file_path),
+                    "functions": [],
+                    "classes": [],
+                    "variables": [],
+                    "imports": [],
+                    "function_calls": [],
+                    "is_dependency": is_dependency,
+                    "lang": self.language_name,
+                }
+
+            tree = self.parser.parse(bytes(source_code, "utf8"))
+
+            parsed_functions = []
+            parsed_classes = []
+            parsed_variables = []
+            parsed_imports = []
+            parsed_calls = []
+
+            # Parse variables first for inference
+            if "variables" in SCALA_QUERIES:
+                 try:
+                     results = execute_query(self.language, SCALA_QUERIES["variables"], tree.root_node)
+                     parsed_variables.extend(self._parse_variables(results, source_code, file_path))
+                 except Exception as e:
+                     error_logger(f"Error parsing Scala variables in {file_path}: {e}")
+
+            for capture_name, query in SCALA_QUERIES.items():
+                if capture_name == "variables": continue 
+                
+                try:
+                    results = execute_query(self.language, query, tree.root_node)
+
+                    if capture_name == "functions":
+                        parsed_functions.extend(self._parse_functions(results, source_code, file_path))
+                    elif capture_name == "classes":
+                        parsed_classes.extend(self._parse_classes(results, source_code, file_path))
+                    elif capture_name == "imports":
+                        parsed_imports.extend(self._parse_imports(results, source_code))
+                    elif capture_name == "calls":
+                        parsed_calls.extend(self._parse_calls(results, source_code, file_path, parsed_variables))
+                except Exception as e:
+                    # Some queries might fail if the grammar differs slightly, catch and log
+                    error_logger(f"Error executing Scala query '{capture_name}' in {file_path}: {e}")
+
+            # Separate classes, traits, objects
+            final_classes = []
+            final_traits = []
+            
+            for item in parsed_classes:
+                item_type = item.get('type', 'class')
+                if item_type == 'trait':
+                     final_traits.append(item)
+                elif item_type == 'object':
+                     item['is_object'] = True
+                     final_classes.append(item)
+                else:
+                     final_classes.append(item)
+
+            return {
+                "file_path": str(file_path),
+                "functions": parsed_functions,
+                "classes": final_classes,
+                "traits": final_traits,
+                "variables": parsed_variables,
+                "imports": parsed_imports,
+                "function_calls": parsed_calls,
+                "is_dependency": is_dependency,
+                "lang": self.language_name,
+            }
+
+        except Exception as e:
+            error_logger(f"Error parsing Scala file {file_path}: {e}")
+            return {
+                "file_path": str(file_path),
+                "functions": [],
+                "classes": [],
+                "variables": [],
+                "imports": [],
+                "function_calls": [],
+                "is_dependency": is_dependency,
+                "lang": self.language_name,
+            }
+
+    def _get_parent_context(self, node: Any) -> Tuple[Optional[str], Optional[str], Optional[int]]:
+        curr = node.parent
+        while curr:
+            if curr.type == "function_definition":
+                name_node = curr.child_by_field_name("name")
+                return (
+                    self._get_node_text(name_node) if name_node else None,
+                    curr.type,
+                    curr.start_point[0] + 1,
+                )
+            if curr.type in ("class_definition", "object_definition", "trait_definition"):
+                name_node = curr.child_by_field_name("name")
+                return (
+                    self._get_node_text(name_node) if name_node else None,
+                    curr.type,
+                    curr.start_point[0] + 1,
+                )
+            curr = curr.parent
+        return None, None, None
+
+    def _get_node_text(self, node: Any) -> str:
+        if not node: return ""
+        return node.text.decode("utf-8")
+
+    def _parse_functions(self, captures: list, source_code: str, file_path: Path) -> List[Dict[str, Any]]:
+        functions = []
+        seen_nodes = set()
+
+        for node, capture_name in captures:
+            if capture_name == "function_node":
+                node_id = (node.start_byte, node.end_byte, node.type)
+                if node_id in seen_nodes:
+                    continue
+                seen_nodes.add(node_id)
+                
+                try:
+                    start_line = node.start_point[0] + 1
+                    end_line = node.end_point[0] + 1
+                    
+                    name_node = node.child_by_field_name("name")
+                    if name_node:
+                        func_name = self._get_node_text(name_node)
+                        
+                        params_node = node.child_by_field_name("parameters")
+                        parameters = []
+                        if params_node:
+                            params_text = self._get_node_text(params_node)
+                            parameters = self._extract_parameter_names(params_text)
+
+                        source_text = self._get_node_text(node)
+                        
+                        context_name, context_type, context_line = self._get_parent_context(node)
+
+                        functions.append({
+                            "name": func_name,
+                            "parameters": parameters,
+                            "args": parameters, # 'args' is sometimes used instead of 'parameters'
+                            "line_number": start_line,
+                            "end_line": end_line,
+                            "source": source_text,
+                            "file_path": str(file_path),
+                            "lang": self.language_name,
+                            "context": context_name,
+                            "class_context": context_name if context_type and "class" in str(context_type) or "object" in str(context_type) or "trait" in str(context_type) else None
+                        })
+                        
+                except Exception as e:
+                    error_logger(f"Error parsing function in {file_path}: {e}")
+                    continue
+
+        return functions
+
+    def _parse_classes(self, captures: list, source_code: str, file_path: Path) -> List[Dict[str, Any]]:
+        classes = []
+        seen_nodes = set()
+
+        for node, capture_name in captures:
+            if capture_name == "class":
+                node_id = (node.start_byte, node.end_byte, node.type)
+                if node_id in seen_nodes:
+                    continue
+                seen_nodes.add(node_id)
+                
+                try:
+                    start_line = node.start_point[0] + 1
+                    end_line = node.end_point[0] + 1
+                    
+                    name_node = node.child_by_field_name("name")
+                    if name_node:
+                        class_name = self._get_node_text(name_node)
+                        source_text = self._get_node_text(node)
+                        
+                        bases = []
+                        # Look for extends clause (extends_clause)
+                        # class_definition -> extends_clause -> template_body
+                        extends_clause = None
+                        for child in node.children:
+                            if child.type == "extends_clause": # Might vary by grammar version: 'extends' keyword + types
+                                extends_clause = child
+                                break
+                        
+                        if extends_clause:
+                             for child in extends_clause.children:
+                                 if child.type == "type_identifier" or child.type == "user_type": # specific to scala grammar
+                                     bases.append(self._get_node_text(child))
+                                 elif child.type == "template_invocation":
+                                      # template_invocation -> user_type
+                                      pass 
+
+                        # Note: parsing bases in Scala can be complex (mixins with 'with' keyword).
+                        # Using text based regex backup might be safer for now if tree query is hard.
+                        
+                        classes.append({
+                            "name": class_name,
+                            "line_number": start_line,
+                            "end_line": end_line,
+                            "bases": bases,
+                            "source": source_text,
+                            "file_path": str(file_path),
+                            "lang": self.language_name,
+                            "type": node.type.replace("_definition", "") # class, object, trait
+                        })
+                        
+                except Exception as e:
+                    error_logger(f"Error parsing class in {file_path}: {e}")
+                    continue
+
+        return classes
+
+    def _parse_variables(self, captures: list, source_code: str, file_path: Path) -> List[Dict[str, Any]]:
+        variables = []
+        seen_vars = set()
+        
+        for node, capture_name in captures:
+            if capture_name == "variable":
+                # The capture is on the whole definition (val/var_definition)
+                # But we have @name on the identifier inside pattern.
+                pass
+            if capture_name == "name":
+                # Check parent context
+                if node.parent.type in ("val_definition", "var_definition"):
+                     definition = node.parent
+                     var_name = self._get_node_text(node)
+                     start_line = node.start_point[0] + 1
+                     
+                     start_byte = node.start_byte
+                     if start_byte in seen_vars:
+                         continue
+                     seen_vars.add(start_byte)
+                     
+                     ctx_name, ctx_type, ctx_line = self._get_parent_context(node)
+                     
+                     # Type extraction: look for type_identifier in definition
+                     var_type = "Unknown"
+                     type_node = definition.child_by_field_name("type")
+                     if type_node:
+                         var_type = self._get_node_text(type_node)
+                     else:
+                         # Attempt inference from value
+                         val_node = definition.child_by_field_name("value")
+                         if val_node:
+                             if val_node.type == "instance_expression" or val_node.type == "new_expression":
+                                 # new Calculator() 
+                                 # instance_expression -> new, type_identifier, arguments
+                                 for child in val_node.children:
+                                     if child.type in ("type_identifier", "simple_type", "user_type", "generic_type"):
+                                         var_type = self._get_node_text(child)
+                                         break
+                                     elif child.type == "template_call": # sometimes nested
+                                          for sub in child.children:
+                                              if sub.type in ("type_identifier", "simple_type", "user_type"):
+                                                  var_type = self._get_node_text(sub)
+                                                  break
+                             elif val_node.type == "call_expression":
+                                 # Circle(5.0)
+                                 # wrapper -> function(identifier)
+                                 func = val_node.child_by_field_name("function")
+                                 if func:
+                                     var_type = self._get_node_text(func)
+                                     
+                     variables.append({
+                        "name": var_name,
+                        "type": var_type,
+                        "line_number": start_line,
+                        "file_path": str(file_path),
+                        "lang": self.language_name,
+                        "context": ctx_name,
+                        "class_context": ctx_name if ctx_type and ("class" in str(ctx_type) or "object" in str(ctx_type)) else None
+                     })
+
+        return variables
+
+    def _parse_imports(self, captures: list, source_code: str) -> List[dict]:
+        imports = []
+        
+        for node, capture_name in captures:
+            if capture_name == "import":
+                try:
+                    # Scala imports can be complex: import java.util.{Date, List} or import java.util._
+                    # We will try to extract the base path.
+                    import_text = self._get_node_text(node)
+                    # Simple heuristic: remove 'import ' and handle one level
+                    clean_text = import_text.replace("import ", "").strip()
+                    
+                    # Split logic for multiple imports in one line not handled perfectly here yet
+                    # Just storing the whole text as name for now is better than crashing
+                    
+                    path = clean_text
+                    
+                    imports.append({
+                        "name": path,
+                        "full_import_name": path,
+                        "line_number": node.start_point[0] + 1,
+                        "alias": None,
+                        "context": (None, None),
+                        "lang": self.language_name,
+                        "is_dependency": False,
+                    })
+                except Exception as e:
+                    error_logger(f"Error parsing import: {e}")
+                    continue
+
+        return imports
+
+    def _parse_calls(self, captures: list, source_code: str, file_path: Path, variables: List[Dict] = []) -> List[Dict]:
+        calls = []
+        seen_calls = set()
+        
+        for node, capture_name in captures:
+            if capture_name == "call_node":
+                try:
+                    start_line = node.start_point[0] + 1
+                    
+                    # Heuristic to find name
+                    call_name = "unknown"
+                    full_name = "unknown"
+                    
+                    if node.type == "call_expression":
+                         # function (child 0) arguments (child 1)
+                         func_node = node.child_by_field_name("function")
+                         if func_node:
+                             if func_node.type == "field_expression": # obj.method
+                                 call_name = self._get_node_text(func_node.child_by_field_name("field")) # or name?
+                                 full_name = self._get_node_text(func_node)
+                             elif func_node.type == "identifier":
+                                 call_name = self._get_node_text(func_node)
+                                 full_name = call_name
+                             elif func_node.type == "generic_function":
+                                 # generic_function -> function
+                                 inner = func_node.child_by_field_name("function")
+                                 if inner:
+                                     full_name = self._get_node_text(inner)
+                                     call_name = full_name # simplified
+
+                    if call_name == "unknown":
+                         # Falback to text if simple
+                         # call_name = self._get_node_text(node).split('(')[0]
+                         continue
+
+                    # Avoid duplicates
+                    call_key = f"{call_name}_{start_line}"
+                    if call_key in seen_calls:
+                        continue
+                    seen_calls.add(call_key)
+                    
+                    ctx_name, ctx_type, ctx_line = self._get_parent_context(node)
+
+                    # Inference from variables
+                    inferred_type = None
+                    if "." in full_name:
+                        base_obj = full_name.split(".")[0]
+                        # search for base_obj in variables
+                        # Prefer variables in local context (ctx_name)
+                        
+                        # Simple search: exact name match in same file
+                        # We could improve by checking scope/context, but for now filtering by name is a good start
+                        candidate = None
+                        for v in variables:
+                            if v["name"] == base_obj:
+                                # Check if context matches or is strictly enclosing? 
+                                # For now, just take the first match or last match? 
+                                # Usually last match (closest definition)
+                                candidate = v
+                                if v["context"] == ctx_name:
+                                    break
+                        
+                        if candidate:
+                            inferred_type = candidate["type"]
+                    elif call_name in variables: # Usually not happening as variables is list of dicts
+                         pass
+
+                    calls.append({
+                        "name": call_name,
+                        "full_name": full_name,
+                        "line_number": start_line,
+                        "args": [],
+                        "inferred_obj_type": inferred_type,
+                        "context": (ctx_name, ctx_type, ctx_line),
+                        "class_context": (ctx_name, ctx_line) if ctx_type and ("class" in str(ctx_type) or "object" in str(ctx_type)) else (None, None),
+                        "lang": self.language_name,
+                        "is_dependency": False,
+                    })
+                except Exception as e:
+                    error_logger(f"Error parsing call: {e}")
+                    continue
+
+        return calls
+    
+
+    def _extract_parameter_names(self, params_text: str) -> List[str]:
+        # Simple extraction for Scala: (a: Int, b: String)
+        params = []
+        if not params_text: return params
+        clean = params_text.strip("()")
+        if not clean: return params
+        
+        # Split by comma, respecting generics []
+        # Scala generics use []
+        
+        # TODO: Reuse regex/parsing logic from other parsers or write simple one
+        # For now, simplistic split
+        parts = clean.split(',')
+        for p in parts:
+            # removing type: 'name: Type'
+            if ':' in p:
+                name = p.split(':')[0].strip()
+                # Remove modifiers like 'implicit', 'override', etc.
+                tokens = name.split()
+                if tokens:
+                    params.append(tokens[-1])
+            else:
+                 # maybe just name?
+                 params.append(p.strip())
+        return params
+
+
+def pre_scan_scala(files: list[Path], parser_wrapper) -> dict:
+    name_to_files = {}
+    
+    for file_path in files:
+        try:
+            with open(file_path, 'r', encoding='utf-8', errors='ignore') as f:
+                content = f.read()
+            
+            # package matches
+            package_name = ""
+            pkg_match = re.search(r'^\s*package\s+([\w\.]+)', content, re.MULTILINE)
+            if pkg_match:
+                package_name = pkg_match.group(1)
+            
+            # class/object/trait matches
+            class_matches = re.finditer(r'\b(class|object|trait)\s+(\w+)', content)
+            for match in class_matches:
+                name = match.group(2)
+                type_ = match.group(1)
+                
+                # Simple mapping
+                if name not in name_to_files:
+                    name_to_files[name] = []
+                name_to_files[name].append(str(file_path))
+                
+                # FQN mapping
+                if package_name:
+                    fqn = f"{package_name}.{name}"
+                    if fqn not in name_to_files:
+                        name_to_files[fqn] = []
+                    name_to_files[fqn].append(str(file_path))
+                
+        except Exception as e:
+            error_logger(f"Error pre-scanning Scala file {file_path}: {e}")
+            
+    return name_to_files

codegraphcontext-0.1.28/src/codegraphcontext/tools/query_tool_languages/scala_toolkit.py

@@ -0,0 +1,5 @@
+class ScalaToolkit:
+    """Template placeholder for future implementation."""
+
+    def get_cypher_query(query: str) -> str:
+        raise NotImplementedError("AdvancedLanguageQuery is not implemented yet.")

{codegraphcontext-0.1.27 → codegraphcontext-0.1.28}/src/codegraphcontext/utils/tree_sitter_manager.py

@@ -46,6 +46,8 @@ LANGUAGE_ALIASES = {
     "rust": "rust",
     "kt": "kotlin",
     "kotlin": "kotlin",
+    "scala": "scala",
+    ".scala": "scala",
 }
 
 

{codegraphcontext-0.1.27 → codegraphcontext-0.1.28/src/codegraphcontext.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: codegraphcontext
-Version: 0.1.27
+Version: 0.1.28
 Summary: An MCP server that indexes local code into a graph database to provide context to AI assistants.
 Author-email: Shashank Shekhar Singh <shashankshekharsingh1205@gmail.com>
 License: MIT License
@@ -91,7 +91,7 @@ A powerful **MCP server** and **CLI toolkit** that indexes local code into a gra
 ![Using the MCP server](https://github.com/Shashankss1205/CodeGraphContext/blob/main/images/Usecase.gif)
 
 ## Project Details
-- **Version:** 0.1.27
+- **Version:** 0.1.28
 - **Authors:** Shashank Shekhar Singh <shashankshekharsingh1205@gmail.com>
 - **License:** MIT License (See [LICENSE](LICENSE) for details)
 - **Website:** [CodeGraphContext](http://codegraphcontext.vercel.app/)

{codegraphcontext-0.1.27 → codegraphcontext-0.1.28}/src/codegraphcontext.egg-info/SOURCES.txt

@@ -41,6 +41,7 @@ src/codegraphcontext/tools/languages/php.py
 src/codegraphcontext/tools/languages/python.py
 src/codegraphcontext/tools/languages/ruby.py
 src/codegraphcontext/tools/languages/rust.py
+src/codegraphcontext/tools/languages/scala.py
 src/codegraphcontext/tools/languages/typescript.py
 src/codegraphcontext/tools/query_tool_languages/c_toolkit.py
 src/codegraphcontext/tools/query_tool_languages/cpp_toolkit.py
@@ -51,6 +52,7 @@ src/codegraphcontext/tools/query_tool_languages/javascript_toolkit.py
 src/codegraphcontext/tools/query_tool_languages/python_toolkit.py
 src/codegraphcontext/tools/query_tool_languages/ruby_toolkit.py
 src/codegraphcontext/tools/query_tool_languages/rust_toolkit.py
+src/codegraphcontext/tools/query_tool_languages/scala_toolkit.py
 src/codegraphcontext/tools/query_tool_languages/typescript_toolkit.py
 src/codegraphcontext/utils/debug_log.py
 src/codegraphcontext/utils/tree_sitter_manager.py