⚡️ Speed up function should_modify_package_json_config by 16% in PR #1231 (js-tests-root)

[codeflash-ai]

⚡️ This pull request contains optimizations for PR #1231

If you approve this dependent PR, these changes will be merged into the original PR branch js-tests-root.

This PR will be automatically closed if the original PR is merged.

---

📄 16% (0.16x) speedup for should_modify_package_json_config in codeflash/cli_cmds/init_javascript.py

⏱️ Runtime : 5.40 milliseconds → 4.64 milliseconds (best of 118 runs)

📝 Explanation and details

The optimized code achieves a 16% runtime improvement (from 5.40ms to 4.64ms) by replacing the file handling approach for reading package.json.

Key Optimization:
The original code used a context manager with open() and json.load():

with package_json_path.open(encoding="utf8") as f:
    package_data = json.load(f)

The optimized version uses a direct byte-read approach:

package_data = json.loads(package_json_path.read_bytes())

Why This Is Faster:

1. Fewer I/O operations: read_bytes() performs a single read operation, while the context manager approach involves opening the file handle, potentially buffered reads by json.load(), and file closing overhead
2. Reduced Python interpreter overhead: Eliminates the context manager protocol (__enter__ and __exit__ methods) and the file object state management
3. Direct memory operation: json.loads() operates on an in-memory bytes object, which is more efficient than streaming from a file object

Line Profiler Evidence:
The optimization shows clear improvement in the JSON reading line:

• Original: 2 hits totaling ~4.22ms (file open + json.load operations)
• Optimized: 1 hit totaling ~3.66ms (single read_bytes + loads operation)
• 13% reduction in this specific operation, contributing to the overall 16% speedup

Test Results:
The optimization shows consistent improvements across all test cases:

• Simple configs: 21-28% faster (e.g., test_package_json_no_codeflash_config: 42.0μs → 33.1μs)
• Configs with validation: 16-21% faster (e.g., test_package_json_valid_config_user_confirms: 82.1μs → 67.6μs)
• Large files: Still effective (e.g., test_large_package_json_file with 1000 dependencies: 242μs → 225μs, 7.5% faster)

The optimization is particularly effective for the most common use cases (small to medium package.json files), where the file I/O overhead is proportionally significant relative to the total execution time.

✅ Correctness verification report:

Test	Status
⚙️ Existing Unit Tests	🔘 None Found
🌀 Generated Regression Tests	✅ 134 Passed
⏪ Replay Tests	🔘 None Found
🔎 Concolic Coverage Tests	🔘 None Found
📊 Tests Coverage	100.0%

🌀 Click to see Generated Regression Tests

import json
import os
from pathlib import Path

import codeflash.cli_cmds.init_javascript as init_js
import pytest  # used for our unit tests
from codeflash.cli_cmds.init_javascript import \
    should_modify_package_json_config
from rich.prompt import Confirm

# Unit tests for should_modify_package_json_config
#
# Each test uses tmp_path (pytest fixture) to create an isolated filesystem layout
# and monkeypatch to change the current working directory so Path("package.json")
# inside the function under test refers to the test-specific file.
#
# We also monkeypatch Confirm.ask (the interactive prompt) when needed to avoid
# hanging on user input. We deliberately do not mock the function under test.

def write_package_json(path: Path, data: dict):
    """
    Helper to write package.json at the given directory path.
    Ensures file is encoded as UTF-8 as expected by the function.
    """
    p = path / "package.json"
    p.write_text(json.dumps(data), encoding="utf8")
    return p

def test_no_package_json_causes_system_exit(tmp_path, monkeypatch):
    # Change CWD to an empty temporary directory to simulate no package.json existing.
    monkeypatch.chdir(tmp_path)

    # Calling the function without a package.json should lead to an exit via apologize_and_exit,
    # which calls sys.exit(1). That raises SystemExit which we assert here.
    with pytest.raises(SystemExit) as excinfo:
        should_modify_package_json_config()

