claude-dev-env 2.8.0 → 2.10.0

package/hooks/hooks_constants/test_pytest_invocation.py

@@ -0,0 +1,130 @@
+"""Recognize and allow fixtures for pytest_invocation segment classification."""
+
+from __future__ import annotations
+
+import pytest
+
+from hooks_constants.pytest_invocation import (
+    segment_reports_a_pytest_exit_code,
+    segment_runs_pytest,
+)
+from hooks_constants.shell_command_pipeline import pipeline_segments_for_command
+
+
+def _first_segment_tokens(command: str) -> list[str]:
+    all_pairs = pipeline_segments_for_command(command)
+    assert all_pairs, f"expected at least one segment for {command!r}"
+    return all_pairs[0][0]
+
+
+@pytest.mark.parametrize(
+    "all_segment_tokens",
+    [
+        ["pytest", "tests"],
+        ["pytest.exe", "tests"],
+        ["pytest.bat", "tests"],
+        ["py.test", "tests"],
+        ["python", "-m", "pytest"],
+        ["python", "-mpytest"],
+        ["python3", "-m", "pytest", "tests"],
+        ["pythonw", "-m", "pytest"],
+        ["pypy3", "-m", "pytest", "tests"],
+        ["pypy3", "--jit", "off", "-m", "pytest"],
+        ["py", "-3", "-m", "pytest"],
+        [r"C:\Python313\python.exe", "-m", "pytest"],
+        ["time", "pytest", "tests"],
+        ["sudo", "pytest", "tests"],
+        ["sudo", "-u", "ci", "pytest", "tests"],
+        ["sudo", "-nu", "ci", "pytest", "tests"],
+        ["uv", "run", "pytest", "tests"],
+        ["uv", "run", "--frozen", "pytest", "tests"],
+        ["uv", "tool", "run", "pytest", "tests"],
+        ["uvx", "pytest", "tests"],
+        ["poetry", "run", "pytest", "tests"],
+        ["pipenv", "run", "pytest", "tests"],
+        ["pdm", "run", "pytest", "tests"],
+        ["hatch", "run", "pytest", "tests"],
+        ["rye", "run", "pytest", "tests"],
+        ["coverage", "run", "-m", "pytest", "tests"],
+        ["python", "-m", "coverage", "run", "-m", "pytest"],
+        ["sudo", "uv", "run", "pytest", "tests"],
+    ],
+)
+def test_should_recognize_pytest_invocation_forms(
+    all_segment_tokens: list[str],
+) -> None:
+    assert segment_runs_pytest(all_segment_tokens) is True
+
+
+@pytest.mark.parametrize(
+    "all_segment_tokens",
+    [
+        ["git", "status"],
+        ["python", "-m", "mypy", "."],
+        ["python", "myscript.py", "-m", "pytest"],
+        ["uv", "run", "--with", "pytest", "mypy", "."],
+        ["uv", "sync"],
+        ["uv", "tool", "install", "pytest"],
+        ["coverage", "run", "-m", "mypy", "."],
+        ["coverage", "report"],
+        ["sudo", "apt", "update"],
+        ["pyright", "-m", "pytest", "."],
+        ["echo", "pytest"],
+        ["ls", "pytest"],
+        [],
+    ],
+)
+def test_should_allow_non_pytest_segment_forms(
+    all_segment_tokens: list[str],
+) -> None:
+    assert segment_runs_pytest(all_segment_tokens) is False
+
+
+@pytest.mark.parametrize(
+    "all_segment_tokens",
+    [
+        ["bash", "-c", "pytest tests"],
+        ["bash", "-euc", "pytest tests"],
+        ["bash", "-euo", "pipefail", "-c", "python -m pytest"],
+        ["sh", "-c", "pytest tests"],
+        ["pwsh", "-Command", "pytest tests"],
+        ["cmd", "/c", "python", "-m", "pytest", "tests"],
+    ],
+)
+def test_should_recognize_shell_string_exec_pytest(
+    all_segment_tokens: list[str],
+) -> None:
+    assert segment_reports_a_pytest_exit_code(all_segment_tokens) is True
+
+
+@pytest.mark.parametrize(
+    "all_segment_tokens",
+    [
+        ["bash", "scripts/ci.sh", "-c", "pytest tests"],
+        ["bash", "--", "-c", "pytest tests"],
+        ["bash", "-Cu", "script.sh"],
+        ["pwsh", "-NonInteractive", "-File", "a.ps1"],
+        ["bash", "script.sh"],
+    ],
+)
+def test_should_allow_shell_forms_that_do_not_run_pytest(
+    all_segment_tokens: list[str],
+) -> None:
+    assert segment_reports_a_pytest_exit_code(all_segment_tokens) is False
+
+
+def test_should_classify_segments_from_pipeline_parser() -> None:
+    all_pairs = pipeline_segments_for_command("uv run pytest tests | tee out.log")
+    assert len(all_pairs) >= 2
+    assert segment_runs_pytest(all_pairs[0][0]) is True
+    assert segment_runs_pytest(all_pairs[1][0]) is False
+
+
+def test_should_not_false_classify_option_value_named_pytest() -> None:
+    all_tokens = _first_segment_tokens("uv run --with pytest mypy .")
+    assert segment_runs_pytest(all_tokens) is False
+
+
+def test_should_not_false_classify_script_argument_named_pytest() -> None:
+    all_tokens = _first_segment_tokens("python myscript.py -m pytest")
+    assert segment_runs_pytest(all_tokens) is False

