claude-dev-env 7.0.0 → 7.2.0

package/hooks/blocking/orchestrator_refresh_reschedule_gate.py

@@ -1,260 +0,0 @@
-#!/usr/bin/env python3
-"""PreToolUse gate: deny orchestrator-refresh re-arm when the run is not active.
-
-Fires on ``ScheduleWakeup`` and ``CronCreate`` when the prompt targets
-``/orchestrator-refresh``. Uses the same status-file gate as
-``skills/orchestrator/scripts/status_gate.py`` so idle loops
-cannot be re-armed on the Claude host without an active status file.
-"""
-
-from __future__ import annotations
-
-import importlib.util
-import json
-import os
-import re
-import sys
-from pathlib import Path
-from types import ModuleType
-from typing import Mapping
-
-_hooks_dir = str(Path(__file__).resolve().parent.parent)
-if _hooks_dir not in sys.path:
-    sys.path.insert(0, _hooks_dir)
-
-from hooks_constants.hook_block_logger import log_hook_block  # noqa: E402
-from hooks_constants.orchestrator_refresh_reschedule_gate_constants import (  # noqa: E402
-    ALL_HOME_SKILLS_RELATIVE_PARTS,
-    ALL_PACKAGE_AGENTS_SKILL_SCRIPTS_RELATIVE_PARTS,
-    ALL_SCHEDULE_TOOL_NAMES,
-    ALL_SKILL_SCRIPTS_RELATIVE_PARTS,
-    CALLING_HOOK_NAME,
-    CRON_CREATE_TOOL_NAME,
-    CWD_FIELD_NAME,
-    DENY_REASON_TEMPLATE,
-    HOOK_EVENT_NAME,
-    ORCHESTRATOR_REFRESH_PROMPT_TOKEN,
-    PLUGIN_ROOT_ENV_VAR,
-    PROMPT_FIELD_NAME,
-    REASON_CRON_CREATE_FORBIDDEN,
-    RUN_SLUG_PROMPT_FLAG,
-    RUN_SLUG_PROMPT_VALUE_PATTERN,
-    TOOL_INPUT_FIELD_NAME,
-    TOOL_NAME_FIELD_NAME,
-)
-
-
-def _candidate_skill_script_directories() -> list[Path]:
-    """Return ordered paths that may contain status_gate.py.
-
-    Returns:
-        Absolute candidate directories in preference order.
-    """
-    all_candidates: list[Path] = []
-    plugin_root = os.environ.get(PLUGIN_ROOT_ENV_VAR)
-    relative_skill_script_layouts = (
-        ALL_PACKAGE_AGENTS_SKILL_SCRIPTS_RELATIVE_PARTS,
-        ALL_SKILL_SCRIPTS_RELATIVE_PARTS,
-    )
-    if plugin_root:
-        plugin_root_path = Path(plugin_root)
-        for each_relative_parts in relative_skill_script_layouts:
-            all_candidates.append(plugin_root_path.joinpath(*each_relative_parts))
-    package_hooks_parent = Path(__file__).resolve().parents[2]
-    for each_relative_parts in relative_skill_script_layouts:
-        all_candidates.append(package_hooks_parent.joinpath(*each_relative_parts))
-    all_candidates.append(Path.home().joinpath(*ALL_HOME_SKILLS_RELATIVE_PARTS))
-    return all_candidates
-
-
-def _load_status_gate_module() -> ModuleType | None:
-    """Import status_gate from the skill scripts package.
-
-    Returns:
-        The loaded module, or None when no candidate path is usable.
-    """
-    for each_directory in _candidate_skill_script_directories():
-        module_path = each_directory / "status_gate.py"
-        if not module_path.is_file():
-            continue
-        scripts_directory = str(each_directory)
-        if scripts_directory not in sys.path:
-            sys.path.insert(0, scripts_directory)
-        spec = importlib.util.spec_from_file_location(
-            "orchestrator_status_gate_for_reschedule_hook",
-            module_path,
-        )
-        if spec is None or spec.loader is None:
-            continue
-        status_gate_module = importlib.util.module_from_spec(spec)
-        sys.modules[spec.name] = status_gate_module
-        spec.loader.exec_module(status_gate_module)
-        return status_gate_module
-    return None
-
-
-def _prompt_targets_orchestrator_refresh(
-    all_tool_input: Mapping[str, object],
-) -> bool:
-    """Return True when the schedule prompt re-enters orchestrator-refresh.
-
-    Args:
-        all_tool_input: PreToolUse tool_input mapping.
-
-    Returns:
-        True when the prompt field contains the refresh skill token.
-    """
-    prompt_value = all_tool_input.get(PROMPT_FIELD_NAME, "")
-    if not isinstance(prompt_value, str):
-        return False
-    stripped_prompt = prompt_value.lstrip()
-    if not stripped_prompt.startswith(ORCHESTRATOR_REFRESH_PROMPT_TOKEN):
-        return False
-    if len(stripped_prompt) == len(ORCHESTRATOR_REFRESH_PROMPT_TOKEN):
-        return True
-    return stripped_prompt[len(ORCHESTRATOR_REFRESH_PROMPT_TOKEN)] in (" ", "\n", "\t")
-
-
-def _should_evaluate(all_payload_by_field: Mapping[str, object]) -> bool:
-    """Return True for schedule tools re-arming orchestrator-refresh.
-
-    Args:
-        all_payload_by_field: Full PreToolUse payload.
-
-    Returns:
-        True when this gate must run.
-    """
-    tool_name = all_payload_by_field.get(TOOL_NAME_FIELD_NAME, "")
-    if tool_name not in ALL_SCHEDULE_TOOL_NAMES:
-        return False
-    tool_input = all_payload_by_field.get(TOOL_INPUT_FIELD_NAME, {})
-    if not isinstance(tool_input, dict):
-        return False
-    return _prompt_targets_orchestrator_refresh(tool_input)
-
-
-def _run_slug_from_prompt(prompt_value: str) -> str:
-    """Extract ``--run-slug`` from a ScheduleWakeup prompt when present.
-
-    Args:
-        prompt_value: The schedule tool prompt text.
-
-    Returns:
-        The slug string, or empty when the flag is absent.
-    """
-    run_slug_from_prompt_pattern = re.compile(
-        re.escape(RUN_SLUG_PROMPT_FLAG) + RUN_SLUG_PROMPT_VALUE_PATTERN
-    )
-    matched = run_slug_from_prompt_pattern.search(prompt_value)
-    if matched is None:
-        return ""
-    return matched.group(1)
-
-
-def _resolve_status_file_path(
-    status_gate_module: ModuleType,
-    all_payload_by_field: Mapping[str, object],
-) -> Path:
-    """Resolve the run status file for this schedule attempt without chdir.
-
-    Args:
-        status_gate_module: Loaded status_gate module.
-        all_payload_by_field: PreToolUse payload (may carry cwd and prompt).
-
-    Returns:
-        Absolute status file path.
-    """
-    base_directory: Path | None = None
-    working_directory_value = all_payload_by_field.get(CWD_FIELD_NAME)
-    if isinstance(working_directory_value, str) and working_directory_value:
-        base_directory = Path(working_directory_value)
-    run_slug = ""
-    tool_input = all_payload_by_field.get(TOOL_INPUT_FIELD_NAME, {})
-    if isinstance(tool_input, dict):
-        prompt_value = tool_input.get(PROMPT_FIELD_NAME, "")
-        if isinstance(prompt_value, str):
-            run_slug = _run_slug_from_prompt(prompt_value)
-    return status_gate_module.resolve_status_file_path(
-        None, base_directory, run_slug
-    )
-
-
-def build_denial_response(reason_code: str) -> dict[str, dict[str, str]]:
-    """Build the PreToolUse deny payload.
-
-    Args:
-        reason_code: Machine reason from decide_should_reschedule.
-
-    Returns:
-        Hook-specific deny JSON structure.
-    """
-    denial_reason = DENY_REASON_TEMPLATE.format(reason=reason_code)
-    return {
-        "hookSpecificOutput": {
-            "hookEventName": HOOK_EVENT_NAME,
-            "permissionDecision": "deny",
-            "permissionDecisionReason": denial_reason,
-        }
-    }
-
-
-def _emit_denial(
-    reason_code: str,
-    all_payload_by_field: Mapping[str, object],
-) -> None:
-    """Log and print a deny decision for the current schedule attempt.
-
-    Args:
-        reason_code: Machine reason string.
-        all_payload_by_field: PreToolUse payload for logging context.
-    """
-    denial = build_denial_response(reason_code)
-    hook_specific_output = denial["hookSpecificOutput"]
-    block_reason = hook_specific_output["permissionDecisionReason"]
-    log_hook_block(
-        calling_hook_name=CALLING_HOOK_NAME,
-        hook_event=HOOK_EVENT_NAME,
-        block_reason=block_reason,
-        tool_name=str(all_payload_by_field.get(TOOL_NAME_FIELD_NAME, "")),
-        offending_input_preview=str(
-            all_payload_by_field.get(TOOL_INPUT_FIELD_NAME, {})
-        ),
-    )
-    print(json.dumps(denial))
-
-
-def main() -> None:
-    """Read PreToolUse stdin and deny idle orchestrator-refresh re-arms."""
-    try:
-        payload_by_field = json.load(sys.stdin)
-    except json.JSONDecodeError:
-        sys.exit(0)
-
-    if not isinstance(payload_by_field, dict):
-        sys.exit(0)
-    if not _should_evaluate(payload_by_field):
-        sys.exit(0)
-
-    tool_name = payload_by_field.get(TOOL_NAME_FIELD_NAME, "")
-    if tool_name == CRON_CREATE_TOOL_NAME:
-        _emit_denial(REASON_CRON_CREATE_FORBIDDEN, payload_by_field)
-        sys.exit(0)
-
-    status_gate_module = _load_status_gate_module()
-    if status_gate_module is None:
-        _emit_denial("status_gate_unavailable", payload_by_field)
-        sys.exit(0)
-
-    status_file_path = _resolve_status_file_path(status_gate_module, payload_by_field)
-    is_reschedule_allowed, reason_code = status_gate_module.decide_should_reschedule(
-        status_file_path
-    )
-    if is_reschedule_allowed:
-        sys.exit(0)
-
-    _emit_denial(reason_code, payload_by_field)
-    sys.exit(0)
-
-
-if __name__ == "__main__":
-    main()