def test_package_json_without_codeflash_returns_true_none(tmp_path, monkeypatch):
    # Simulate project root with a package.json that does not contain "codeflash".
    monkeypatch.chdir(tmp_path)
    write_package_json(tmp_path, {"name": "example-project", "version": "1.0.0"})

    # Should indicate we need to modify configuration (True) and provide no existing config (None).
    codeflash_output = should_modify_package_json_config(); result = codeflash_output # 38.6μs -> 30.2μs (28.0% faster)

def test_package_json_with_empty_codeflash_returns_true_none(tmp_path, monkeypatch):
    # Simulate package.json with an explicit empty codeflash object.
    monkeypatch.chdir(tmp_path)
    write_package_json(tmp_path, {"codeflash": {}})

    # Empty config counts as "no config", so function should return (True, None).
    codeflash_output = should_modify_package_json_config() # 35.2μs -> 28.9μs (21.7% faster)

@pytest.mark.parametrize("confirm_choice", [True, False])
def test_valid_config_with_existing_module_root_calls_confirm_and_returns_choice(tmp_path, monkeypatch, confirm_choice):
    # Create a module root directory and a package.json with a valid codeflash config.
    project_dir = tmp_path
    module_dir = project_dir / "src"
    module_dir.mkdir()  # make sure moduleRoot exists and is a directory

    config = {"moduleRoot": "src", "extra": "value"}
    write_package_json(project_dir, {"codeflash": config, "name": "proj"})

    # Change into the project dir so Path("package.json") is found.
    monkeypatch.chdir(project_dir)

    # Monkeypatch Confirm.ask to simulate user interaction (True/False).
    monkeypatch.setattr(init_js.Confirm, "ask", staticmethod(lambda *a, **kw: confirm_choice))

    # The function should return the mocked Confirm.ask choice and the config dict read from file.
    codeflash_output = should_modify_package_json_config(); result = codeflash_output # 86.1μs -> 73.9μs (16.4% faster)

def test_invalid_module_root_returns_true_none(tmp_path, monkeypatch):
    # package.json has moduleRoot pointing to a non-existent directory -> should return (True, None).
    monkeypatch.chdir(tmp_path)
    write_package_json(tmp_path, {"codeflash": {"moduleRoot": "nonexistent"}})

    codeflash_output = should_modify_package_json_config() # 49.2μs -> 42.3μs (16.2% faster)

def test_invalid_tests_root_returns_true_none(tmp_path, monkeypatch):
    # moduleRoot exists but testsRoot points to a non-existent path -> should return (True, None).
    project_dir = tmp_path
    module_dir = project_dir / "app"
    module_dir.mkdir()

    # testsRoot points to missing "tests" folder
    write_package_json(project_dir, {"codeflash": {"moduleRoot": "app", "testsRoot": "tests"}})
    monkeypatch.chdir(project_dir)

    codeflash_output = should_modify_package_json_config() # 54.0μs -> 46.0μs (17.3% faster)

def test_malformed_json_returns_true_none(tmp_path, monkeypatch):
    # If package.json cannot be parsed as JSON, function should catch exception and return (True, None).
    monkeypatch.chdir(tmp_path)
    p = tmp_path / "package.json"
    # write invalid JSON
    p.write_text('{"codeflash": { invalid-json }', encoding="utf8")

    codeflash_output = should_modify_package_json_config() # 47.9μs -> 38.8μs (23.4% faster)

def test_module_root_pointing_to_file_counts_as_invalid(tmp_path, monkeypatch):
    # If moduleRoot points to a path that is a file (not a directory), is_dir() is False -> invalid.
    project_dir = tmp_path
    file_path = project_dir / "not_a_dir"
    file_path.write_text("I am a file", encoding="utf8")  # creates a file, not a directory

    write_package_json(project_dir, {"codeflash": {"moduleRoot": "not_a_dir"}})
    monkeypatch.chdir(project_dir)

    codeflash_output = should_modify_package_json_config() # 40.7μs -> 34.4μs (18.2% faster)

