⚡️ Speed up function should_modify_package_json_config by 21% 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.

---

📄 21% (0.21x) speedup for should_modify_package_json_config in codeflash/cli_cmds/init_javascript.py

⏱️ Runtime : 808 microseconds → 668 microseconds (best of 40 runs)

📝 Explanation and details

This optimization achieves a 20% runtime improvement (808μs → 668μs) through two targeted changes:

Key Optimizations

1. Module-level Confirm import - Moving from rich.prompt import Confirm from inside the function to the module level eliminates repeated import overhead on each function call. The line profiler shows this previously took ~52μs per call, which is now avoided entirely.

2. Simplified path construction - Replacing Path.cwd() / "package.json" with Path("package.json") eliminates an unnecessary OS syscall. The line profiler shows this reduced the path construction time from ~496μs to ~202μs (59% faster on this line alone), saving ~300μs per invocation.

Why These Changes Matter

• Import optimization: Python's import mechanism, even when cached, has overhead. Moving to module-level eliminates this per-call cost completely.

• Path operation: Path.cwd() makes an OS call (getcwd()) every time, while Path("package.json") directly creates a path relative to the current directory without the syscall overhead.

Test Performance

All test cases show consistent improvements:

• Simple cases: 17-46% faster (e.g., empty config test: 58.0μs → 43.6μs)
• Complex validation cases: 21-28% faster (e.g., invalid JSON: 67.3μs → 52.5μs)
• Even large-scale tests with 500+ config keys improved by ~9%

The optimization is particularly effective for scenarios where this function is called multiple times (e.g., during batch operations or repeated validation), as the per-call savings compound. Both changes are semantically equivalent to the original code—they produce identical results while executing faster.

✅ Correctness verification report:

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

🌀 Click to see Generated Regression Tests

import json  # to write package.json test fixtures
import sys  # for raising SystemExit in our local apologize_and_exit shim
from pathlib import Path  # to create directories and file paths for tests
from unittest.mock import patch  # to patch Confirm.ask in rich.prompt

import pytest  # used for our unit tests
from codeflash.cli_cmds.init_javascript import \
    should_modify_package_json_config

def test_missing_package_json_triggers_apologize_and_exit(tmp_path, monkeypatch):
    # Scenario: There is no package.json in the current working directory.
    # Expectation: The function calls apologize_and_exit which we emulate by
    # raising SystemExit. We assert that SystemExit is raised.
    monkeypatch.chdir(tmp_path)  # ensure working directory has no package.json
    with pytest.raises(SystemExit) as excinfo:
        should_modify_package_json_config()

def test_package_json_without_codeflash_returns_true_none(tmp_path, monkeypatch):
    # Scenario: package.json exists but has no "codeflash" key.
    # Expectation: The function should return (True, None) indicating we should
    # modify the config (no existing config present).
    monkeypatch.chdir(tmp_path)
    package = {"name": "example-project", "version": "0.1.0"}
    (tmp_path / "package.json").write_text(json.dumps(package), encoding="utf8")

    codeflash_output = should_modify_package_json_config(); result = codeflash_output # 65.8μs -> 45.0μs (46.3% faster)

def test_package_json_with_empty_codeflash_returns_true_none(tmp_path, monkeypatch):
    # Scenario: package.json has an empty "codeflash" dict.
    # Expectation: Treated as no config -> return (True, None).
    monkeypatch.chdir(tmp_path)
    package = {"codeflash": {}}
    (tmp_path / "package.json").write_text(json.dumps(package), encoding="utf8")

    codeflash_output = should_modify_package_json_config(); result = codeflash_output # 58.0μs -> 43.6μs (33.2% faster)

def test_invalid_json_in_package_returns_true_none(tmp_path, monkeypatch):
    # Edge Case: package.json has invalid JSON content.
    # Expectation: The function should catch the exception and return (True, None).
    monkeypatch.chdir(tmp_path)
    (tmp_path / "package.json").write_text("{ not: valid json ", encoding="utf8")

    codeflash_output = should_modify_package_json_config(); result = codeflash_output # 67.3μs -> 52.5μs (28.4% faster)

def test_module_root_invalid_returns_true_none(tmp_path, monkeypatch):
    # Edge Case: codeflash.moduleRoot points to a non-existent directory.
    # Expectation: The function should detect invalid moduleRoot and return (True, None).
    monkeypatch.chdir(tmp_path)
    package = {"codeflash": {"moduleRoot": "does_not_exist"}}
    (tmp_path / "package.json").write_text(json.dumps(package), encoding="utf8")

    codeflash_output = should_modify_package_json_config(); result = codeflash_output # 74.5μs -> 60.0μs (24.1% faster)

