claude-dev-env 2.27.0 → 2.28.1

package/hooks/blocking/code_rules_unused_imports.py

@@ -1,197 +0,0 @@
-"""Unused module-level import check and its import-range helpers."""
-
-import ast
-import sys
-from pathlib import Path
-
-_blocking_directory = str(Path(__file__).resolve().parent)
-_hooks_directory = str(Path(__file__).resolve().parent.parent)
-if _blocking_directory not in sys.path:
-    sys.path.insert(0, _blocking_directory)
-if _hooks_directory not in sys.path:
-    sys.path.insert(0, _hooks_directory)
-
-from code_rules_scope_binding import (  # noqa: E402
-    _attribute_root_name_if_loaded,
-    _collect_string_annotation_names,
-    _load_name_is_shadowed,
-)
-from code_rules_shared import (  # noqa: E402
-    _build_parent_map,
-    is_migration_file,
-)
-
-from hooks_constants.unused_module_import_constants import (  # noqa: E402
-    MAX_UNUSED_IMPORT_ISSUES,
-    UNUSED_IMPORT_GUIDANCE,
-    line_suppresses_unused_import_via_noqa,
-)
-
-
-def _import_alias_pairs(
-    import_node: ast.Import | ast.ImportFrom,
-) -> list[tuple[str, int, int | None]]:
-    """Return (binding_name, alias_line, from_keyword_line) for each name introduced.
-
-    The from-keyword line is None for plain `import X` statements; for
-    `from X import (...)` it carries the line of the `from` keyword so
-    callers can honor a `# noqa` placed on the opening line of a
-    multi-line import block.
-    """
-    bindings: list[tuple[str, int, int | None]] = []
-    from_keyword_line = import_node.lineno if isinstance(import_node, ast.ImportFrom) else None
-    for each_alias in import_node.names:
-        if each_alias.name == "*":
-            continue
-        binding_name = each_alias.asname if each_alias.asname else each_alias.name.split(".")[0]
-        alias_line = each_alias.lineno or import_node.lineno
-        bindings.append((binding_name, alias_line, from_keyword_line))
-    return bindings
-
-
-def _import_statement_line_ranges(tree: ast.Module) -> list[tuple[int, int]]:
-    ranges: list[tuple[int, int]] = []
-    for each_node in tree.body:
-        if isinstance(each_node, (ast.Import, ast.ImportFrom)):
-            start_line = each_node.lineno
-            end_line = each_node.end_lineno or each_node.lineno
-            ranges.append((start_line, end_line))
-    return ranges
-
-
-def _line_number_falls_in_import_ranges(
-    line_number: int,
-    all_import_line_ranges: list[tuple[int, int]],
-) -> bool:
-    for each_start, each_end in all_import_line_ranges:
-        if each_start <= line_number <= each_end:
-            return True
-    return False
-
-
-def _collect_load_names_outside_import_ranges(
-    tree: ast.Module,
-    all_import_line_ranges: list[tuple[int, int]],
-) -> set[str]:
-    parent_by_node_id = _build_parent_map(tree)
-    referenced_names: set[str] = set()
-    for each_node in ast.walk(tree):
-        if isinstance(each_node, ast.Name) and isinstance(each_node.ctx, ast.Load):
-            line_number = each_node.lineno
-            if line_number is None or _line_number_falls_in_import_ranges(
-                line_number,
-                all_import_line_ranges,
-            ):
-                continue
-            if _load_name_is_shadowed(each_node, each_node.id, parent_by_node_id):
-                continue
-            referenced_names.add(each_node.id)
-        elif isinstance(each_node, ast.Attribute) and isinstance(
-            each_node.ctx, ast.Load
-        ):
-            line_number = each_node.lineno
-            if line_number is None or _line_number_falls_in_import_ranges(
-                line_number,
-                all_import_line_ranges,
-            ):
-                continue
-            root_name = _attribute_root_name_if_loaded(each_node)
-            if root_name is not None and not _load_name_is_shadowed(
-                root_name,
-                root_name.id,
-                parent_by_node_id,
-            ):
-                referenced_names.add(root_name.id)
-    referenced_names.update(_collect_string_annotation_names(tree))
-    return referenced_names
-
-
-def _module_declares_dunder_all(tree: ast.Module) -> bool:
-    """Return True when the module body assigns or annotates ``__all__``."""
-    return any(
-        (
-            isinstance(each_node, ast.Assign)
-            and any(
-                isinstance(each_target, ast.Name) and each_target.id == "__all__"
-                for each_target in each_node.targets
-            )
-        )
-        or (
-            isinstance(each_node, ast.AnnAssign)
-            and isinstance(each_node.target, ast.Name)
-            and each_node.target.id == "__all__"
-        )
-        for each_node in tree.body
-    )
-
-
-def check_unused_module_level_imports(
-    content: str,
-    file_path: str,
-    full_file_content: str | None = None,
-) -> list[str]:
-    """Flag module-level imports that are never referenced in the rest of the file.
-
-    References are detected from AST ``Name`` / ``Attribute`` loads outside import
-    statements so mentions in comments or string literals do not count. Files
-    declaring ``__all__`` (including annotated assignments) are skipped. A
-    ``if TYPE_CHECKING:`` block does not exempt the file: its guarded imports
-    are nested inside the ``If`` node and are never scanned as top-level
-    bindings, while a dead top-level runtime import in the same file is still
-    flagged. Suppression honors bare ``# noqa`` or an explicit ``F401`` code in
-    the noqa list only.
-
-    When ``full_file_content`` is provided, ``content`` is treated as an Edit
-    fragment containing the imports being added or replaced, while the
-    ``__all__`` gate detection and reference scanning run
-    against ``full_file_content`` (the post-edit file as it will look once the
-    Edit applies). This prevents false-positive flags on imports added in the
-    same Edit as their consumers.
-    """
-    if is_migration_file(file_path):
-        return []
-    try:
-        fragment_tree = ast.parse(content)
-    except SyntaxError:
-        return []
-    reference_source = full_file_content if full_file_content is not None else content
-    try:
-        reference_tree = ast.parse(reference_source)
-    except SyntaxError:
-        return []
-    if _module_declares_dunder_all(reference_tree):
-        return []
-    fragment_lines = content.splitlines()
-    reference_import_ranges = _import_statement_line_ranges(reference_tree)
-    referenced_names = _collect_load_names_outside_import_ranges(
-        reference_tree,
-        reference_import_ranges,
-    )
-    import_bindings: list[tuple[str, int, int | None]] = []
-    for each_node in fragment_tree.body:
-        if isinstance(each_node, (ast.Import, ast.ImportFrom)):
-            if isinstance(each_node, ast.ImportFrom) and each_node.module == "__future__":
-                continue
-            for each_binding in _import_alias_pairs(each_node):
-                import_bindings.append(each_binding)
-    issues: list[str] = []
-    for each_name, each_line_number, each_from_keyword_line in import_bindings:
-        if 1 <= each_line_number <= len(fragment_lines):
-            if line_suppresses_unused_import_via_noqa(fragment_lines[each_line_number - 1]):
-                continue
-        if each_from_keyword_line is not None and 1 <= each_from_keyword_line <= len(
-            fragment_lines
-        ):
-            if line_suppresses_unused_import_via_noqa(
-                fragment_lines[each_from_keyword_line - 1]
-            ):
-                continue
-        if each_name in referenced_names:
-            continue
-        issues.append(
-            f"Line {each_line_number}: unused module-level import {each_name!r}"
-            f" — {UNUSED_IMPORT_GUIDANCE}"
-        )
-        if len(issues) >= MAX_UNUSED_IMPORT_ISSUES:
-            break
-    return issues

