claude-dev-env 1.29.2 → 1.30.0

package/scripts/test_groq_bugteam.py

@@ -8,22 +8,29 @@ from __future__ import annotations
 
 import importlib.util
 import pathlib
+import re
 import sys
 import urllib.error
 
-import pytest
-
-sys.path.insert(0, str(pathlib.Path(__file__).parent))
+scripts_directory = pathlib.Path(__file__).parent
+scripts_directory_string = str(scripts_directory)
+if scripts_directory_string not in sys.path:
+    sys.path.insert(0, scripts_directory_string)
 for _cached in list(sys.modules):
     if _cached == "config" or _cached.startswith("config."):
         del sys.modules[_cached]
 
+import groq_bugteam_dotenv  # noqa: E402
+import pytest  # noqa: E402
+
 from config import groq_bugteam_config  # noqa: E402
 
 
 def _load_groq_bugteam_module():
     scripts_directory = pathlib.Path(__file__).parent
-    sys.path.insert(0, str(scripts_directory))
+    scripts_directory_string = str(scripts_directory)
+    if scripts_directory_string not in sys.path:
+        sys.path.insert(0, scripts_directory_string)
     for cached_module_name in list(sys.modules):
         if cached_module_name == "config" or cached_module_name.startswith("config."):
             del sys.modules[cached_module_name]
@@ -64,6 +71,32 @@ class TestClampText:
         assert clamped.startswith("HEAD")
         assert clamped.endswith("TAIL")
 
+    @pytest.mark.parametrize("max_characters", [50, 100, 200, 500, 1000])
+    def test_output_never_exceeds_max_characters(self, max_characters):
+        long_text = "a" * 5000
+        clamped = groq_bugteam.clamp_text(long_text, max_characters)
+        assert len(clamped) <= max_characters
+
+    def test_returns_plain_head_when_marker_does_not_fit(self):
+        long_text = "a" * 1000
+        tiny_budget = 10
+        clamped = groq_bugteam.clamp_text(long_text, tiny_budget)
+        assert len(clamped) <= tiny_budget
+        assert clamped == long_text[:tiny_budget]
+        assert "truncated" not in clamped
+
+    def test_truncation_marker_count_matches_characters_actually_dropped(self):
+        long_text = "a" * 1000
+        max_characters = 200
+        clamped = groq_bugteam.clamp_text(long_text, max_characters)
+        marker_match = re.search(r"truncated (\d+) chars", clamped)
+        assert marker_match is not None
+        reported_truncated_count = int(marker_match.group(1))
+        full_marker = f"\n\n... [truncated {reported_truncated_count} chars] ...\n\n"
+        preserved_original_length = len(clamped) - len(full_marker)
+        actually_truncated_count = len(long_text) - preserved_original_length
+        assert reported_truncated_count == actually_truncated_count
+
 
 class TestParseJsonObject:
     def test_parses_clean_json(self):
@@ -276,6 +309,106 @@ class TestIsRecoverableHttpError:
         assert groq_bugteam.should_skip_to_next_model(self._make_error(status)) is False
 
 