package/hooks/blocking/package_inventory_stale_blocker.py

@@ -1,107 +0,0 @@
-#!/usr/bin/env python3
-"""PreToolUse hook: blocks a new production file absent from its package inventory.
-
-A package directory documents its own files in a sibling inventory document — a
-``README.md`` Layout table, a ``CLAUDE.md`` "Key files" list, or a skill
-``SKILL.md`` Layout table that maps the ``scripts/`` subdirectory — whose entries
-name each file in backticks. When a Write creates a new production code file in a
-directory whose inventory already names two or more sibling files but carries no
-entry naming the new file, the inventory and the directory disagree on the
-package's file set: a reader who trusts the inventory to map the directory misses
-the new file. This hook fires on a Write that creates such a file and blocks it,
-directing the author to add the inventory entry in the same change. Edits to an
-existing file, exempt files (``__init__.py``, ``conftest.py``, ``setup.py``,
-``_path_setup.py``), test files, and files inside a directory that carries no
-per-file inventory (such as ``config/`` or ``tests/``) are out of scope.
-"""
-
-import os
-import sys
-from pathlib import Path
-
-try:
-    _hooks_root_directory = str(Path(__file__).resolve().parent.parent)
-    _blocking_directory = str(Path(__file__).resolve().parent)
-    for each_bootstrap_directory in (_hooks_root_directory, _blocking_directory):
-        if each_bootstrap_directory not in sys.path:
-            sys.path.insert(0, each_bootstrap_directory)
-    from inventory_intent_records import records
-    from package_inventory_stale_blocker_parts import decision, inventory_detection
-
-    from hooks_constants.pre_tool_use_stdin import (
-        read_hook_input_dictionary_from_stdin,
-    )
-except ImportError as import_error:
-    raise ImportError(
-        "package_inventory_stale_blocker: cannot import its parts submodules; "
-        "ensure the hooks directory is importable."
-    ) from import_error
-
-
-inventory_named_basenames = inventory_detection.inventory_named_basenames
-is_inventoried_production_file = inventory_detection.is_inventoried_production_file
-find_stale_inventory = inventory_detection.find_stale_inventory
-survey_directory_inventories = inventory_detection.survey_directory_inventories
-deny_stale_inventory = decision.deny_stale_inventory
-
-
-def _resolve_payload(input_data: dict) -> tuple[str, dict, str]:
-    """Return the tool name, tool input, and file path from a PreToolUse payload.
-
-    Args:
-        input_data: The parsed PreToolUse payload.
-
-    Returns:
-        The tool name, the tool input dict, and the file path — each emptied when
-        its value is absent or the wrong type.
-    """
-    raw_tool_name = input_data.get("tool_name", "")
-    tool_name = raw_tool_name if isinstance(raw_tool_name, str) else ""
-    tool_input = input_data.get("tool_input", {})
-    if not isinstance(tool_input, dict):
-        return tool_name, {}, ""
-    file_path = tool_input.get("file_path", "")
-    if not isinstance(file_path, str):
-        return tool_name, tool_input, ""
-    return tool_name, tool_input, file_path
-
-
-def _emit_stale_decision(
-    input_data: dict, file_path: str, survey: inventory_detection._InventorySurvey
-) -> None:
-    """Allow the write when a pending row intent matches, else record and deny.
-
-    Args:
-        input_data: The parsed PreToolUse payload.
-        file_path: The destination path of the new file.
-        survey: The maintained-inventory survey the file is absent from.
-    """
-    session_id = str(input_data.get("session_id") or "")
-    directory = str(Path(file_path).resolve().parent)
-    filename = os.path.basename(file_path)
-    if records.has_fresh_row_intent(session_id, directory, filename):
-        records.consume_row_intent(session_id, directory, filename)
-        return
-    records.record_file_intent(session_id, directory, filename)
-    deny_stale_inventory(file_path, survey)
-
-
-def main() -> None:
-    """Read the PreToolUse payload from stdin and block a stale-inventory Write."""
-    input_data = read_hook_input_dictionary_from_stdin()
-    if input_data is None:
-        sys.exit(0)
-    tool_name, _tool_input, file_path = _resolve_payload(input_data)
-    if tool_name != "Write" or not file_path:
-        sys.exit(0)
-    if os.path.exists(file_path) or not is_inventoried_production_file(file_path):
-        sys.exit(0)
-    survey = find_stale_inventory(file_path)
-    if survey is None:
-        sys.exit(0)
-    _emit_stale_decision(input_data, file_path, survey)
-    sys.exit(0)
-
-
-if __name__ == "__main__":
-    main()