def test_module_root_defaults_to_dot_and_valid_when_missing(tmp_path, monkeypatch):
    # If moduleRoot is not specified, it should default to "." which is the current dir and valid.
    project_dir = tmp_path
    # create tests directory so testsRoot check (if present) can also be valid
    (project_dir / "tests").mkdir()
    write_package_json(project_dir, {"codeflash": {"testsRoot": "tests"}})
    monkeypatch.chdir(project_dir)

    # Monkeypatch Confirm.ask to avoid prompting; return False to simulate "do not reconfigure".
    monkeypatch.setattr(init_js.Confirm, "ask", staticmethod(lambda *a, **kw: False))

    codeflash_output = should_modify_package_json_config(); result = codeflash_output # 47.8μs -> 41.2μs (16.1% faster)

def test_large_package_json_with_many_keys_and_valid_config(tmp_path, monkeypatch):
    # Large scale test: create a package.json with many unrelated keys and a valid codeflash config.
    # Keep the number of additional keys well under 1000 to comply with instructions.
    project_dir = tmp_path
    (project_dir / "lib").mkdir()  # make moduleRoot exist

    many_keys = {f"key_{i}": f"value_{i}" for i in range(300)}  # 300 extra keys is large but reasonable
    codeflash_config = {"moduleRoot": "lib", "testsRoot": "lib_tests"}
    # create tests directory mentioned by testsRoot so config is fully valid
    (project_dir / "lib_tests").mkdir()
    data = {"name": "bigproj", "version": "0.0.1", **many_keys, "codeflash": codeflash_config}
    write_package_json(project_dir, data)
    monkeypatch.chdir(project_dir)

    # Simulate user chooses to re-configure (True)
    monkeypatch.setattr(init_js.Confirm, "ask", staticmethod(lambda *a, **kw: True))

    codeflash_output = should_modify_package_json_config(); result = codeflash_output # 96.4μs -> 88.0μs (9.52% faster)
# codeflash_output is used to check that the output of the original code is the same as that of the optimized code.

import json
import os
import tempfile
from pathlib import Path
from unittest.mock import MagicMock, patch

# imports
import pytest
from codeflash.cli_cmds.init_javascript import \
    should_modify_package_json_config

# Test fixtures
@pytest.fixture
def temp_dir():
    """Create a temporary directory for test files."""
    with tempfile.TemporaryDirectory() as tmpdir:
        original_cwd = os.getcwd()
        os.chdir(tmpdir)
        yield tmpdir
        os.chdir(original_cwd)

@pytest.fixture
def package_json_minimal(temp_dir):
    """Create a minimal valid package.json file."""
    package_json_path = Path("package.json")
    package_json_path.write_text(json.dumps({"name": "test-project"}), encoding="utf8")
    return package_json_path

@pytest.fixture
def package_json_with_valid_config(temp_dir):
    """Create a package.json with valid codeflash config."""
    Path(".").mkdir(exist_ok=True)
    Path("tests").mkdir(exist_ok=True)
    package_json_path = Path("package.json")
    data = {
        "name": "test-project",
        "codeflash": {
            "moduleRoot": ".",
            "testsRoot": "tests"
        }
    }
    package_json_path.write_text(json.dumps(data), encoding="utf8")
    return package_json_path

@pytest.fixture
def package_json_with_invalid_module_root(temp_dir):
    """Create a package.json with invalid moduleRoot."""
    package_json_path = Path("package.json")
    data = {
        "name": "test-project",
        "codeflash": {
            "moduleRoot": "/nonexistent/path"
        }
    }
    package_json_path.write_text(json.dumps(data), encoding="utf8")
    return package_json_path

@pytest.fixture
def package_json_with_invalid_tests_root(temp_dir):
    """Create a package.json with invalid testsRoot."""
    Path(".").mkdir(exist_ok=True)
    package_json_path = Path("package.json")
    data = {
        "name": "test-project",
        "codeflash": {
            "moduleRoot": ".",
            "testsRoot": "/nonexistent/tests"
        }
    }
    package_json_path.write_text(json.dumps(data), encoding="utf8")
    return package_json_path

def test_no_package_json_found(temp_dir):
    """Test when package.json does not exist."""
    
    # The function should call apologize_and_exit when package.json is not found
    with patch('codeflash.cli_cmds.init_javascript.apologize_and_exit') as mock_exit:
        should_modify_package_json_config() # 205μs -> 186μs (10.4% faster)
        # apologize_and_exit should be called since package.json doesn't exist
        mock_exit.assert_called_once()