package/hooks/blocking/hedging_language_blocker.py

@@ -1,221 +0,0 @@
-#!/usr/bin/env python3
-"""Stop hook for bare hedging words that mark unverified claims.
-
-Words like "likely" or "probably" stand in for evidence. When prose-style
-enforcement is on, a hedge word blocks the response unless the same sentence
-carries an explicit uncertainty label (unverified, I don't know, no source for
-this claim). A label in another sentence does not exempt a bare hedge.
-
-::
-
-    pass:  This claim is unverified; the deploy is probably blocked.
-    flag:  This claim is unverified. The deploy is probably blocked.
-
-When enforcement is off, surviving bare hedges emit privacy-safe advisory
-candidates (OP-07B). See rules/hedging-claims.md and
-docs/references/prose-style-enforcement.md.
-"""
-
-import json
-import os
-import re
-import sys
-from pathlib import Path
-
-_hooks_dir = str(Path(__file__).resolve().parent.parent)
-if _hooks_dir not in sys.path:
-    sys.path.insert(0, _hooks_dir)
-
-from blocking.config.prose_style_enforcement_constants import (  # noqa: E402
-    prose_style_enforcement_enabled_in_environment,
-)
-from hooks_constants.hedging_uncertainty_constants import (  # noqa: E402
-    ALL_EXPLICIT_UNCERTAINTY_LABEL_PATTERNS,
-    BLOCK_REASON_PREFIX,
-    HEDGING_TERM_LIST_SEPARATOR,
-    POSITIVE_CORRECTIVE_GUIDANCE,
-    SENTENCE_BOUNDARY_PATTERN,
-)
-from hooks_constants.hook_block_logger import log_hook_block  # noqa: E402
-from hooks_constants.messages import USER_FACING_NOTICE  # noqa: E402
-from hooks_constants.prose_matcher_precision_constants import (  # noqa: E402
-    ADVISORY_CONTEXT_SNIPPET_MAX_CHARS,
-    MATCHER_ID_HEDGING_WORD,
-    MAXIMUM_ADVISORY_EMITS_PER_CALL,
-)
-from hooks_constants.text_stripping import strip_code_and_quotes  # noqa: E402
-from observability.prose_matcher_advisory import emit_advisory_candidate  # noqa: E402
-
-PLUGIN_ROOT = os.path.dirname(os.path.dirname(os.path.dirname(os.path.abspath(__file__))))
-
-RESEARCH_MODE_SKILL_SEARCH_PATHS = [
-    os.path.join(PLUGIN_ROOT, ".agents", "skills", "research-mode", "SKILL.md"),
-    os.path.join(PLUGIN_ROOT, "skills", "research-mode", "SKILL.md"),
-    os.path.join(os.path.expanduser("~"), ".claude", "skills", "research-mode", "SKILL.md"),
-    os.path.join(os.path.expanduser("~"), ".claude", "plugins", "marketplaces", "claude-deep-research", "skills", "research-mode", "SKILL.md"),
-]
-
-HEDGING_WORDS = [
-    r"\blikely\b",
-    r"\bunlikely\b",
-    r"\bprobably\b",
-    r"\bprobable\b",
-    r"\bpresumably\b",
-    r"\bperhaps\b",
-    r"\bpossibly\b",
-    r"\bseemingly\b",
-    r"\bapparently\b",
-    r"\barguably\b",
-    r"\bsupposedly\b",
-    r"\bostensibly\b",
-    r"\bconceivably\b",
-    r"\bplausibly\b",
-]
-
-HEDGING_PHRASES = [
-    r"\bmight be\b",
-    r"\bcould be\b",
-    r"\bseems to be\b",
-    r"\bappears to be\b",
-    r"\bin all likelihood\b",
-    r"\bmore likely than not\b",
-    r"\bit.s possible that\b",
-]
-
-ALL_HEDGING_PATTERNS = [
-    re.compile(pattern, re.IGNORECASE) for pattern in HEDGING_WORDS + HEDGING_PHRASES
-]
-
-
-def _sentence_carries_explicit_uncertainty(sentence: str) -> bool:
-    """Return True when the sentence labels the claim as unknown or unverified."""
-    for each_label_pattern in ALL_EXPLICIT_UNCERTAINTY_LABEL_PATTERNS:
-        if each_label_pattern.search(sentence):
-            return True
-    return False
-
-
-def _hedging_terms_in_prose_slice(prose_slice: str) -> list[str]:
-    """Return unique hedge terms found in one prose slice (sentence or full text)."""
-    matched_terms: list[str] = []
-    for each_pattern in ALL_HEDGING_PATTERNS:
-        for each_match in each_pattern.findall(prose_slice):
-            normalized_term = each_match.strip().lower()
-            if normalized_term not in matched_terms:
-                matched_terms.append(normalized_term)
-    return matched_terms
-
-
-def find_hedging_words(text: str) -> list[str]:
-    """Return all hedging words/phrases in the stripped prose (any sentence)."""
-    prose_text = strip_code_and_quotes(text)
-    return _hedging_terms_in_prose_slice(prose_text)
-
-
-def find_blocking_hedging_terms(text: str) -> list[str]:
-    """Return hedge terms that lack an explicit uncertainty label in-sentence.
-
-    ::
-
-        find_blocking_hedging_terms("Unverified: the port is probably down.")
-            -> []
-        find_blocking_hedging_terms("Unverified. The port is probably down.")
-            -> ["probably"]
-
-    Args:
-        text: Full assistant message, including code and quotes.
-
-    Returns:
-        Unique bare hedge terms that still warrant a block or advisory emit.
-    """
-    prose_text = strip_code_and_quotes(text)
-    if not prose_text.strip():
-        return []
-
-    all_sentences = SENTENCE_BOUNDARY_PATTERN.split(prose_text)
-    if len(all_sentences) <= 1:
-        all_sentences = [prose_text]
-
-    matched_terms: list[str] = []
-    for each_sentence in all_sentences:
-        if not each_sentence.strip():
-            continue
-        if _sentence_carries_explicit_uncertainty(each_sentence):
-            continue
-        for each_term in _hedging_terms_in_prose_slice(each_sentence):
-            if each_term not in matched_terms:
-                matched_terms.append(each_term)
-    return matched_terms
-
-
-def main() -> None:
-    try:
-        hook_input = json.load(sys.stdin)
-    except json.JSONDecodeError:
-        sys.exit(0)
-
-    if hook_input.get("stop_hook_active", False):
-        sys.exit(0)
-
-    assistant_message = hook_input.get("last_assistant_message", "")
-
-    if not assistant_message:
-        sys.exit(0)
-
-    found_hedging_terms = find_blocking_hedging_terms(assistant_message)
-
-    if not found_hedging_terms:
-        sys.exit(0)
-
-    if not prose_style_enforcement_enabled_in_environment():
-        try:
-            for each_term in found_hedging_terms[:MAXIMUM_ADVISORY_EMITS_PER_CALL]:
-                emit_advisory_candidate(
-                    MATCHER_ID_HEDGING_WORD,
-                    "Stop",
-                    f"{each_term}:{assistant_message[:ADVISORY_CONTEXT_SNIPPET_MAX_CHARS]}",
-                )
-        except (ImportError, OSError, TypeError, ValueError):
-            pass
-        sys.exit(0)
-
-    formatted_term_list = HEDGING_TERM_LIST_SEPARATOR.join(
-        f'"{term}"' for term in found_hedging_terms
-    )
-
-    resolved_skill_path: str | None = None
-    for each_skill_path in RESEARCH_MODE_SKILL_SEARCH_PATHS:
-        if os.path.exists(each_skill_path):
-            resolved_skill_path = each_skill_path
-            break
-
-    if resolved_skill_path is not None:
-        skill_reference = f"under the research-mode constraints defined in:\n\n{resolved_skill_path}"
-    else:
-        skill_reference = (
-            "under research-mode constraints "
-            "(no research-mode skill installed; verify with sources or prompt the user via AskUserQuestion with potential options + context)"
-        )
-
-    block_reason = (
-        f"{BLOCK_REASON_PREFIX}{formatted_term_list}. "
-        f"Rewrite {skill_reference}\n\n"
-        f"{POSITIVE_CORRECTIVE_GUIDANCE}"
-    )
-    block_response = {
-        "decision": "block",
-        "reason": block_reason,
-        "systemMessage": USER_FACING_NOTICE,
-        "suppressOutput": True,
-    }
-    log_hook_block(
-        calling_hook_name="hedging_language_blocker.py",
-        hook_event="Stop",
-        block_reason=block_reason,
-    )
-    print(json.dumps(block_response))
-    sys.exit(0)
-
-
-if __name__ == "__main__":
-    main()