package/hooks/hooks_constants/test_session_start_injector.py

@@ -0,0 +1,168 @@
+"""Tests for the shared SessionStart context injector."""
+
+from __future__ import annotations
+
+
+import pytest
+
+from hooks_constants.session_start_injector import (
+    InjectionResult,
+    InjectorConfiguration,
+    build_additional_context_payload,
+    default_injector_configuration,
+    inject_session_start_context,
+    injector_enabled_in_environment,
+    normalize_session_start_source,
+)
+from hooks_constants.session_start_injector_constants import (
+    INJECTION_STATUS_DISABLED,
+    INJECTION_STATUS_OK,
+    INJECTION_STATUS_TIMEOUT,
+    INJECTION_STATUS_UNKNOWN_SOURCE,
+    SESSION_START_INJECTOR_ENABLED_ENV_VAR,
+    SESSION_START_SOURCE_CLEAR,
+    SESSION_START_SOURCE_COMPACT,
+    SESSION_START_SOURCE_RESUME,
+    SESSION_START_SOURCE_STARTUP,
+    SESSION_START_SOURCE_UNKNOWN,
+)
+
+
+def _configuration(
+    *,
+    is_enabled: bool = True,
+    timeout_milliseconds: int = 50,
+    context_by_source: dict[str, str] | None = None,
+    default_context_for_unknown: str = "",
+) -> InjectorConfiguration:
+    return InjectorConfiguration(
+        is_enabled=is_enabled,
+        timeout_milliseconds=timeout_milliseconds,
+        context_by_source=context_by_source
+        or {
+            SESSION_START_SOURCE_STARTUP: "startup-context",
+            SESSION_START_SOURCE_RESUME: "resume-context",
+            SESSION_START_SOURCE_CLEAR: "clear-context",
+            SESSION_START_SOURCE_COMPACT: "compact-context",
+        },
+        default_context_for_unknown=default_context_for_unknown,
+    )
+
+
+def _fixed_clock(all_readings: list[float]) -> object:
+    index = {"value": 0}
+
+    def _read() -> float:
+        reading = all_readings[min(index["value"], len(all_readings) - 1)]
+        index["value"] += 1
+        return reading
+
+    return _read
+
+
+@pytest.mark.parametrize(
+    ("source", "expected_context"),
+    [
+        (SESSION_START_SOURCE_STARTUP, "startup-context"),
+        (SESSION_START_SOURCE_RESUME, "resume-context"),
+        (SESSION_START_SOURCE_CLEAR, "clear-context"),
+        (SESSION_START_SOURCE_COMPACT, "compact-context"),
+    ],
+)
+def test_inject_known_source_returns_ok_with_context(
+    source: str, expected_context: str
+) -> None:
+    result = inject_session_start_context(
+        {"source": source},
+        _configuration(),
+        clock=_fixed_clock([1.0, 1.002]),
+    )
+    assert result.status == INJECTION_STATUS_OK
+    assert result.source == source
+    assert result.additional_context == expected_context
+    assert result.is_context_injected is True
+    assert result.latency_milliseconds == pytest.approx(2.0)
+
+
+def test_inject_disabled_returns_quickly_without_context() -> None:
+    result = inject_session_start_context(
+        {"source": SESSION_START_SOURCE_STARTUP},
+        _configuration(is_enabled=False),
+        clock=_fixed_clock([0.0, 0.0001]),
+    )
+    assert result.status == INJECTION_STATUS_DISABLED
+    assert result.additional_context == ""
+    assert result.is_context_injected is False
+    assert result.latency_milliseconds < 1.0
+
+
+def test_inject_timeout_budget_zero_returns_timeout() -> None:
+    result = inject_session_start_context(
+        {"source": SESSION_START_SOURCE_RESUME},
+        _configuration(timeout_milliseconds=0),
+        clock=_fixed_clock([0.0, 0.0]),
+    )
+    assert result.status == INJECTION_STATUS_TIMEOUT
+    assert result.is_context_injected is False
+
+
+def test_inject_unknown_source_is_explicit() -> None:
+    result = inject_session_start_context(
+        {"source": "not-a-real-source"},
+        _configuration(default_context_for_unknown="fallback"),
+        clock=_fixed_clock([0.0, 0.001]),
+    )
+    assert result.status == INJECTION_STATUS_UNKNOWN_SOURCE
+    assert result.source == SESSION_START_SOURCE_UNKNOWN
+    assert result.additional_context == "fallback"
+    assert result.is_context_injected is True
+
+
+def test_normalize_session_start_source_handles_missing_and_case() -> None:
+    assert normalize_session_start_source({}) == SESSION_START_SOURCE_UNKNOWN
+    assert (
+        normalize_session_start_source({"source": " STARTUP "})
+        == SESSION_START_SOURCE_STARTUP
+    )
+    assert normalize_session_start_source({"source": 12}) == SESSION_START_SOURCE_UNKNOWN
+
+
+def test_build_additional_context_payload_only_when_injected() -> None:
+    injected = InjectionResult(
+        source=SESSION_START_SOURCE_STARTUP,
+        status=INJECTION_STATUS_OK,
+        additional_context="hello",
+        latency_milliseconds=1.0,
+        is_context_injected=True,
+    )
+    empty = InjectionResult(
+        source=SESSION_START_SOURCE_STARTUP,
+        status=INJECTION_STATUS_DISABLED,
+        additional_context="",
+        latency_milliseconds=0.1,
+        is_context_injected=False,
+    )
+    assert build_additional_context_payload(injected) == {
+        "additionalContext": "hello"
+    }
+    assert build_additional_context_payload(empty) == {}
+
+
+def test_injector_enabled_in_environment_default_on(
+    monkeypatch: pytest.MonkeyPatch,
+) -> None:
+    monkeypatch.delenv(SESSION_START_INJECTOR_ENABLED_ENV_VAR, raising=False)
+    assert injector_enabled_in_environment() is True
+    monkeypatch.setenv(SESSION_START_INJECTOR_ENABLED_ENV_VAR, "0")
+    assert injector_enabled_in_environment() is False
+    monkeypatch.setenv(SESSION_START_INJECTOR_ENABLED_ENV_VAR, "true")
+    assert injector_enabled_in_environment() is True
+
+
+def test_default_injector_configuration_reads_env(
+    monkeypatch: pytest.MonkeyPatch,
+) -> None:
+    monkeypatch.setenv(SESSION_START_INJECTOR_ENABLED_ENV_VAR, "off")
+    configuration = default_injector_configuration()
+    assert configuration.is_enabled is False
+