def test_package_json_no_codeflash_config(package_json_minimal):
    """Test when package.json exists but has no codeflash config."""
    # Call the function
    should_modify, config = should_modify_package_json_config() # 42.0μs -> 33.1μs (27.0% faster)

def test_package_json_empty_codeflash_config(temp_dir):
    """Test when package.json has empty codeflash config."""
    package_json_path = Path("package.json")
    data = {"name": "test-project", "codeflash": {}}
    package_json_path.write_text(json.dumps(data), encoding="utf8")
    
    # Call the function
    should_modify, config = should_modify_package_json_config() # 35.5μs -> 28.6μs (23.8% faster)

def test_package_json_valid_config_user_confirms(package_json_with_valid_config):
    """Test when package.json has valid config and user confirms reconfiguration."""
    # Mock Confirm.ask to return True (user wants to reconfigure)
    with patch('codeflash.cli_cmds.init_javascript.Confirm.ask', return_value=True):
        should_modify, config = should_modify_package_json_config() # 82.1μs -> 67.6μs (21.4% faster)

def test_package_json_valid_config_user_declines(package_json_with_valid_config):
    """Test when package.json has valid config and user declines reconfiguration."""
    # Mock Confirm.ask to return False (user doesn't want to reconfigure)
    with patch('codeflash.cli_cmds.init_javascript.Confirm.ask', return_value=False):
        should_modify, config = should_modify_package_json_config() # 78.9μs -> 67.7μs (16.5% faster)

def test_invalid_module_root(package_json_with_invalid_module_root):
    """Test when moduleRoot points to non-existent directory."""
    # Call the function
    should_modify, config = should_modify_package_json_config() # 57.8μs -> 48.3μs (19.6% faster)

def test_invalid_tests_root(package_json_with_invalid_tests_root):
    """Test when testsRoot points to non-existent directory."""
    # Call the function
    should_modify, config = should_modify_package_json_config() # 59.0μs -> 50.7μs (16.3% faster)

def test_package_json_malformed_json(temp_dir):
    """Test when package.json contains invalid JSON."""
    package_json_path = Path("package.json")
    # Write invalid JSON
    package_json_path.write_text("{invalid json content}", encoding="utf8")
    
    # Call the function
    should_modify, config = should_modify_package_json_config() # 46.5μs -> 36.6μs (27.2% faster)

def test_package_json_missing_encoding(temp_dir):
    """Test reading package.json without explicit encoding issues."""
    package_json_path = Path("package.json")
    data = {"name": "test-project"}
    package_json_path.write_text(json.dumps(data), encoding="utf8")
    
    # Call the function
    should_modify, config = should_modify_package_json_config() # 33.7μs -> 27.5μs (22.6% faster)

def test_module_root_as_dot_reference(temp_dir):
    """Test when moduleRoot is explicitly set to '.' (current directory)."""
    package_json_path = Path("package.json")
    data = {
        "name": "test-project",
        "codeflash": {
            "moduleRoot": "."
        }
    }
    package_json_path.write_text(json.dumps(data), encoding="utf8")
    
    # Call the function
    should_modify, config = should_modify_package_json_config() # 363μs -> 320μs (13.5% faster)
    
    # Should recognize '.' as valid current directory
    # Will ask user for confirmation
    with patch('codeflash.cli_cmds.init_javascript.Confirm.ask', return_value=False):
        should_modify, config = should_modify_package_json_config() # 70.6μs -> 59.6μs (18.6% faster)

def test_module_root_relative_path(temp_dir):
    """Test when moduleRoot is a valid relative path."""
    # Create src directory
    Path("src").mkdir(exist_ok=True)
    Path("tests").mkdir(exist_ok=True)
    
    package_json_path = Path("package.json")
    data = {
        "name": "test-project",
        "codeflash": {
            "moduleRoot": "src",
            "testsRoot": "tests"
        }
    }
    package_json_path.write_text(json.dumps(data), encoding="utf8")
    
    # Call the function
    with patch('codeflash.cli_cmds.init_javascript.Confirm.ask', return_value=True):
        should_modify, config = should_modify_package_json_config() # 73.4μs -> 62.9μs (16.6% faster)