package/hooks/blocking/intent_only_ending_blocker.py

@@ -1,148 +0,0 @@
-#!/usr/bin/env python3
-"""Stop hook that blocks a turn ending with a promise of future work.
-
-When a turn ends with a forward-looking statement of intent ("I'll now run the
-tests", "Let me implement the fix"), complete the work with tool calls during
-the turn. Route work requiring user-only input through AskUserQuestion. The
-rule name is long-horizon-autonomy.
-"""
-
-import json
-import re
-import sys
-from pathlib import Path
-
-_hooks_dir = str(Path(__file__).resolve().parent.parent)
-if _hooks_dir not in sys.path:
-    sys.path.insert(0, _hooks_dir)
-
-from blocking.config.prose_style_enforcement_constants import (  # noqa: E402
-    prose_style_enforcement_enabled_in_environment,
-)
-from hooks_constants.hook_block_logger import log_hook_block  # noqa: E402
-from hooks_constants.messages import USER_FACING_INTENT_ENDING_NOTICE  # noqa: E402
-from hooks_constants.text_stripping import strip_code_and_quotes  # noqa: E402
-
-
-def extract_final_paragraph(text: str) -> str:
-    """Return the last non-empty paragraph of the prose after stripping code and quotes.
-
-    Args:
-        text: The raw assistant message to extract the closing paragraph from.
-    """
-    paragraph_split_pattern = re.compile(r"\n\s*\n")
-    prose_text = strip_code_and_quotes(text)
-    candidate_paragraphs = [
-        each_paragraph.strip()
-        for each_paragraph in paragraph_split_pattern.split(prose_text)
-        if each_paragraph.strip()
-    ]
-    if not candidate_paragraphs:
-        return ""
-    return candidate_paragraphs[-1]
-
-
-def extract_first_sentence(paragraph: str) -> str:
-    """Return the first sentence of a paragraph.
-
-    Args:
-        paragraph: The paragraph whose leading sentence is needed.
-    """
-    sentence_boundary_pattern = re.compile(r"(?<=[.!?])\s+")
-    sentences = sentence_boundary_pattern.split(paragraph.strip(), maxsplit=1)
-    if not sentences:
-        return ""
-    return sentences[0].strip()
-
-
-def find_intent_only_ending(text: str) -> bool:
-    """Return whether the final paragraph ends the turn on a promise about undone work.
-
-    Args:
-        text: The raw assistant message to evaluate.
-    """
-    future_intent_opener_pattern = re.compile(
-        r"^(?:(?:now|next|then|okay|alright)\s*,?\s*)?"
-        r"(?:i['’]ll(?:\s+now|\s+go\s+ahead\s+and|\s+proceed\s+to)?"
-        r"|i\s+will"
-        r"|i['’]m\s+going\s+to"
-        r"|i\s+am\s+going\s+to"
-        r"|i['’]m\s+about\s+to"
-        r"|i\s+plan\s+to"
-        r"|let\s+me"
-        r"|let['’]s"
-        r"|going\s+to)\b",
-        re.IGNORECASE,
-    )
-    undone_work_verb_pattern = re.compile(
-        r"\b(?:run|start|implement|create|write|add|fix|update|check|test|wire"
-        r"|build|deploy|push|git\s+commit|commit\s+the\s+changes"
-        r"|commit\s+the\s+fix|investigate|set\s+up|refactor|generate"
-        r"|install|continue|look\s+into)\b",
-        re.IGNORECASE,
-    )
-    next_steps_lead_in_pattern = re.compile(r"^next\s+steps?:", re.IGNORECASE)
-    second_person_subject_pattern = re.compile(
-        r"\b(?:you|your|you['’]?re|user['’]?s?)\b",
-        re.IGNORECASE,
-    )
-
-    final_paragraph = extract_final_paragraph(text)
-    if not final_paragraph:
-        return False
-
-    if next_steps_lead_in_pattern.match(final_paragraph):
-        return not second_person_subject_pattern.search(final_paragraph)
-
-    first_sentence = extract_first_sentence(final_paragraph)
-    if not future_intent_opener_pattern.match(first_sentence):
-        return False
-
-    return bool(undone_work_verb_pattern.search(first_sentence))
-
-
-def main() -> None:
-    """Read the stop-hook payload and block turns that promise future work."""
-    try:
-        hook_input = json.load(sys.stdin)
-    except json.JSONDecodeError:
-        sys.exit(0)
-
-    if hook_input.get("stop_hook_active", False):
-        sys.exit(0)
-
-    if not prose_style_enforcement_enabled_in_environment():
-        sys.exit(0)
-
-    assistant_message = hook_input.get("last_assistant_message", "")
-
-    if not assistant_message:
-        sys.exit(0)
-
-    if not find_intent_only_ending(assistant_message):
-        sys.exit(0)
-
-    block_reason = (
-        "LONG-HORIZON-AUTONOMY GUARDRAIL: This turn ends with a promise of future "
-        "work. Complete that work with tool calls during this turn. Route questions "
-        "requiring user-only input through AskUserQuestion, then end the turn cleanly.\n\n"
-        "Re-output the complete response with the work performed, per the "
-        "long-horizon-autonomy rule."
-    )
-    block_response = {
-        "decision": "block",
-        "reason": block_reason,
-        "systemMessage": USER_FACING_INTENT_ENDING_NOTICE,
-        "suppressOutput": True,
-    }
-    log_hook_block(
-        calling_hook_name="intent_only_ending_blocker.py",
-        hook_event="Stop",
-        block_reason=block_reason,
-    )
-    print(json.dumps(block_response))
-    sys.exit(0)
-
-
-if __name__ == "__main__":
-    main()