+class TestCallGroqWithFallback:
+    def _install_fake_transport(self, monkeypatch, fake_post_to_groq):
+        monkeypatch.setattr(groq_bugteam, "post_to_groq", fake_post_to_groq)
+        monkeypatch.setattr(groq_bugteam.time, "sleep", lambda _seconds: None)
+
+    def test_non_recoverable_http_error_does_not_attempt_fallback_model(self, monkeypatch):
+        attempted_models: list[str] = []
+
+        def fake_post_to_groq(api_key, model, messages, temperature, max_completion_tokens):
+            attempted_models.append(model)
+            raise urllib.error.HTTPError(
+                url="x", code=401, msg="unauthorized", hdrs=None, fp=None
+            )
+
+        self._install_fake_transport(monkeypatch, fake_post_to_groq)
+        with pytest.raises(RuntimeError):
+            groq_bugteam.call_groq_with_fallback("k", [], 0.0, 100)
+        assert attempted_models == [groq_bugteam.GROQ_PRIMARY_MODEL]
+
+    def test_413_falls_back_to_secondary_model(self, monkeypatch):
+        attempted_models: list[str] = []
+
+        def fake_post_to_groq(api_key, model, messages, temperature, max_completion_tokens):
+            attempted_models.append(model)
+            if model == groq_bugteam.GROQ_PRIMARY_MODEL:
+                raise urllib.error.HTTPError(
+                    url="x", code=413, msg="payload too large", hdrs=None, fp=None
+                )
+            return "ok-content"
+
+        self._install_fake_transport(monkeypatch, fake_post_to_groq)
+        result = groq_bugteam.call_groq_with_fallback("k", [], 0.0, 100)
+        assert result.model == groq_bugteam.GROQ_FALLBACK_MODEL
+        assert attempted_models[0] == groq_bugteam.GROQ_PRIMARY_MODEL
+        assert groq_bugteam.GROQ_FALLBACK_MODEL in attempted_models
+
+    def test_recoverable_error_retries_same_model_then_falls_back(self, monkeypatch):
+        call_log: list[str] = []
+
+        def fake_post_to_groq(api_key, model, messages, temperature, max_completion_tokens):
+            call_log.append(model)
+            raise urllib.error.HTTPError(
+                url="x", code=503, msg="service unavailable", hdrs=None, fp=None
+            )
+
+        self._install_fake_transport(monkeypatch, fake_post_to_groq)
+        with pytest.raises(RuntimeError):
+            groq_bugteam.call_groq_with_fallback("k", [], 0.0, 100)
+        assert call_log.count(groq_bugteam.GROQ_PRIMARY_MODEL) > 1
+        assert groq_bugteam.GROQ_FALLBACK_MODEL in call_log
+
+
+class TestCoerceIndexesToIntSet:
+    def test_coerces_string_indexes_to_ints(self):
+        assert groq_bugteam.coerce_indexes_to_int_set(["0", "2"]) == {0, 2}
+
+    def test_drops_non_numeric_entries(self):
+        assert groq_bugteam.coerce_indexes_to_int_set(["0", "abc", None, 1]) == {0, 1}
+
+    def test_handles_none_input(self):
+        assert groq_bugteam.coerce_indexes_to_int_set(None) == set()
+
+    def test_handles_empty_list(self):
+        assert groq_bugteam.coerce_indexes_to_int_set([]) == set()
+
+    def test_accepts_already_int_values(self):
+        assert groq_bugteam.coerce_indexes_to_int_set([0, 1, 2]) == {0, 1, 2}
+
+
+class TestCoerceSkippedEntries:
+    def test_coerces_string_finding_index_to_int(self):
+        assert groq_bugteam.coerce_skipped_entries(
+            [{"finding_index": "3", "reason": "x"}]
+        ) == {3: "x"}
+
+    def test_drops_entries_without_parseable_index(self):
+        assert groq_bugteam.coerce_skipped_entries(
+            [{"finding_index": "not-a-number", "reason": "x"}]
+        ) == {}
+
+    def test_drops_entries_missing_finding_index(self):
+        assert groq_bugteam.coerce_skipped_entries([{"reason": "orphan"}]) == {}
+
+    def test_defaults_reason_to_empty_string(self):
+        assert groq_bugteam.coerce_skipped_entries([{"finding_index": 1}]) == {1: ""}
+
+    def test_handles_none_input(self):
+        assert groq_bugteam.coerce_skipped_entries(None) == {}
+
+    def test_treats_none_reason_as_empty_string(self):
+        assert groq_bugteam.coerce_skipped_entries(
+            [{"finding_index": 1, "reason": None}]
+        ) == {1: ""}
+
+    def test_stringifies_non_string_reasons(self):
+        assert groq_bugteam.coerce_skipped_entries(
+            [{"finding_index": 1, "reason": 42}]
+        ) == {1: "42"}
+
+
 class TestBuildFixUserMessage:
     def test_embeds_file_content_byte_for_byte_with_trailing_newline(self):
         original_content = "line1\nline2\n"
@@ -370,8 +503,13 @@ class TestDecodeSubprocessStderr:
 
 
 class TestRunPipelineRefusals:
-    def test_rejects_missing_api_key(self, monkeypatch):
+    def test_rejects_missing_api_key(self, monkeypatch, tmp_path):
         monkeypatch.delenv("GROQ_API_KEY", raising=False)
+        monkeypatch.setattr(
+            groq_bugteam_dotenv,
+            "claude_dev_env_dotenv_path",
+            lambda: tmp_path / "missing.env",
+        )
         result = groq_bugteam.run_pipeline({"diff": "anything"})
         assert "error" in result
         assert "GROQ_API_KEY" in result["error"]

package/scripts/test_groq_bugteam_apply_fix_from_spec.py

