Merge branch 'main' into gpu-flag

Author: aseembits93

.github/workflows/claude.yml

@@ -49,6 +49,7 @@ jobs:
         uses: anthropics/claude-code-action@v1
         with:
           use_foundry: "true"
+          claude_args: '--allowedTools "Read,Edit,Write,Glob,Grep,Bash(git status*),Bash(git diff*),Bash(git add *),Bash(git commit *),Bash(git push*),Bash(git log*),Bash(uv run pre-commit *),Bash(uv run ruff *),Bash(uv run pytest *),Bash(uv run mypy *),Bash(uv run coverage *),Bash(gh pr comment*),Bash(gh pr view*),Bash(gh pr diff*)"'
           additional_permissions: |
             actions: read
         env:

.pre-commit-config.yaml

@@ -1,6 +1,6 @@
 repos:
 - repo: https://github.com/astral-sh/ruff-pre-commit
-  rev: v0.12.7
+  rev: v0.15.0
   hooks:
     # Run the linter.
     - id: ruff-check

CLAUDE.md

@@ -62,6 +62,8 @@ codeflash/
 - Use libcst, not ast - For Python, always use `libcst` for code parsing/modification to preserve formatting.
 - Code context extraction and replacement tests must always assert for full string equality, no substring matching.
 - Any new feature or bug fix that can be tested automatically must have test cases.
+- If changes affect existing test expectations, update the tests accordingly. Tests must always pass after changes.
+- NEVER use leading underscores for function names (e.g., `_helper`). Python has no true private functions. Always use public names.
 
 ## Code Style
 
@@ -70,7 +72,7 @@ codeflash/
 - **Tooling**: Ruff for linting/formatting, mypy strict mode, pre-commit hooks
 - **Comments**: Minimal - only explain "why", not "what"
 - **Docstrings**: Do not add unless explicitly requested
-- **Naming**: Prefer public functions (no leading underscore) - Python doesn't have true private functions
+- **Naming**: NEVER use leading underscores (`_function_name`) - Python has no true private functions, use public names
 - **Paths**: Always use absolute paths, handle encoding explicitly (UTF-8)
 
 ## Git Commits & Pull Requests

codeflash/languages/python/support.py

@@ -321,7 +321,7 @@ def find_references(
 
             function_pos = None
             for name in names:
-                if name.type == "function" and name.name == function.name:
+                if name.type == "function" and name.name == function.function_name:
                     # Check for class parent if it's a method
                     if function.class_name:
                         parent = name.parent()

pyproject.toml

@@ -78,8 +78,9 @@ dev = [
     "types-greenlet>=3.1.0.20241221,<4",
     "types-pexpect>=4.9.0.20241208,<5",
     "types-unidiff>=0.7.0.20240505,<0.8",
-    "uv>=0.6.2",
     "pre-commit>=4.2.0,<5",
+    "ty>=0.0.14",
+    "uv>=0.9.29",
 ]
 tests = [
     "black>=25.9.0",

tests/test_languages/test_python_support.py

@@ -555,3 +555,125 @@ def standalone():
 
             standalone_funcs = [f for f in functions if f.class_name is None]
             assert len(standalone_funcs) == 1
+
+
+# === Tests for find_references method ===
+# These tests verify that PythonSupport correctly finds references to functions
+# using jedi, including the fix for using function.function_name instead of function.name.
+
+
+def test_find_references_simple_function(python_support, tmp_path):
+    """Test finding references to a simple function.
+
+    This test specifically exercises the code path that was fixed in the
+    regression where function.name was used instead of function.function_name.
+    """
+    from codeflash.models.function_types import FunctionToOptimize
+
+    # Create source file with function definition
+    source_file = tmp_path / "utils.py"
+    source_file.write_text("""def helper_function(x):
+    return x * 2
+""")
+
+    # Create a file that imports and uses the function
+    consumer_file = tmp_path / "consumer.py"
+    consumer_file.write_text("""from utils import helper_function
+
+def process(value):
+    return helper_function(value) + 1
+""")
+
+    func = FunctionToOptimize(
+        function_name="helper_function",
+        file_path=source_file,
+        starting_line=1,
+        ending_line=2,
+    )
+
+    refs = python_support.find_references(func, project_root=tmp_path)
+
+    assert len(refs) >= 1
+    ref_files = {str(r.file_path) for r in refs}
+    assert any("consumer.py" in f for f in ref_files)
+
+
+def test_find_references_class_method(python_support, tmp_path):
+    """Test finding references to a class method.
+
+    This verifies the class_name attribute is correctly used to disambiguate methods.
+    """
+    from codeflash.models.function_types import FunctionParent, FunctionToOptimize
+
+    # Create source file with class and method
+    source_file = tmp_path / "calculator.py"
+    source_file.write_text("""class Calculator:
+    def add(self, a, b):
+        return a + b
+""")
+
+    # Create a file that uses the class method
+    consumer_file = tmp_path / "main.py"
+    consumer_file.write_text("""from calculator import Calculator
+
+def compute():
+    calc = Calculator()
+    return calc.add(1, 2)
+""")
+
+    func = FunctionToOptimize(
+        function_name="add",
+        file_path=source_file,
+        parents=[FunctionParent(name="Calculator", type="ClassDef")],
+        starting_line=2,
+        ending_line=3,
+        is_method=True,
+    )
+
+    refs = python_support.find_references(func, project_root=tmp_path)
+
+    assert len(refs) >= 1
+    ref_files = {str(r.file_path) for r in refs}
+    assert any("main.py" in f for f in ref_files)
+
+
+def test_find_references_no_references(python_support, tmp_path):
+    """Test that find_references returns empty list when no references exist."""
+    from codeflash.models.function_types import FunctionToOptimize
+
+    source_file = tmp_path / "isolated.py"
+    source_file.write_text("""def isolated_function():
+    return 42
+""")
+
+    func = FunctionToOptimize(
+        function_name="isolated_function",
+        file_path=source_file,
+        starting_line=1,
+        ending_line=2,
+    )
+
+    refs = python_support.find_references(func, project_root=tmp_path)
+
+    assert refs == []
+
+
+def test_find_references_nonexistent_function(python_support, tmp_path):
+    """Test that find_references handles nonexistent functions gracefully."""
+    from codeflash.models.function_types import FunctionToOptimize
+
+    source_file = tmp_path / "source.py"
+    source_file.write_text("""def existing_function():
+    return 1
+""")
+
+    func = FunctionToOptimize(
+        function_name="nonexistent_function",
+        file_path=source_file,
+        starting_line=1,
+        ending_line=2,
+    )
+
+    refs = python_support.find_references(func, project_root=tmp_path)
+
+    assert refs == []