package/hooks/hooks_constants/test_shell_command_pipeline.py

@@ -0,0 +1,135 @@
+"""Real command fixtures for the quote-aware shell pipeline parser.
+
+Covers quotes, operators, heredocs, continuations, groups, wrappers, and
+compound shells. No pytest-specific classification runs here.
+"""
+
+from __future__ import annotations
+
+import pathlib
+import sys
+
+_HOOKS_ROOT = pathlib.Path(__file__).resolve().parent.parent
+if str(_HOOKS_ROOT) not in sys.path:
+    sys.path.insert(0, str(_HOOKS_ROOT))
+
+from hooks_constants.shell_command_pipeline import (  # noqa: E402
+    all_operator_aware_tokenizations,
+    join_line_continuations,
+    live_command_lines,
+    pipeline_segments_for_command,
+    scannable_command_lines,
+    segments_with_following_operator,
+)
+from hooks_constants.shell_command_segments import (  # noqa: E402
+    split_into_segments,
+)
+
+
+def test_pipe_segments_pair_with_following_operator() -> None:
+    all_tokens = ["pytest", "tests", "|", "tee", "out.log"]
+    all_pairs = segments_with_following_operator(all_tokens)
+    assert all_pairs[0] == (["pytest", "tests"], "|")
+    assert all_pairs[1] == (["tee", "out.log"], "")
+
+
+def test_quoted_pipe_inside_k_expression_stays_in_one_segment() -> None:
+    """Quote-aware tokenization keeps pytest -k \"a|b\" as one segment."""
+    command = 'pytest -k "a|b" tests'
+    all_tokenizations = all_operator_aware_tokenizations(command)
+    assert all_tokenizations
+    all_pairs = segments_with_following_operator(all_tokenizations[0])
+    assert len(all_pairs) == 1
+    segment_tokens, following_operator = all_pairs[0]
+    assert following_operator == ""
+    assert any("a|b" in each_token or each_token == "a|b" for each_token in segment_tokens)
+
+
+def test_quote_unaware_segments_split_on_pipe_inside_quotes() -> None:
+    """Divergence: shell_command_segments peels | inside a|b; quote-aware path does not."""
+    all_segments = split_into_segments(["pytest", "-k", "a|b", "tests"])
+    assert len(all_segments) > 1
+    quote_aware_pairs = pipeline_segments_for_command('pytest -k "a|b" tests')
+    assert len(quote_aware_pairs) >= 1
+    assert all(each_operator != "|" for _, each_operator in quote_aware_pairs)
+
+
+def test_heredoc_body_is_dropped_from_live_lines() -> None:
+    all_lines = [
+        "cat > run.sh <<'EOF'",
+        "pytest tests | tee out.log",
+        "EOF",
+        "echo done",
+    ]
+    assert live_command_lines(all_lines) == ["cat > run.sh <<'EOF'", "echo done"]
+
+
+def test_scannable_lines_drop_heredoc_body_and_keep_later_command() -> None:
+    command = "cat > run.sh <<'EOF'\npytest tests | tee out.log\nEOF\necho done"
+    all_lines = scannable_command_lines(join_line_continuations(command))
+    assert "pytest tests | tee out.log" not in all_lines
+    assert any("echo done" in each_line for each_line in all_lines)
+
+
+def test_line_continuation_joins_pipe_onto_one_line() -> None:
+    command = "echo hi \\\n| cat"
+    joined = join_line_continuations(command)
+    assert "\n" not in joined
+    assert "| cat" in joined
+
+
+def test_comment_does_not_hide_following_line() -> None:
+    command = "echo hi  # note\necho bye"
+    all_lines = scannable_command_lines(command)
+    assert any("echo bye" in each_line for each_line in all_lines)
+    assert all("# note" not in each_line for each_line in all_lines)
+
+
+def test_paren_group_joins_multiline_subshell_before_pipe() -> None:
+    command = "(\necho hi\n) | cat"
+    all_lines = scannable_command_lines(command)
+    assert len(all_lines) == 1
+    assert "|" in all_lines[0]
+    assert "echo hi" in all_lines[0]
+
+
+def test_glued_close_paren_and_pipe_split_into_operator_token() -> None:
+    all_pairs = segments_with_following_operator(["(", "echo", "hi", ")|", "cat"])
+    assert any(each_operator == "|" for _, each_operator in all_pairs)
+
+
+def test_and_operator_resets_segment() -> None:
+    all_pairs = segments_with_following_operator(
+        ["echo", "a", "&&", "echo", "b"]
+    )
+    assert all_pairs[0] == (["echo", "a"], "&&")
+    assert all_pairs[1][0] == ["echo", "b"]
+
+
+def test_pipeline_segments_for_command_on_simple_pipe() -> None:
+    all_pairs = pipeline_segments_for_command("echo hi | cat")
+    leading_programs = [
+        each_segment[0] for each_segment, _ in all_pairs if each_segment
+    ]
+    assert "echo" in leading_programs
+    assert "cat" in leading_programs
+    assert any(each_operator == "|" for _, each_operator in all_pairs)
+
+
+def test_wrapper_tokens_remain_visible_in_segment() -> None:
+    """Wrappers stay in the segment; classification is a later slice."""
+    all_pairs = pipeline_segments_for_command("sudo -n echo hi | cat")
+    first_pipe_segment = next(
+        each_segment for each_segment, each_operator in all_pairs if each_operator == "|"
+    )
+    assert first_pipe_segment[0] in {"sudo", "sudo.exe"} or "sudo" in first_pipe_segment[0]
+
+
+def test_compound_shell_if_fi_tokens_survive_tokenization() -> None:
+    command = "if true; then echo hi; fi"
+    all_tokenizations = all_operator_aware_tokenizations(command)
+    assert all_tokenizations
+    flat_tokens = all_tokenizations[0]
+    assert "if" in flat_tokens
+    assert "then" in flat_tokens
+    assert "fi" in flat_tokens