@@ -0,0 +1,426 @@
+"""Tests for groq_bugteam.apply_fix_from_spec().
+
+Covers the Claude-authored fix-spec pipeline: replacement_code splicing,
+intended_change derivation, acceptance-criterion self-check, out-of-range
+guard, and trailing-newline preservation. All Groq HTTP calls are
+monkeypatched; no network activity.
+"""
+
+from __future__ import annotations
+
+import importlib.util
+import io
+import json
+import pathlib
+import sys
+
+import pytest
+
+
+def _load_groq_bugteam_module():
+    scripts_directory = pathlib.Path(__file__).parent
+    sys.path.insert(0, str(scripts_directory))
+    modules_to_remove = [
+        each_module_name
+        for each_module_name in list(sys.modules)
+        if each_module_name == "groq_bugteam"
+        or each_module_name.startswith("groq_bugteam.")
+    ]
+    for each_module_name in modules_to_remove:
+        del sys.modules[each_module_name]
+    module_path = scripts_directory / "groq_bugteam.py"
+    module_spec = importlib.util.spec_from_file_location("groq_bugteam", module_path)
+    loaded_module = importlib.util.module_from_spec(module_spec)
+    sys.modules["groq_bugteam"] = loaded_module
+    module_spec.loader.exec_module(loaded_module)
+    return loaded_module
+
+
+groq_bugteam = _load_groq_bugteam_module()
+
+
+FAKE_API_KEY = "gsk_test_placeholder_value"
+
+
+def _stub_groq_response(monkeypatch, response_object: dict) -> None:
+    """Force call_groq_with_fallback() to return a synthetic JSON payload."""
+
+    def fake_call(api_key, messages, temperature, max_completion_tokens):
+        return groq_bugteam.GroqCallResult(
+            content=json.dumps(response_object),
+            model="fake-model",
+        )
+
+    monkeypatch.setenv("GROQ_API_KEY", FAKE_API_KEY)
+    monkeypatch.setattr(groq_bugteam, "call_groq_with_fallback", fake_call)
+
+
+class TestApplyFixFromSpecReplacementCode:
+    def test_applies_replacement_code_byte_for_byte_outside_edit(self, monkeypatch):
+        original_file = "line_one\nline_two\nline_three\n"
+        spec_list = [
+            {
+                "finding_index": 0,
+                "severity": "P1",
+                "category": "J",
+                "file": "sample.py",
+                "target_line_start": 2,
+                "target_line_end": 2,
+                "intended_change": "replace line_two",
+                "replacement_code": "line_two_fixed",
+                "acceptance_criteria": ["line_two_fixed appears on line 2"],
+            }
+        ]
+        patched_file = "line_one\nline_two_fixed\nline_three\n"
+        fake_response = {
+            "updated_content": patched_file,
+            "applied_finding_indexes": [0],
+            "skipped": [],
+            "acceptance_checks": [
+                {
+                    "finding_index": 0,
+                    "criterion": "line_two_fixed appears on line 2",
+                    "met": True,
+                }
+            ],
+        }
+        _stub_groq_response(monkeypatch, fake_response)
+
+        outcome = groq_bugteam.apply_fix_from_spec(spec_list, original_file)
+
+        assert outcome["updated_content"] == patched_file
+        assert outcome["applied_finding_indexes"] == [0]
+        assert outcome["skipped"] == []
+
+
+class TestApplyFixFromSpecDerivedEdit:
+    def test_derives_minimal_edit_when_replacement_absent(self, monkeypatch):
+        original_file = "value = 1\nreturn value\n"
+        spec_list = [
+            {
+                "finding_index": 3,
+                "severity": "P2",
+                "category": "E",
+                "file": "sample.py",
+                "target_line_start": 1,
+                "target_line_end": 1,
+                "intended_change": "rename value to total_count",
+                "acceptance_criteria": [
+                    "variable named total_count exists on line 1",
+                    "the literal token value does not appear on line 1",
+                ],
+            }
+        ]
+        patched_file = "total_count = 1\nreturn value\n"
+        fake_response = {
+            "updated_content": patched_file,
+            "applied_finding_indexes": [3],
+            "skipped": [],
+            "acceptance_checks": [
+                {
+                    "finding_index": 3,
+                    "criterion": "variable named total_count exists on line 1",
+                    "met": True,
+                },
+                {
+                    "finding_index": 3,
+                    "criterion": "the literal token value does not appear on line 1",
+                    "met": True,
+                },
+            ],
+        }
+        _stub_groq_response(monkeypatch, fake_response)
+
+        outcome = groq_bugteam.apply_fix_from_spec(spec_list, original_file)
+
+        assert outcome["updated_content"] == patched_file
+        assert outcome["applied_finding_indexes"] == [3]
+
+
+class TestApplyFixFromSpecAcceptanceFailure:
+    def test_moves_finding_to_skipped_when_any_criterion_unmet(self, monkeypatch):
+        original_file = "alpha\nbeta\n"
+        spec_list = [
+            {
+                "finding_index": 7,
+                "severity": "P1",
+                "category": "H",
+                "file": "sample.py",
+                "target_line_start": 2,
+                "target_line_end": 2,
+                "intended_change": "replace beta with gamma",
+                "replacement_code": "gamma",
+                "acceptance_criteria": [
+                    "gamma appears on line 2",
+                    "delta appears on line 2",
+                ],
+            }
+        ]
+        patched_file = "alpha\ngamma\n"
+        fake_response = {
+            "updated_content": patched_file,
+            "applied_finding_indexes": [7],
+            "skipped": [],
+            "acceptance_checks": [
+                {
+                    "finding_index": 7,
+                    "criterion": "gamma appears on line 2",
+                    "met": True,
+                },
+                {
+                    "finding_index": 7,
+                    "criterion": "delta appears on line 2",
+                    "met": False,
+                },
+            ],
+        }
+        _stub_groq_response(monkeypatch, fake_response)
+
+        outcome = groq_bugteam.apply_fix_from_spec(spec_list, original_file)
+
+        assert 7 not in outcome["applied_finding_indexes"]
+        skipped_indexes = [each["finding_index"] for each in outcome["skipped"]]
+        assert 7 in skipped_indexes
+        reason_text = next(
+            each["reason"] for each in outcome["skipped"] if each["finding_index"] == 7
+        )
+        assert "delta appears on line 2" in reason_text
+
+
+class TestApplyFixFromSpecOutOfRange:
+    def test_skips_when_target_lines_out_of_range(self, monkeypatch):
+        original_file = "only_line\n"
+        spec_list = [
+            {
+                "finding_index": 2,
+                "severity": "P2",
+                "category": "E",
+                "file": "sample.py",
+                "target_line_start": 50,
+                "target_line_end": 51,
+                "intended_change": "fix beyond file end",
+                "replacement_code": "noop",
+                "acceptance_criteria": ["noop replaces line 50"],
+            }
+        ]
+        fake_response = {
+            "updated_content": original_file,
+            "applied_finding_indexes": [],
+            "skipped": [
+                {
+                    "finding_index": 2,
+                    "reason": "target_line_start out of range",
+                }
+            ],
+            "acceptance_checks": [],
+        }
+        _stub_groq_response(monkeypatch, fake_response)
+
+        outcome = groq_bugteam.apply_fix_from_spec(spec_list, original_file)
+
+        assert outcome["updated_content"] == original_file
+        assert outcome["applied_finding_indexes"] == []
+        assert outcome["skipped"][0]["finding_index"] == 2
+
+
+class TestApplyFixFromSpecTrailingNewline:
+    def test_preserves_trailing_newline_when_original_had_one(self, monkeypatch):
+        original_file = "alpha\nbeta\n"
+        spec_list = [
+            {
+                "finding_index": 0,
+                "severity": "P1",
+                "category": "J",
+                "file": "sample.py",
+                "target_line_start": 1,
+                "target_line_end": 1,
+                "intended_change": "rename alpha to alpha_fixed",
+                "replacement_code": "alpha_fixed",
+                "acceptance_criteria": ["alpha_fixed appears on line 1"],
+            }
+        ]
+        fake_response = {
+            "updated_content": "alpha_fixed\nbeta",
+            "applied_finding_indexes": [0],
+            "skipped": [],
+            "acceptance_checks": [
+                {
+                    "finding_index": 0,
+                    "criterion": "alpha_fixed appears on line 1",
+                    "met": True,
+                }
+            ],
+        }
+        _stub_groq_response(monkeypatch, fake_response)
+
+        outcome = groq_bugteam.apply_fix_from_spec(spec_list, original_file)
+
+        assert outcome["updated_content"].endswith("\n")
+
+    def test_preserves_absence_of_trailing_newline(self, monkeypatch):
+        original_file = "alpha\nbeta"
+        spec_list = [
+            {
+                "finding_index": 0,
+                "severity": "P1",
+                "category": "J",
+                "file": "sample.py",
+                "target_line_start": 1,
+                "target_line_end": 1,
+                "intended_change": "rename alpha to alpha_fixed",
+                "replacement_code": "alpha_fixed",
+                "acceptance_criteria": ["alpha_fixed appears on line 1"],
+            }
+        ]
+        fake_response = {
+            "updated_content": "alpha_fixed\nbeta\n",
+            "applied_finding_indexes": [0],
+            "skipped": [],
+            "acceptance_checks": [
+                {
+                    "finding_index": 0,
+                    "criterion": "alpha_fixed appears on line 1",
+                    "met": True,
+                }
+            ],
+        }
+        _stub_groq_response(monkeypatch, fake_response)
+
+        outcome = groq_bugteam.apply_fix_from_spec(spec_list, original_file)
+
+        assert not outcome["updated_content"].endswith("\n")
+
+
+class TestApplyFixFromSpecUntrustedResponseShape:
+    def test_skipped_entry_missing_finding_index_does_not_crash(self, monkeypatch):
+        original_file = "alpha\nbeta\n"
+        spec_list = [
+            {
+                "finding_index": 4,
+                "severity": "P1",
+                "category": "J",
+                "file": "sample.py",
+                "target_line_start": 1,
+                "target_line_end": 1,
+                "intended_change": "rename alpha",
+                "replacement_code": "alpha_fixed",
+                "acceptance_criteria": ["alpha_fixed appears on line 1"],
+            }
+        ]
+        patched_file = "alpha_fixed\nbeta\n"
+        fake_response = {
+            "updated_content": patched_file,
+            "applied_finding_indexes": [4],
+            "skipped": [{"reason": "malformed entry without finding_index"}],
+            "acceptance_checks": [
+                {
+                    "finding_index": 4,
+                    "criterion": "alpha_fixed appears on line 1",
+                    "met": True,
+                }
+            ],
+        }
+        _stub_groq_response(monkeypatch, fake_response)
+
+        outcome = groq_bugteam.apply_fix_from_spec(spec_list, original_file)
+
+        assert outcome["updated_content"] == patched_file
+        assert outcome["applied_finding_indexes"] == [4]
+
+    def test_null_updated_content_falls_back_to_current_content(self, monkeypatch):
+        original_file = "alpha\nbeta\n"
+        spec_list = [
+            {
+                "finding_index": 0,
+                "severity": "P2",
+                "category": "E",
+                "file": "sample.py",
+                "target_line_start": 1,
+                "target_line_end": 1,
+                "intended_change": "no-op fallback",
+                "replacement_code": "alpha",
+                "acceptance_criteria": ["alpha remains on line 1"],
+            }
+        ]
+        fake_response = {
+            "updated_content": None,
+            "applied_finding_indexes": [],
+            "skipped": [
+                {
+                    "finding_index": 0,
+                    "reason": "Groq returned null updated_content",
+                }
+            ],
+            "acceptance_checks": [],
+        }
+        _stub_groq_response(monkeypatch, fake_response)
+
+        outcome = groq_bugteam.apply_fix_from_spec(spec_list, original_file)
+
+        assert outcome["updated_content"] == original_file
+
+    def test_null_collection_fields_coerce_to_empty_lists(self, monkeypatch):
+        original_file = "alpha\n"
+        spec_list = [
+            {
+                "finding_index": 1,
+                "severity": "P2",
+                "category": "E",
+                "file": "sample.py",
+                "target_line_start": 1,
+                "target_line_end": 1,
+                "intended_change": "no-op",
+                "replacement_code": "alpha",
+                "acceptance_criteria": ["alpha remains"],
+            }
+        ]
+        fake_response = {
+            "updated_content": original_file,
+            "applied_finding_indexes": None,
+            "skipped": None,
+            "acceptance_checks": None,
+        }
+        _stub_groq_response(monkeypatch, fake_response)
+
+        outcome = groq_bugteam.apply_fix_from_spec(spec_list, original_file)
+
+        assert outcome["applied_finding_indexes"] == []
+        assert outcome["skipped"] == []
+        assert outcome["acceptance_checks"] == []
+
+
+class TestRunSpecModeMainErrorContract:
+    def test_missing_api_key_emits_json_error_and_exits_nonzero(
+        self, monkeypatch, capsys
+    ):
+        monkeypatch.delenv("GROQ_API_KEY", raising=False)
+        monkeypatch.setattr(
+            "groq_bugteam_dotenv.load_claude_dev_env_dotenv_file",
+            lambda: None,
+        )
+        spec_payload = {
+            "spec": [
+                {
+                    "finding_index": 0,
+                    "severity": "P1",
+                    "category": "J",
+                    "file": "sample.py",
+                    "target_line_start": 1,
+                    "target_line_end": 1,
+                    "intended_change": "noop",
+                    "replacement_code": "noop",
+                    "acceptance_criteria": ["noop"],
+                }
+            ],
+            "current_content": "noop\n",
+        }
+        monkeypatch.setattr("sys.stdin", io.StringIO(json.dumps(spec_payload)))
+
+        with pytest.raises(SystemExit) as exit_info:
+            groq_bugteam.run_spec_mode_main()
+
+        captured = capsys.readouterr()
+        emitted_outcome = json.loads(captured.out)
+        assert "error" in emitted_outcome
+        assert "GROQ_API_KEY" in emitted_outcome["error"]
+        assert exit_info.value.code != 0