def test_tests_root_missing_when_module_root_valid(temp_dir):
    """Test when testsRoot is missing but moduleRoot is valid."""
    package_json_path = Path("package.json")
    data = {
        "name": "test-project",
        "codeflash": {
            "moduleRoot": "."
        }
    }
    package_json_path.write_text(json.dumps(data), encoding="utf8")
    
    # Call the function
    with patch('codeflash.cli_cmds.init_javascript.Confirm.ask', return_value=False):
        should_modify, config = should_modify_package_json_config() # 67.8μs -> 57.9μs (17.2% faster)

def test_tests_root_none_value(temp_dir):
    """Test when testsRoot is explicitly set to None."""
    package_json_path = Path("package.json")
    data = {
        "name": "test-project",
        "codeflash": {
            "moduleRoot": ".",
            "testsRoot": None
        }
    }
    package_json_path.write_text(json.dumps(data), encoding="utf8")
    
    # Call the function
    with patch('codeflash.cli_cmds.init_javascript.Confirm.ask', return_value=False):
        should_modify, config = should_modify_package_json_config() # 66.6μs -> 59.2μs (12.5% faster)

def test_codeflash_config_with_extra_fields(temp_dir):
    """Test when codeflash config has extra fields beyond moduleRoot and testsRoot."""
    package_json_path = Path("package.json")
    data = {
        "name": "test-project",
        "codeflash": {
            "moduleRoot": ".",
            "testsRoot": None,
            "customField": "customValue",
            "anotherField": 123
        }
    }
    package_json_path.write_text(json.dumps(data), encoding="utf8")
    
    # Call the function
    with patch('codeflash.cli_cmds.init_javascript.Confirm.ask', return_value=False):
        should_modify, config = should_modify_package_json_config() # 67.2μs -> 58.5μs (14.9% faster)

def test_special_characters_in_paths(temp_dir):
    """Test when paths contain special characters."""
    # Create directory with special characters
    special_dir = "test-dir_with.special"
    Path(special_dir).mkdir(exist_ok=True)
    
    package_json_path = Path("package.json")
    data = {
        "name": "test-project",
        "codeflash": {
            "moduleRoot": special_dir
        }
    }
    package_json_path.write_text(json.dumps(data), encoding="utf8")
    
    # Call the function
    with patch('codeflash.cli_cmds.init_javascript.Confirm.ask', return_value=False):
        should_modify, config = should_modify_package_json_config() # 65.3μs -> 55.2μs (18.4% faster)

def test_deeply_nested_codeflash_config(temp_dir):
    """Test when package.json has a deeply nested structure."""
    package_json_path = Path("package.json")
    data = {
        "name": "test-project",
        "version": "1.0.0",
        "description": "A test project",
        "main": "index.js",
        "scripts": {"test": "jest"},
        "dependencies": {"lodash": "^4.0.0"},
        "codeflash": {
            "moduleRoot": ".",
            "testsRoot": None
        },
        "devDependencies": {"jest": "^27.0.0"}
    }
    package_json_path.write_text(json.dumps(data), encoding="utf8")
    
    # Call the function
    with patch('codeflash.cli_cmds.init_javascript.Confirm.ask', return_value=False):
        should_modify, config = should_modify_package_json_config() # 70.1μs -> 60.4μs (16.1% faster)

def test_case_sensitive_config_key(temp_dir):
    """Test that codeflash config key lookup is case-sensitive."""
    package_json_path = Path("package.json")
    data = {
        "name": "test-project",
        "Codeflash": {  # Wrong case
            "moduleRoot": "."
        }
    }
    package_json_path.write_text(json.dumps(data), encoding="utf8")
    
    # Call the function
    should_modify, config = should_modify_package_json_config() # 34.6μs -> 28.5μs (21.7% faster)