package/hooks/hooks_constants/volatile_path_in_post_blocker_constants.py

@@ -24,7 +24,7 @@ PATH_ANCHOR_CHARACTER: str = "/"
 PATH_SEGMENT_START_CHARACTERS: str = "_-"
 
 ALL_PATH_ANCHORED_VOLATILE_PATH_MARKERS: tuple[str, ...] = (
-    ".claude-editor/jobs/",
+    ".claude-profile-a/jobs/",
     ".claude/worktrees/",
 )
 

package/hooks/hooks_constants/working_style_prompt_constants.py

@@ -0,0 +1,30 @@
+"""Working-style prompt text for the SessionStart working_style_prompt hook."""
+
+from __future__ import annotations
+
+__all__ = [
+    "WORKING_STYLE_PROMPT",
+]
+
+WORKING_STYLE_PROMPT = (
+    "document everything in a location you can find later, rather than relying on "
+    "memory. scratch txt file you'll keep running as you go; ledger, if you will."
+    "Always, without exception, write in plain english. Keep responses focused, "
+    "brief, and concise. Keep disclaimers and caveats short, and spend most of the "
+    "response on the main answer. When asked to explain something, give a high-level "
+    "summary unless an in-depth explanation is specifically requested."
+    "Before your first tool call, say in one sentence what you're about to do. While "
+    "working, give a brief update only when you find something important or change "
+    "direction. When you finish, lead with the outcome: your first sentence should "
+    "answer \"what happened\" or \"what did you find,\" with supporting detail after "
+    "it for readers who want it."
+    "Match the length of written documents to what the task needs: cover the "
+    "substance, but do not pad with filler sections, redundant summaries, or "
+    "boilerplate."
+    "Deliver what was asked, at the scope intended. Make routine judgment calls "
+    "yourself, and check in only when different readings of the request would lead "
+    "to materially different work. If the request seems mistaken or a better "
+    "approach exists, say so in a sentence and continue with the task as asked "
+    "rather than quietly narrowing, widening, or transforming it. Finish the whole "
+    "task, and stop short of actions that are clearly beyond what was asked."
+)

package/hooks/observability/CLAUDE.md

@@ -8,8 +8,10 @@ PostToolUse hooks that record agent behavior for later review. These hooks do no
 |---|---|---|
 | `instructions_loaded_logger.py` | PostToolUse (file load events) | Appends a JSONL record to `~/.claude/logs/instructions_loaded.jsonl` each time Claude Code loads a context file (CLAUDE.md, rules, skills), capturing the file path, load reason, memory type, and session ID |
 | `session_file_edit_tracker.py` | PostToolUse (Write/Edit/MultiEdit) | Records the resolved absolute path of each file edited this session into a per-session JSON file under the system temp directory, for the session edit stage gate to read at commit time |
+| `prose_matcher_advisory.py` | Advisory emit from prose matchers | Privacy-safe JSONL candidates (`matcher_id`, surface, context fingerprint, label) plus keep/narrow/drop/advisory classification against the sample floor |
 | `test_instructions_loaded_logger.py` | — | Tests for `instructions_loaded_logger.py` |
 | `test_session_file_edit_tracker.py` | — | Tests for `session_file_edit_tracker.py` |
+| `test_prose_matcher_advisory.py` | — | Tests for advisory emit and precision classification |
 
 ## Conventions