codegraphcontext 0.4.4__tar.gz → 0.4.5__tar.gz

{codegraphcontext-0.4.4/src/codegraphcontext.egg-info → codegraphcontext-0.4.5}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: codegraphcontext
-Version: 0.4.4
+Version: 0.4.5
 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
@@ -52,8 +52,9 @@ Requires-Dist: nbconvert>=7.16.6
 Requires-Dist: pathspec>=0.12.1
 Requires-Dist: falkordb>=0.1.0
 Requires-Dist: requests>=2.28.0
+Requires-Dist: protobuf<3.21,>=3.20
 Requires-Dist: falkordblite>=0.1.0; sys_platform != "win32" and python_version >= "3.12"
-Requires-Dist: kuzu>=0.4.0; sys_platform == "win32" or (sys_platform != "win32" and python_version >= "3.10" and python_version < "3.12")
+Requires-Dist: real_ladybug; sys_platform == "win32" or (sys_platform != "win32" and python_version >= "3.10")
 Requires-Dist: fastapi>=0.100.0
 Requires-Dist: uvicorn>=0.22.0
 Provides-Extra: parsing
@@ -165,7 +166,7 @@ A powerful **MCP server** and **CLI toolkit** that indexes local code into a gra
 ---
 
 ## Project Details
-- **Version:** 0.4.4
+- **Version:** 0.4.5
 - **Authors:** Shashank Shekhar Singh <shashankshekharsingh1205@gmail.com>
 - **License:** MIT License (See [LICENSE](LICENSE) for details)
 - **Website:** [CodeGraphContext](http://codegraphcontext.vercel.app/)
@@ -228,7 +229,7 @@ CodeGraphContext supports multiple graph database backends to suit your environm
 | **Setup** | Zero-config / Embedded | Zero-config / In-process | Docker / External |
 | **Platform** | **All (Windows Native, macOS, Linux)** | Unix-only (Linux/macOS/WSL) | All Platforms |
 | **Use Case** | Desktop, IDE, Local development | Specialized Unix development | Enterprise, Massive graphs |
-| **Requirement**| `pip install kuzu` | `pip install falkordblite` | Neo4j Server / Docker |
+| **Requirement**| `pip install real_ladybug` | `pip install falkordblite` | Neo4j Server / Docker |
 | **Speed** | ⚡ Extremely Fast | ⚡ Fast | 🚀 Scalable |
 | **Persistence**| Yes (to disk) | Yes (to disk) | Yes (to disk) |
 
@@ -339,7 +340,7 @@ Use CodeGraphContext as an **MCP server** for AI assistants:
 
 2.  **Database Setup (Automatic)**
     
-    - **KùzuDB (default on Windows):** Runs natively on Windows, macOS, and Linux. On Windows it is the usual embedded choice; `pip install kuzu` if needed.
+    - **KùzuDB (default on Windows):** Runs natively on Windows, macOS, and Linux. On Windows it is the usual embedded choice; `pip install real_ladybug` if needed.
     - **FalkorDB Lite (typical default on Unix):** When Python 3.12+ and `falkordblite` are available on Unix/macOS/WSL, the embedded backend prefers FalkorDB Lite; otherwise KùzuDB is used.
     - **Neo4j (Alternative):** To use Neo4j instead, or if you prefer a server-based approach, run: `cgc neo4j setup`
 

{codegraphcontext-0.4.4 → codegraphcontext-0.4.5}/README.md

@@ -97,7 +97,7 @@ A powerful **MCP server** and **CLI toolkit** that indexes local code into a gra
 ---
 
 ## Project Details
-- **Version:** 0.4.4
+- **Version:** 0.4.5
 - **Authors:** Shashank Shekhar Singh <shashankshekharsingh1205@gmail.com>
 - **License:** MIT License (See [LICENSE](LICENSE) for details)
 - **Website:** [CodeGraphContext](http://codegraphcontext.vercel.app/)
@@ -160,7 +160,7 @@ CodeGraphContext supports multiple graph database backends to suit your environm
 | **Setup** | Zero-config / Embedded | Zero-config / In-process | Docker / External |
 | **Platform** | **All (Windows Native, macOS, Linux)** | Unix-only (Linux/macOS/WSL) | All Platforms |
 | **Use Case** | Desktop, IDE, Local development | Specialized Unix development | Enterprise, Massive graphs |
-| **Requirement**| `pip install kuzu` | `pip install falkordblite` | Neo4j Server / Docker |
+| **Requirement**| `pip install real_ladybug` | `pip install falkordblite` | Neo4j Server / Docker |
 | **Speed** | ⚡ Extremely Fast | ⚡ Fast | 🚀 Scalable |
 | **Persistence**| Yes (to disk) | Yes (to disk) | Yes (to disk) |
 
@@ -271,7 +271,7 @@ Use CodeGraphContext as an **MCP server** for AI assistants:
 
 2.  **Database Setup (Automatic)**
     
-    - **KùzuDB (default on Windows):** Runs natively on Windows, macOS, and Linux. On Windows it is the usual embedded choice; `pip install kuzu` if needed.
+    - **KùzuDB (default on Windows):** Runs natively on Windows, macOS, and Linux. On Windows it is the usual embedded choice; `pip install real_ladybug` if needed.
     - **FalkorDB Lite (typical default on Unix):** When Python 3.12+ and `falkordblite` are available on Unix/macOS/WSL, the embedded backend prefers FalkorDB Lite; otherwise KùzuDB is used.
     - **Neo4j (Alternative):** To use Neo4j instead, or if you prefer a server-based approach, run: `cgc neo4j setup`
 

{codegraphcontext-0.4.4 → codegraphcontext-0.4.5}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "codegraphcontext"
-version = "0.4.4"
+version = "0.4.5"
 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"
@@ -31,8 +31,9 @@ dependencies = [
     "pathspec>=0.12.1",
     "falkordb>=0.1.0",
     "requests>=2.28.0",
+    "protobuf>=3.20,<3.21",
     "falkordblite>=0.1.0; sys_platform != 'win32' and python_version >= '3.12'",
-    "kuzu>=0.4.0; sys_platform == 'win32' or (sys_platform != 'win32' and python_version >= '3.10' and python_version < '3.12')",
+    "real_ladybug; sys_platform == 'win32' or (sys_platform != 'win32' and python_version >= '3.10')",
     "fastapi>=0.100.0",
     "uvicorn>=0.22.0"
 ]

{codegraphcontext-0.4.4 → codegraphcontext-0.4.5}/src/codegraphcontext/cli/cli_helpers.py

@@ -721,19 +721,31 @@ def watch_helper(path: str, context: Optional[str] = None):
         # Add the directory to watch
         if is_indexed:
             console.print("[green]✓[/green] Already indexed (no initial scan needed)")
-            watcher.watch_directory(str(path_obj), perform_initial_scan=False)
+            watcher.watch_directory(
+                str(path_obj),
+                perform_initial_scan=False,
+                cgcignore_path=ctx.cgcignore_path,
+            )
         else:
             console.print("[yellow]⚠[/yellow]  Not indexed yet. Performing initial scan...")
             
             # Index the repository first (like MCP does)
             async def do_index():
-                await graph_builder.build_graph_from_path_async(path_obj, is_dependency=False)
+                await graph_builder.build_graph_from_path_async(
+                    path_obj,
+                    is_dependency=False,
+                    cgcignore_path=ctx.cgcignore_path,
+                )
             
             asyncio.run(do_index())
             console.print("[green]✓[/green] Initial scan complete")
             
             # Now start watching (without another scan)
-            watcher.watch_directory(str(path_obj), perform_initial_scan=False)
+            watcher.watch_directory(
+                str(path_obj),
+                perform_initial_scan=False,
+                cgcignore_path=ctx.cgcignore_path,
+            )
         
         console.print("[bold green]👀 Monitoring for file changes...[/bold green] (Press Ctrl+C to stop)")
         console.print("[dim]💡 Tip: Open a new terminal window to continue working[/dim]\n")

{codegraphcontext-0.4.4 → codegraphcontext-0.4.5}/src/codegraphcontext/cli/main.py

@@ -854,11 +854,11 @@ def doctor():
         elif default_db == "kuzudb":
             from importlib.util import find_spec
 
-            if find_spec("kuzu") is not None:
+            if find_spec("real_ladybug") is not None:
                 console.print(f"   [green]✓[/green] KuzuDB is installed")
             else:
                 console.print(f"   [red]✗[/red] KuzuDB is not installed")
-                console.print(f"       Run: pip install kuzu")
+                console.print(f"       Run: pip install real_ladybug")
                 all_checks_passed = False
         else:
             # FalkorDB

{codegraphcontext-0.4.4 → codegraphcontext-0.4.5}/src/codegraphcontext/core/__init__.py

@@ -22,7 +22,7 @@ import importlib.util
 def _is_kuzudb_available() -> bool:
     """Check if KùzuDB is installed."""
     try:
-        return importlib.util.find_spec("kuzu") is not None
+        return importlib.util.find_spec("real_ladybug") is not None
     except ImportError:
         return False
 
@@ -70,7 +70,7 @@ def get_database_manager(db_path: Optional[str] = None) -> Union['DatabaseManage
         db_type = db_type.lower()
         if db_type == 'kuzudb':
             if not _is_kuzudb_available():
-                raise ValueError("Database set to 'kuzudb' but Kùzu is not installed.\nRun 'pip install kuzu'")
+                raise ValueError("Database set to 'kuzudb' but Kùzu is not installed.\nRun 'pip install real_ladybug'")
             from .database_kuzu import KuzuDBManager
             info_logger(f"Using KùzuDB (explicit) at {db_path or 'default path'}")
             return KuzuDBManager(db_path=db_path)
@@ -147,7 +147,7 @@ def get_database_manager(db_path: Optional[str] = None) -> Union['DatabaseManage
         return DatabaseManager()
 
     error_msg = "No database backend available.\n"
-    error_msg += "Recommended: Install KùzuDB for zero-config ('pip install kuzu')\n"
+    error_msg += "Recommended: Install KùzuDB for zero-config ('pip install real_ladybug')\n"
 
     if platform.system() != "Windows":
         error_msg += "Alternative: Install FalkorDB Lite ('pip install falkordblite')\n"

{codegraphcontext-0.4.4 → codegraphcontext-0.4.5}/src/codegraphcontext/core/database_kuzu.py

@@ -66,7 +66,7 @@ class KuzuDBManager:
         if self._conn is None:
             with self._lock:
                 if self._conn is None:
-                    import kuzu
+                    import real_ladybug as kuzu
                     max_retries = 5
                     for attempt in range(max_retries):
                         try:
@@ -77,7 +77,7 @@ class KuzuDBManager:
                             info_logger("KùzuDB connection established and schema verified")
                             break
                         except ImportError:
-                            error_logger("KùzuDB is not installed. Run 'pip install kuzu'")
+                            error_logger("KùzuDB is not installed. Run 'pip install real_ladybug'")
                             raise ValueError("KùzuDB missing.")
                         except Exception as e:
                             if "lock" in str(e).lower() and attempt < max_retries - 1:
@@ -156,6 +156,26 @@ class KuzuDBManager:
                     warning_logger(f"Kuzu Schema Rel Error ({table_name}): {e}")
                     debug_log(f"Kuzu Schema Rel Error ({table_name}): {e}")
 
+        self._run_schema_migrations()
+
+    def _run_schema_migrations(self):
+        """Add columns introduced after older local Kùzu databases were created."""
+        migrations = [
+            ("Module", "full_import_name", "STRING"),
+            ("IMPORTS", "full_import_name", "STRING"),
+            ("IMPORTS", "imported_name", "STRING"),
+        ]
+
+        for table_name, column_name, column_type in migrations:
+            try:
+                self._conn.execute(f"ALTER TABLE `{table_name}` ADD {column_name} {column_type}")
+            except Exception as e:
+                err = str(e).lower()
+                if "already exists" in err or "duplicate" in err:
+                    continue
+                warning_logger(f"Kuzu Schema Migration Error ({table_name}.{column_name}): {e}")
+                debug_log(f"Kuzu Schema Migration Error ({table_name}.{column_name}): {e}")
+
     def close_driver(self):
         """Closes the connection."""
         if self._conn is not None:
@@ -188,10 +208,10 @@ class KuzuDBManager:
     @staticmethod
     def test_connection(db_path: str = None) -> Tuple[bool, Optional[str]]:
         try:
-            import kuzu
+            import real_ladybug as kuzu
             return True, None
         except ImportError:
-            return False, "KùzuDB is not installed. Run 'pip install kuzu'"
+            return False, "KùzuDB is not installed. Run 'pip install real_ladybug'"
 
 class KuzuDriverWrapper:
     def __init__(self, conn):

{codegraphcontext-0.4.4 → codegraphcontext-0.4.5}/src/codegraphcontext/core/watcher.py

@@ -10,9 +10,13 @@ from watchdog.observers import Observer
 from watchdog.events import FileSystemEventHandler
 
 if typing.TYPE_CHECKING:
+    from pathspec import PathSpec
     from codegraphcontext.tools.graph_builder import GraphBuilder
     from codegraphcontext.core.jobs import JobManager
 
+from codegraphcontext.core.cgcignore import build_ignore_spec
+from codegraphcontext.tools.indexing.constants import DEFAULT_IGNORE_PATTERNS
+from codegraphcontext.cli.config_manager import get_config_value
 from codegraphcontext.utils.debug_log import debug_log, info_logger, error_logger, warning_logger
 
 class RepositoryEventHandler(FileSystemEventHandler):
@@ -23,7 +27,15 @@ class RepositoryEventHandler(FileSystemEventHandler):
     to build a baseline and then uses this cached state to perform efficient
     updates when files are changed, created, or deleted.
     """
-    def __init__(self, graph_builder: "GraphBuilder", repo_path: Path, debounce_interval=2.0, perform_initial_scan: bool = True):
+    def __init__(
+        self,
+        graph_builder: "GraphBuilder",
+        repo_path: Path,
+        debounce_interval=2.0,
+        perform_initial_scan: bool = True,
+        cgcignore_path: str = None,
+        ignore_spec: "PathSpec" = None,
+    ):
         """
         Initializes the event handler.
 
@@ -32,12 +44,17 @@ class RepositoryEventHandler(FileSystemEventHandler):
             repo_path: The absolute path to the repository directory to watch.
             debounce_interval: The time in seconds to wait for more changes before processing an event.
             perform_initial_scan: Whether to perform an initial scan of the repository.
+            cgcignore_path: Optional explicit .cgcignore path from the active context.
+            ignore_spec: Optional precompiled ignore spec, useful for tests.
         """
         super().__init__()
         self.graph_builder = graph_builder
-        self.repo_path = repo_path
+        self.repo_path = repo_path.resolve()
         self.debounce_interval = debounce_interval
         self.timers = {} # A dictionary to manage debounce timers for file paths.
+        self.ignore_root = self.repo_path
+        self.ignore_spec = ignore_spec
+        self._load_ignore_spec(cgcignore_path)
         
         # Caches for the repository's state.
         self.all_file_data = []
@@ -47,11 +64,65 @@ class RepositoryEventHandler(FileSystemEventHandler):
         if perform_initial_scan:
             self._initial_scan()
 
+    def _load_ignore_spec(self, cgcignore_path: str = None) -> None:
+        """Load .cgcignore rules using the same defaults as repository indexing."""
+        if self.ignore_spec is not None:
+            return
+        try:
+            self.ignore_spec, resolved_cgcignore = build_ignore_spec(
+                ignore_root=self.ignore_root,
+                default_patterns=DEFAULT_IGNORE_PATTERNS,
+                explicit_path=cgcignore_path,
+            )
+            if resolved_cgcignore:
+                debug_log(
+                    f"Watcher using .cgcignore at {resolved_cgcignore} "
+                    f"(filtering relative to {self.ignore_root})"
+                )
+        except OSError as e:
+            self.ignore_spec = None
+            warning_logger(f"Could not load/create watcher .cgcignore: {e}")
+
+    def _should_ignore(self, path: str | Path) -> bool:
+        """Return True when a path is excluded by .cgcignore or IGNORE_DIRS."""
+        path_obj = Path(path).resolve()
+        ignore_root = getattr(self, "ignore_root", getattr(self, "repo_path", None))
+
+        ignore_dirs_str = get_config_value("IGNORE_DIRS") or ""
+        if ignore_dirs_str and ignore_root:
+            ignore_dirs = {d.strip().lower() for d in ignore_dirs_str.split(",") if d.strip()}
+            try:
+                parts = {p.lower() for p in path_obj.relative_to(ignore_root).parent.parts}
+                if parts.intersection(ignore_dirs):
+                    return True
+            except ValueError:
+                pass
+
+        ignore_spec = getattr(self, "ignore_spec", None)
+        if not ignore_spec or not ignore_root:
+            return False
+
+        try:
+            rel_path = path_obj.relative_to(ignore_root).as_posix()
+        except ValueError:
+            return False
+        return ignore_spec.match_file(rel_path)
+
+    def _is_supported_code_file(self, path: str | Path) -> bool:
+        path_obj = Path(path)
+        return path_obj.is_file() and path_obj.suffix in self.graph_builder.parsers and not self._should_ignore(path_obj)
+
+    def _iter_supported_files(self) -> list[Path]:
+        supported_extensions = self.graph_builder.parsers.keys()
+        return [
+            f for f in self.repo_path.rglob("*")
+            if f.is_file() and f.suffix in supported_extensions and not self._should_ignore(f)
+        ]
+
     def _initial_scan(self):
         """Scans the entire repository, parses all files, and builds the initial graph."""
         info_logger(f"Performing initial scan for watcher: {self.repo_path}")
-        supported_extensions = self.graph_builder.parsers.keys()
-        all_files = [f for f in self.repo_path.rglob("*") if f.is_file() and f.suffix in supported_extensions]
+        all_files = self._iter_supported_files()
         
         # 1. Pre-scan all files to get a global map of where every symbol is defined.
         self.imports_map = self.graph_builder.pre_scan_imports(all_files)
@@ -126,6 +197,10 @@ class RepositoryEventHandler(FileSystemEventHandler):
         """
         info_logger(f"File change detected (incremental update): {event_path_str}")
         changed_path = Path(event_path_str)
+        if self._should_ignore(changed_path):
+            debug_log(f"Ignored watcher update based on .cgcignore: {changed_path}")
+            return
+
         changed_path_str = str(changed_path.resolve())
         supported_extensions = self.graph_builder.parsers.keys()
 
@@ -160,7 +235,7 @@ class RepositoryEventHandler(FileSystemEventHandler):
         subset_file_data = []
         for path_str in affected_paths:
             p = Path(path_str)
-            if p.exists() and p.suffix in supported_extensions:
+            if p.exists() and p.suffix in supported_extensions and not self._should_ignore(p):
                 parsed = self.graph_builder.parse_file(self.repo_path, p)
                 if "error" not in parsed:
                     subset_file_data.append(parsed)
@@ -177,22 +252,22 @@ class RepositoryEventHandler(FileSystemEventHandler):
 
     # The following methods are called by the watchdog observer when a file event occurs.
     def on_created(self, event):
-        if not event.is_directory and Path(event.src_path).suffix in self.graph_builder.parsers:
+        if not event.is_directory and self._is_supported_code_file(event.src_path):
             self._debounce(event.src_path, lambda: self._handle_modification(event.src_path))
 
     def on_modified(self, event):
-        if not event.is_directory and Path(event.src_path).suffix in self.graph_builder.parsers:
+        if not event.is_directory and self._is_supported_code_file(event.src_path):
             self._debounce(event.src_path, lambda: self._handle_modification(event.src_path))
 
     def on_deleted(self, event):
-        if not event.is_directory and Path(event.src_path).suffix in self.graph_builder.parsers:
+        if not event.is_directory and Path(event.src_path).suffix in self.graph_builder.parsers and not self._should_ignore(event.src_path):
             self._debounce(event.src_path, lambda: self._handle_modification(event.src_path))
 
     def on_moved(self, event):
         if not event.is_directory:
-            if Path(event.src_path).suffix in self.graph_builder.parsers:
+            if Path(event.src_path).suffix in self.graph_builder.parsers and not self._should_ignore(event.src_path):
                 self._debounce(event.src_path, lambda: self._handle_modification(event.src_path))
-            if Path(event.dest_path).suffix in self.graph_builder.parsers:
+            if Path(event.dest_path).suffix in self.graph_builder.parsers and not self._should_ignore(event.dest_path):
                 self._debounce(event.dest_path, lambda: self._handle_modification(event.dest_path))
 
 
@@ -207,7 +282,7 @@ class CodeWatcher:
         self.watched_paths = set() # Keep track of paths already being watched.
         self.watches = {} # Store watch objects to allow unscheduling
 
-    def watch_directory(self, path: str, perform_initial_scan: bool = True):
+    def watch_directory(self, path: str, perform_initial_scan: bool = True, cgcignore_path: str = None):
         """Schedules a directory to be watched for changes."""
         path_obj = Path(path).resolve()
         path_str = str(path_obj)
@@ -217,7 +292,12 @@ class CodeWatcher:
             return {"message": f"Path already being watched: {path_str}"}
         
         # Create a new, dedicated event handler for this specific repository path.
-        event_handler = RepositoryEventHandler(self.graph_builder, path_obj, perform_initial_scan=perform_initial_scan)
+        event_handler = RepositoryEventHandler(
+            self.graph_builder,
+            path_obj,
+            perform_initial_scan=perform_initial_scan,
+            cgcignore_path=cgcignore_path,
+        )
         
         watch = self.observer.schedule(event_handler, path_str, recursive=True)
         self.watches[path_str] = watch

{codegraphcontext-0.4.4 → codegraphcontext-0.4.5}/src/codegraphcontext/tools/code_finder.py

@@ -864,6 +864,42 @@ class CodeFinder:
         """Find all dependencies and dependents of a module"""
         with self.driver.session() as session:
             repo_filter = "AND file.path STARTS WITH $repo_path" if repo_path else ""
+            backend = getattr(self.db_manager, "get_backend_type", lambda: "")()
+
+            # KuzuDB is stricter about OPTIONAL MATCH variable scoping, and nested
+            # repository ownership is already represented in the file path.
+            if backend == "kuzudb":
+                importers_result = session.run(f"""
+                    MATCH (file:File)-[imp:IMPORTS]->(module:Module)
+                    WHERE (module.name = $module_name OR module.full_import_name CONTAINS $module_name) {repo_filter}
+                    RETURN DISTINCT
+                        file.path as importer_file_path,
+                        imp.line_number as import_line_number,
+                        file.is_dependency as file_is_dependency,
+                        '' as repository_name
+                    ORDER BY file_is_dependency ASC, importer_file_path
+                    LIMIT 50
+                """, module_name=module_name, repo_path=repo_path)
+
+                imports_result = session.run(f"""
+                    MATCH (file:File)-[:IMPORTS]->(target_module:Module)
+                    WHERE (target_module.name = $module_name OR target_module.full_import_name CONTAINS $module_name) {repo_filter}
+                    WITH file, target_module
+                    MATCH (file)-[imp:IMPORTS]->(other_module:Module)
+                    WHERE other_module.name <> target_module.name
+                    RETURN DISTINCT
+                        other_module.name as imported_module,
+                        imp.alias as import_alias
+                    ORDER BY imported_module
+                    LIMIT 50
+                """, module_name=module_name, repo_path=repo_path)
+
+                return {
+                    "module_name": module_name,
+                    "importers": importers_result.data(),
+                    "imports": imports_result.data()
+                }
+
             # Find files that import this module (who imports this module)
             importers_result = session.run(f"""
                 MATCH (file:File)-[imp:IMPORTS]->(module:Module {{name: $module_name}})

{codegraphcontext-0.4.4 → codegraphcontext-0.4.5}/src/codegraphcontext/tools/indexing/persistence/writer.py

@@ -278,19 +278,28 @@ class GraphWriter:
             js_imports = []
             other_imports = []
             for imp in file_data.get("imports", []):
-                if lang == "javascript":
+                if lang in {"javascript", "typescript", "tsx"}:
                     module_name = imp.get("source")
                     if module_name:
                         js_imports.append(
                             {
                                 "module_name": module_name,
                                 "imported_name": imp.get("name", "*"),
-                                "alias": imp.get("alias"),
-                                "line_number": imp.get("line_number"),
+                                "alias": imp.get("alias") or "",
+                                "line_number": imp.get("line_number") or 0,
                             }
                         )
                 else:
-                    other_imports.append(imp)
+                    module_name = imp.get("name") or imp.get("source") or imp.get("full_import_name")
+                    if module_name:
+                        other_imports.append(
+                            {
+                                "name": module_name,
+                                "alias": imp.get("alias") or "",
+                                "full_import_name": imp.get("full_import_name") or module_name,
+                                "line_number": imp.get("line_number") or 0,
+                            }
+                        )
 
             if js_imports:
                 session.run(

{codegraphcontext-0.4.4 → codegraphcontext-0.4.5}/src/codegraphcontext/tools/indexing/resolution/calls.py

@@ -20,6 +20,7 @@ def resolve_function_call(
     if called_name in __builtins__:
         return None
 
+    resolved_called_name = called_name
     resolved_path = None
     full_call = call.get("full_name", called_name)
     base_obj = full_call.split(".")[0] if "." in full_call else None
@@ -43,6 +44,14 @@ def resolve_function_call(
 
     if not resolved_path:
         possible_paths = imports_map.get(lookup_name, [])
+        if not possible_paths and lookup_name in local_imports:
+            imported_name = local_imports[lookup_name]
+            alias_paths = imports_map.get(imported_name, [])
+            if alias_paths:
+                possible_paths = alias_paths
+                lookup_name = imported_name
+                if called_name == base_obj or called_name == call["name"]:
+                    resolved_called_name = imported_name
         if len(possible_paths) == 1:
             resolved_path = possible_paths[0]
         elif len(possible_paths) > 1:
@@ -74,8 +83,8 @@ def resolve_function_call(
         if called_name in local_names:
             resolved_path = caller_file_path
             is_unresolved_external = False
-        elif called_name in imports_map and imports_map[called_name]:
-            candidates = imports_map[called_name]
+        elif resolved_called_name in imports_map and imports_map[resolved_called_name]:
+            candidates = imports_map[resolved_called_name]
             for path in candidates:
                 for imp_name in local_imports.values():
                     if imp_name.replace(".", "/") in path:
@@ -100,7 +109,7 @@ def resolve_function_call(
             "caller_name": caller_name,
             "caller_file_path": caller_file_path,
             "caller_line_number": caller_line_number,
-            "called_name": called_name,
+            "called_name": resolved_called_name,
             "called_file_path": resolved_path,
             "line_number": call["line_number"],
             "args": call.get("args", []),
@@ -109,7 +118,7 @@ def resolve_function_call(
     return {
         "type": "file",
         "caller_file_path": caller_file_path,
-        "called_name": called_name,
+        "called_name": resolved_called_name,
         "called_file_path": resolved_path,
         "line_number": call["line_number"],
         "args": call.get("args", []),