package/scripts/test_groq_bugteam_dotenv.py

@@ -0,0 +1,66 @@
+"""Tests for groq_bugteam_dotenv local .env loading."""
+
+from __future__ import annotations
+
+import os
+import pathlib
+import sys
+
+import pytest
+
+_SCRIPTS_DIRECTORY = pathlib.Path(__file__).parent.resolve()
+sys.path.insert(0, str(_SCRIPTS_DIRECTORY))
+
+from groq_bugteam_dotenv import (  # noqa: E402
+    claude_dev_env_dotenv_path,
+    load_claude_dev_env_dotenv_file,
+)
+
+
+class TestLoadClaudeDevEnvDotenvFile:
+    def test_sets_groq_key_from_file(self, monkeypatch, tmp_path):
+        monkeypatch.delenv("GROQ_API_KEY", raising=False)
+        env_file = tmp_path / ".env"
+        env_file.write_text("GROQ_API_KEY=from_file_value\n", encoding="utf-8")
+        load_claude_dev_env_dotenv_file(env_file)
+        assert os.environ["GROQ_API_KEY"] == "from_file_value"
+
+    def test_does_not_override_existing_key(self, monkeypatch, tmp_path):
+        monkeypatch.setenv("GROQ_API_KEY", "preset_value")
+        env_file = tmp_path / ".env"
+        env_file.write_text("GROQ_API_KEY=from_file_value\n", encoding="utf-8")
+        load_claude_dev_env_dotenv_file(env_file)
+        assert os.environ["GROQ_API_KEY"] == "preset_value"
+
+    def test_skips_comments_and_blank_lines(self, monkeypatch, tmp_path):
+        monkeypatch.delenv("GROQ_API_KEY", raising=False)
+        env_file = tmp_path / ".env"
+        env_file.write_text("\n# comment\nGROQ_API_KEY=x\n", encoding="utf-8")
+        load_claude_dev_env_dotenv_file(env_file)
+        assert os.environ["GROQ_API_KEY"] == "x"
+
+    def test_strips_export_prefix(self, monkeypatch, tmp_path):
+        monkeypatch.delenv("GROQ_API_KEY", raising=False)
+        env_file = tmp_path / ".env"
+        env_file.write_text("export GROQ_API_KEY=exported\n", encoding="utf-8")
+        load_claude_dev_env_dotenv_file(env_file)
+        assert os.environ["GROQ_API_KEY"] == "exported"
+
+    def test_strips_double_quotes(self, monkeypatch, tmp_path):
+        monkeypatch.delenv("GROQ_API_KEY", raising=False)
+        env_file = tmp_path / ".env"
+        env_file.write_text('GROQ_API_KEY="quoted"\n', encoding="utf-8")
+        load_claude_dev_env_dotenv_file(env_file)
+        assert os.environ["GROQ_API_KEY"] == "quoted"
+
+    def test_missing_file_is_no_op(self, monkeypatch, tmp_path):
+        monkeypatch.delenv("GROQ_API_KEY", raising=False)
+        missing_file = tmp_path / "does_not_exist.env"
+        load_claude_dev_env_dotenv_file(missing_file)
+        assert "GROQ_API_KEY" not in os.environ
+
+
+def test_claude_dev_env_dotenv_path_ends_with_env_filename():
+    resolved = claude_dev_env_dotenv_path()
+    assert resolved.name == ".env"
+    assert resolved.parent.name == "claude-dev-env"