def test_permission_error_handling(temp_dir):
    """Test handling when package.json cannot be read due to permissions."""
    package_json_path = Path("package.json")
    data = {"name": "test-project"}
    package_json_path.write_text(json.dumps(data), encoding="utf8")
    
    # Remove read permissions
    os.chmod(package_json_path, 0o000)
    
    try:
        # Call the function
        should_modify, config = should_modify_package_json_config()
    finally:
        # Restore permissions for cleanup
        os.chmod(package_json_path, 0o644)

def test_large_package_json_file(temp_dir):
    """Test with a large package.json file containing many dependencies."""
    package_json_path = Path("package.json")
    data = {
        "name": "test-project",
        "version": "1.0.0",
        "codeflash": {
            "moduleRoot": "."
        },
        "dependencies": {f"dep-{i}": f"^{i}.0.0" for i in range(500)},
        "devDependencies": {f"dev-dep-{i}": f"^{i}.0.0" for i in range(500)}
    }
    package_json_path.write_text(json.dumps(data), encoding="utf8")
    
    # Call the function
    with patch('codeflash.cli_cmds.init_javascript.Confirm.ask', return_value=False):
        should_modify, config = should_modify_package_json_config() # 242μs -> 225μs (7.48% faster)

def test_large_codeflash_config_with_many_custom_fields(temp_dir):
    """Test codeflash config with many custom fields."""
    package_json_path = Path("package.json")
    codeflash_config = {
        "moduleRoot": ".",
        "testsRoot": None
    }
    # Add 500 custom fields
    for i in range(500):
        codeflash_config[f"customField_{i}"] = f"value_{i}"
    
    data = {
        "name": "test-project",
        "codeflash": codeflash_config
    }
    package_json_path.write_text(json.dumps(data), encoding="utf8")
    
    # Call the function
    with patch('codeflash.cli_cmds.init_javascript.Confirm.ask', return_value=False):
        should_modify, config = should_modify_package_json_config() # 144μs -> 130μs (11.0% faster)

def test_package_json_with_unicode_content(temp_dir):
    """Test package.json with unicode characters."""
    package_json_path = Path("package.json")
    data = {
        "name": "test-project",
        "description": "Test with unicode: \u00e9\u00e0\u00fc",
        "codeflash": {
            "moduleRoot": ".",
            "testsRoot": None
        }
    }
    package_json_path.write_text(json.dumps(data, ensure_ascii=False), encoding="utf8")
    
    # Call the function
    with patch('codeflash.cli_cmds.init_javascript.Confirm.ask', return_value=False):
        should_modify, config = should_modify_package_json_config() # 68.9μs -> 60.2μs (14.4% faster)

def test_multiple_sequential_calls(temp_dir):
    """Test multiple sequential calls to the function."""
    package_json_path = Path("package.json")
    data = {
        "name": "test-project",
        "codeflash": {
            "moduleRoot": "."
        }
    }
    package_json_path.write_text(json.dumps(data), encoding="utf8")
    
    # Call the function multiple times
    with patch('codeflash.cli_cmds.init_javascript.Confirm.ask', return_value=False):
        for _ in range(100):
            should_modify, config = should_modify_package_json_config()

def test_package_json_with_many_nested_levels(temp_dir):
    """Test package.json with deeply nested JSON structure."""
    package_json_path = Path("package.json")
    
    # Create nested structure
    nested = {"level_0": {"level_1": {"level_2": {"level_3": {"level_4": {}}}}}}
    nested["level_0"]["level_1"]["level_2"]["level_3"]["level_4"]["codeflash"] = {
        "moduleRoot": "."
    }
    
    data = {
        "name": "test-project",
        "nested": nested,
        "codeflash": {
            "moduleRoot": "."
        }
    }
    package_json_path.write_text(json.dumps(data), encoding="utf8")
    
    # Call the function
    with patch('codeflash.cli_cmds.init_javascript.Confirm.ask', return_value=False):
        should_modify, config = should_modify_package_json_config() # 70.0μs -> 58.0μs (20.6% faster)
# codeflash_output is used to check that the output of the original code is the same as that of the optimized code.

To edit these changes git checkout codeflash/optimize-pr1231-2026-02-01T12.34.35 and push.