def test_tests_root_invalid_returns_true_none(tmp_path, monkeypatch):
    # Edge Case: moduleRoot exists but testsRoot points to a non-existent directory.
    # Expectation: The function should detect invalid testsRoot and return (True, None).
    monkeypatch.chdir(tmp_path)
    # create a valid module root directory
    (tmp_path / "src").mkdir()
    package = {"codeflash": {"moduleRoot": "src", "testsRoot": "no_tests_here"}}
    (tmp_path / "package.json").write_text(json.dumps(package), encoding="utf8")

    codeflash_output = should_modify_package_json_config(); result = codeflash_output # 82.4μs -> 67.7μs (21.7% faster)

def test_valid_config_prompts_and_respects_user_choice_true(tmp_path, monkeypatch):
    # Basic: Valid configuration where both moduleRoot and testsRoot are directories.
    # Expectation: Confirm.ask is invoked; when it returns True, the function
    # returns (True, config).
    monkeypatch.chdir(tmp_path)
    (tmp_path / "src").mkdir()
    (tmp_path / "tests").mkdir()

    config = {"moduleRoot": "src", "testsRoot": "tests", "other": 123}
    (tmp_path / "package.json").write_text(json.dumps({"codeflash": config}), encoding="utf8")

    # Patch Confirm.ask to simulate the user selecting "Yes" (True).
    with patch("rich.prompt.Confirm.ask", return_value=True) as mock_ask:
        codeflash_output = should_modify_package_json_config(); result = codeflash_output # 102μs -> 84.7μs (21.4% faster)
        mock_ask.assert_called_once()  # ensure the prompt was invoked

def test_valid_config_prompts_and_respects_user_choice_false(tmp_path, monkeypatch):
    # Basic: Valid configuration; user chooses not to re-configure (False).
    # Expectation: Function returns (False, config).
    monkeypatch.chdir(tmp_path)
    (tmp_path / "src").mkdir()
    (tmp_path / "tests").mkdir()

    config = {"moduleRoot": "src", "testsRoot": "tests"}
    (tmp_path / "package.json").write_text(json.dumps({"codeflash": config}), encoding="utf8")

    # Simulate the user selecting "No" (False).
    with patch("rich.prompt.Confirm.ask", return_value=False) as mock_ask:
        codeflash_output = should_modify_package_json_config(); result = codeflash_output # 95.8μs -> 81.5μs (17.5% faster)
        mock_ask.assert_called_once()

def test_default_module_root_used_when_missing_and_no_testsroot(tmp_path, monkeypatch):
    # Edge: codeflash config exists but moduleRoot is omitted. Default should be "."
    # If testsRoot is omitted too, the config is valid and the function should prompt.
    monkeypatch.chdir(tmp_path)
    # Current directory ('.') exists by definition.
    config = {"someOtherKey": "value"}  # no moduleRoot, no testsRoot
    (tmp_path / "package.json").write_text(json.dumps({"codeflash": config}), encoding="utf8")

    # Simulate user choosing False (do not re-configure).
    with patch("rich.prompt.Confirm.ask", return_value=False) as mock_ask:
        codeflash_output = should_modify_package_json_config(); result = codeflash_output # 88.1μs -> 74.1μs (18.8% faster)
        mock_ask.assert_called_once()

def test_large_package_json_handling_under_limits(tmp_path, monkeypatch):
    # Large Scale: Create a package.json with a large "codeflash" dict to
    # test scalability. Keep elements under 1000 (we use 500).
    # Expectation: Function handles large dict and returns (False, config)
    # when Confirm.ask is patched to False.
    monkeypatch.chdir(tmp_path)
    (tmp_path / "src").mkdir()  # valid module root
    # Construct a large codeflash dict with 500 keys plus valid moduleRoot value.
    large_config = {"moduleRoot": "src"}
    large_config.update({f"key_{i}": i for i in range(500)})
    (tmp_path / "package.json").write_text(json.dumps({"codeflash": large_config}), encoding="utf8")

    with patch("rich.prompt.Confirm.ask", return_value=False) as mock_ask:
        codeflash_output = should_modify_package_json_config(); result = codeflash_output # 172μs -> 159μs (8.78% faster)
        mock_ask.assert_called_once()
        returned_flag, returned_config = result
# 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.25.17 and push.