refactor(sdk): merge dependency methods and add depth parameter

- Make dependencies a proxy property with optional depth parameter
- Default to all dependencies (depth=None)
- Support direct dependencies via depth=1
- Maintain backward compatibility
- Update move_symbol_to_file to use direct dependencies

Co-Authored-By: [email protected] <[email protected]>

Author: devin-ai-integration[bot]

src/codegen/sdk/core/interfaces/importable.py

@@ -1,5 +1,5 @@
 import logging
-from typing import TYPE_CHECKING, Generic, Self, TypeVar, Union
+from typing import TYPE_CHECKING, Generic, Optional, Self, TypeVar, Union
 
 from tree_sitter import Node as TSNode
 
@@ -45,20 +45,41 @@ def __init__(self, ts_node: TSNode, file_node_id: NodeId, G: "CodebaseGraph", pa
     def dependencies(self) -> list[Union["Symbol", "Import"]]:
         """Returns a list of symbols that this symbol depends on.
 
-        Returns a list of symbols (including imports) that this symbol directly depends on.
-        The returned list is sorted by file location for consistent ordering.
+        This property returns all dependencies (direct and indirect).
+        For finer control over dependency depth, use get_dependencies_to_depth().
 
         Returns:
-            list[Union[Symbol, Import]]: A list of symbols and imports that this symbol directly depends on,
+            list[Union[Symbol, Import]]: A list of symbols and imports that this symbol depends on,
                 sorted by file location.
         """
-        return self.get_dependencies(UsageType.DIRECT)
+        return self.get_dependencies_to_depth()
+
+    @reader(cache=False)
+    def get_dependencies_to_depth(self, depth: Optional[int] = None) -> list[Union["Symbol", "Import"]]:
+        """Returns a list of symbols that this symbol depends on up to a specified depth.
+
+        Args:
+            depth: Optional[int], maximum depth to traverse in the dependency graph.
+                  None means unlimited depth (all dependencies).
+                  1 means direct dependencies only.
+                  Default is None (all dependencies).
+
+        Returns:
+            list[Union[Symbol, Import]]: A list of symbols and imports that this symbol depends on,
+                sorted by file location.
+        """
+        if depth == 1:
+            return self.get_dependencies(UsageType.DIRECT)
+        return self._get_all_dependencies(depth)
 
     @reader(cache=False)
     @noapidoc
     def get_dependencies(self, usage_types: UsageType) -> list[Union["Symbol", "Import"]]:
-        """Returns Symbols and Importsthat this symbol depends on.
-
+        """Internal method for getting dependencies by usage type.
+        
+        This is kept for backward compatibility and internal use.
+        New code should use the dependencies property or get_dependencies_to_depth method.
+        
         Opposite of `usages`
         """
         avoid = set(self.descendant_symbols)
@@ -113,6 +134,34 @@ def _remove_internal_edges(self, edge_type: EdgeType | None = None) -> None:
         for v in self.G.successors(self.node_id, edge_type=edge_type):
             self.G.remove_edge(self.node_id, v.node_id, edge_type=edge_type)
 
+    @reader(cache=False)
+    @noapidoc
+    def _get_all_dependencies(self, max_depth: Optional[int] = None) -> list[Union["Symbol", "Import"]]:
+        """Gets all dependencies up to specified depth.
+        
+        Internal implementation of depth-based dependency traversal.
+        """
+        dependency_map: dict[Self, list[Union["Symbol", "Import"]]] = {}
+        current_depth = 1
+        
+        def _collect_deps(symbol: Self, depth: int) -> None:
+            if depth > max_depth if max_depth is not None else False:
+                return
+                
+            direct_deps = symbol.get_dependencies(UsageType.DIRECT)
+            if symbol not in dependency_map:
+                dependency_map[symbol] = direct_deps
+                
+            for dep in direct_deps:
+                if isinstance(dep, Symbol):
+                    _collect_deps(dep, depth + 1)
+        
+        _collect_deps(self, current_depth)
+        all_deps = []
+        for deps in dependency_map.values():
+            all_deps.extend(deps)
+        return sort_editables(list(set(all_deps)), by_file=True)
+
     @property
     @noapidoc
     def descendant_symbols(self) -> list[Self]:

src/codegen/sdk/core/symbol.py

@@ -312,7 +312,7 @@ def _move_to_file(
 
         if include_dependencies:
             # =====[ Move over dependencies recursively ]=====
-            for dep in self.dependencies:
+            for dep in self.get_dependencies_to_depth(depth=1):  # Only get direct dependencies
                 if dep in encountered_symbols:
                     continue
 
@@ -333,7 +333,7 @@ def _move_to_file(
                     else:
                         file.add_import_from_import_string(dep.source)
         else:
-            for dep in self.dependencies:
+            for dep in self.get_dependencies_to_depth(depth=1):  # Only get direct dependencies
                 # =====[ Symbols - add back edge ]=====
                 if isinstance(dep, Symbol) and dep.is_top_level:
                     file.add_symbol_import(symbol=dep, alias=dep.name, import_type=ImportType.NAMED_EXPORT, is_type_import=False)

tests/unit/codegen/sdk/core/interfaces/test_importable_dependencies.py

@@ -0,0 +1,151 @@
+from codegen.sdk.codebase.factory.get_session import get_codebase_session
+from codegen.sdk.core.dataclasses.usage import UsageType
+from codegen.sdk.enums import ProgrammingLanguage
+
+
+def test_dependencies_with_depth(tmpdir):
+    """Test that dependencies property and get_dependencies_to_depth respect depth parameter."""
+    py_code = """
+class A:
+    def method_a(self):
+        pass
+
+class B(A):
+    def method_b(self):
+        self.method_a()
+
+class C(B):
+    def method_c(self):
+        self.method_b()
+
+def use_c():
+    return C()
+"""
+    with get_codebase_session(tmpdir=tmpdir, programming_language=ProgrammingLanguage.PYTHON, files={"test.py": py_code}) as G:
+        use_c_func = G.get_function("use_c")
+        c_class = G.get_class("C")
+        b_class = G.get_class("B")
+        a_class = G.get_class("A")
+
+        # Test direct dependencies (depth=1)
+        direct_deps = c_class.get_dependencies_to_depth(depth=1)
+        assert len(direct_deps) == 1
+        assert direct_deps[0] == b_class
+
+        # Test two levels of dependencies (depth=2)
+        two_level_deps = c_class.get_dependencies_to_depth(depth=2)
+        assert len(two_level_deps) == 2
+        assert b_class in two_level_deps
+        assert a_class in two_level_deps
+
+        # Test unlimited depth (depth=None)
+        all_deps = c_class.get_dependencies_to_depth()
+        assert len(all_deps) == 2
+        assert b_class in all_deps
+        assert a_class in all_deps
+
+        # Test that default dependencies property returns all dependencies
+        default_deps = c_class.dependencies
+        assert set(default_deps) == set(all_deps)
+
+
+def test_dependencies_with_imports(tmpdir):
+    """Test that dependencies property and get_dependencies_to_depth handle imports correctly."""
+    py_code = """
+from typing import Optional
+
+class MyClass:
+    def __init__(self, value: Optional[str] = None):
+        self.value = value
+"""
+    with get_codebase_session(tmpdir=tmpdir, programming_language=ProgrammingLanguage.PYTHON, files={"test.py": py_code}) as G:
+        my_class = G.get_class("MyClass")
+        
+        # Test that imports are included in dependencies
+        deps = my_class.get_dependencies_to_depth(depth=1)
+        assert len(deps) == 2  # Optional and str
+        assert any(dep.name == "Optional" for dep in deps)
+        assert any(dep.name == "str" for dep in deps)
+
+        # Test that default dependencies property includes imports
+        all_deps = my_class.dependencies
+        assert len(all_deps) == 2
+        assert any(dep.name == "Optional" for dep in all_deps)
+        assert any(dep.name == "str" for dep in all_deps)
+
+
+def test_backward_compatibility(tmpdir):
+    """Test that get_dependencies method still works for backward compatibility."""
+    py_code = """
+from typing import Optional
+
+class MyClass:
+    def __init__(self, value: Optional[str] = None):
+        self.value = value
+"""
+    with get_codebase_session(tmpdir=tmpdir, programming_language=ProgrammingLanguage.PYTHON, files={"test.py": py_code}) as G:
+        my_class = G.get_class("MyClass")
+        
+        # Test that get_dependencies with DIRECT usage type works
+        direct_deps = my_class.get_dependencies(UsageType.DIRECT)
+        assert len(direct_deps) == 2
+        assert any(dep.name == "Optional" for dep in direct_deps)
+        assert any(dep.name == "str" for dep in direct_deps)
+
+        # Test that get_dependencies with CHAINED usage type works
+        chained_deps = my_class.get_dependencies(UsageType.CHAINED)
+        assert len(chained_deps) == 0  # No chained dependencies in this example
+
+        # Test that get_dependencies with combined usage types works
+        all_deps = my_class.get_dependencies(UsageType.DIRECT | UsageType.CHAINED)
+        assert len(all_deps) == 2
+        assert any(dep.name == "Optional" for dep in all_deps)
+        assert any(dep.name == "str" for dep in all_deps)
+
+
+def test_zero_depth(tmpdir):
+    """Test that depth=0 returns empty list."""
+    py_code = """
+class A:
+    pass
+
+class B(A):
+    pass
+"""
+    with get_codebase_session(tmpdir=tmpdir, programming_language=ProgrammingLanguage.PYTHON, files={"test.py": py_code}) as G:
+        b_class = G.get_class("B")
+        
+        # Test that depth=0 returns empty list
+        deps = b_class.get_dependencies_to_depth(depth=0)
+        assert len(deps) == 0
+
+
+def test_cyclic_dependencies(tmpdir):
+    """Test that dependencies property and get_dependencies_to_depth handle cyclic dependencies."""
+    py_code = """
+class A:
+    def method_a(self):
+        return B()
+
+class B:
+    def method_b(self):
+        return A()
+"""
+    with get_codebase_session(tmpdir=tmpdir, programming_language=ProgrammingLanguage.PYTHON, files={"test.py": py_code}) as G:
+        a_class = G.get_class("A")
+        b_class = G.get_class("B")
+
+        # Test direct dependencies
+        a_direct_deps = a_class.get_dependencies_to_depth(depth=1)
+        assert len(a_direct_deps) == 1
+        assert a_direct_deps[0] == b_class
+
+        # Test that cyclic dependencies are handled properly
+        a_all_deps = a_class.get_dependencies_to_depth()
+        assert len(a_all_deps) == 1
+        assert b_class in a_all_deps
+
+        # Test B's dependencies
+        b_direct_deps = b_class.get_dependencies_to_depth(depth=1)
+        assert len(b_direct_deps) == 1
+        assert b_direct_deps[0] == a_class