code-muse 0.0.1__py3-none-any.whl

code_muse/plugins/prompt_newline/register_callbacks.py

@@ -0,0 +1,159 @@
+"""Register callbacks for the prompt_newline plugin.
+
+This plugin is a tiny ergonomics hack: it places the user's input cursor on a
+*new line* below the muse/agent/model/cwd chrome, so long working-directory
+paths don't squeeze the typing area.
+
+It hooks two things:
+
+* ``startup`` — wraps ``get_prompt_with_active_model`` so the FormattedText it
+  returns gets a trailing ``\\n`` appended **at call time** (so the slash
+  command toggle takes effect immediately, no restart needed).
+* ``custom_command`` / ``custom_command_help`` — exposes ``/prompt_newline``
+  for runtime on/off, persisted via ``muse.cfg``.
+
+Default: OFF. Opt-in only.
+"""
+
+from code_muse.callbacks import register_callback
+from code_muse.plugins.prompt_newline.config import is_enabled, set_enabled
+
+_COMMAND_NAME = "prompt_newline"
+_PATCH_ATTR = "_prompt_newline_original"
+
+
+def _emit_info(message: str) -> None:
+    from code_muse.messaging import emit_info
+
+    emit_info(message)
+
+
+def _emit_error(message: str) -> None:
+    from code_muse.messaging import emit_error
+
+    emit_error(message)
+
+
+def _emit_success(message: str) -> None:
+    from code_muse.messaging import emit_success
+
+    emit_success(message)
+
+
+def _append_newline(formatted_text):
+    """Return a new FormattedText with a trailing newline tuple.
+
+    ``FormattedText`` is a ``list`` subclass of ``(style, text)`` tuples, so we
+    rebuild it rather than mutating in place — the upstream caller may cache
+    or reuse the returned object.
+    """
+    from prompt_toolkit.formatted_text import FormattedText
+
+    try:
+        return FormattedText(list(formatted_text) + [("", "\n")])
+    except Exception:
+        # Defensive: never break the prompt if the upstream shape changes.
+        return formatted_text
+
+
+def _install_prompt_patch() -> None:
+    """Monkey-patch ``get_prompt_with_active_model`` to honor ``is_enabled()``.
+
+    Idempotent: re-running won't double-wrap.
+    """
+    from code_muse.command_line import prompt_toolkit_completion as ptc
+
+    if getattr(ptc, _PATCH_ATTR, None) is not None:
+        return  # Already patched
+
+    original = ptc.get_prompt_with_active_model
+    setattr(ptc, _PATCH_ATTR, original)
+
+    def patched(base: str = ">>> "):
+        result = original(base)
+        if is_enabled():
+            return _append_newline(result)
+        return result
+
+    ptc.get_prompt_with_active_model = patched
+
+
+def _on_startup() -> None:
+    try:
+        _install_prompt_patch()
+    except Exception as exc:
+        # Plugins must fail gracefully — never crash the app.
+        _emit_error(f"prompt_newline: failed to install prompt patch — {exc}")
+
+
+def _custom_help() -> list[tuple[str, str]]:
+    return [
+        (
+            _COMMAND_NAME,
+            "Toggle placing user input on a new line below the prompt chrome",
+        )
+    ]
+
+
+def _parse_toggle_arg(command: str) -> bool | None:
+    """Parse ``/prompt_newline [on|off|true|false|toggle]``.
+
+    Returns:
+        True/False for an explicit set, or ``None`` to mean "flip current".
+    """
+    tokens = command.strip().split()
+    if len(tokens) < 2:
+        return None  # bare /prompt_newline → flip
+    arg = tokens[1].lower()
+    if arg in ("on", "true", "1", "yes", "enable", "enabled"):
+        return True
+    if arg in ("off", "false", "0", "no", "disable", "disabled"):
+        return False
+    if arg in ("toggle",):
+        return None
+    raise ValueError(arg)
+
+
+def _handle_prompt_newline_command(command: str) -> bool:
+    try:
+        target = _parse_toggle_arg(command)
+    except ValueError as exc:
+        _emit_error(
+            f"/{_COMMAND_NAME}: unknown argument '{exc.args[0]}'. "
+            "Usage: /prompt_newline [on|off|toggle]"
+        )
+        return True
+
+    if target is None:
+        target = not is_enabled()
+
+    set_enabled(target)
+    state = "ON" if target else "OFF"
+    _emit_success(f"[Run] prompt_newline is now {state}")
+    if target:
+        _emit_info("Your input will appear on a fresh line below the prompt chrome.")
+    else:
+        _emit_info("Prompt is back to single-line mode.")
+    return True
+
+
+def _handle_custom_command(command: str, name: str):
+    if name != _COMMAND_NAME:
+        return None
+    return _handle_prompt_newline_command(command)
+
+
+register_callback("startup", _on_startup)
+register_callback("custom_command", _handle_custom_command)
+register_callback("custom_command_help", _custom_help)
+
+
+__all__ = [
+    "_append_newline",
+    "_custom_help",
+    "_handle_custom_command",
+    "_handle_prompt_newline_command",
+    "_install_prompt_patch",
+    "_on_startup",
+    "_parse_toggle_arg",
+]

code_muse/plugins/safety_status/register_callbacks.py

@@ -0,0 +1,113 @@
+"""Safety status plugin — concise /safety and /status slash commands.
+
+Shows the current risk posture without exposing secret values.
+"""
+
+from pathlib import Path
+
+from rich.panel import Panel
+
+from code_muse.callbacks import count_callbacks, register_callback
+from code_muse.messaging import emit_info
+
+
+def _custom_help() -> list[tuple[str, str]]:
+    return [
+        ("safety", "Show safety and trust status (risk posture)"),
+        ("status", "Alias for /safety"),
+    ]
+
+
+def _get_status_lines() -> list[str]:
+    """Build a list of safety-status lines. All values are redacted or safe."""
+    lines: list[str] = []
+
+    # Yolo mode
+    try:
+        from code_muse.config import get_yolo_mode
+
+        yolo = get_yolo_mode()
+    except Exception:
+        yolo = False
+    lines.append(f"Yolo mode      : {'on' if yolo else 'off'}")
+
+    # Shell safety
+    try:
+        from code_muse.config import get_safety_permission_level
+
+        level = get_safety_permission_level()
+    except Exception:
+        level = "unknown"
+    lines.append(f"Shell safety   : {level}")
+
+    # Workspace root
+    try:
+        from code_muse.tools.path_policy import get_workspace_root
+
+        ws = get_workspace_root()
+    except Exception:
+        ws = Path.cwd()
+    lines.append(f"Workspace      : {ws}")
+
+    # Sensitive-file policy
+    try:
+        from code_muse.tools.path_policy import SENSITIVE_PATHS
+
+        policy = f"{len(SENSITIVE_PATHS)} sensitive patterns"
+    except Exception:
+        policy = "active"
+    lines.append(f"Sensitive policy: {policy}")
+
+    # Hook trust
+    try:
+        from code_muse.hook_engine.trust import _load_trust_db
+
+        db = _load_trust_db()
+        hook_count = len(db)
+    except Exception:
+        hook_count = 0
+    lines.append(f"Hook trust     : {hook_count} trusted project(s)")
+
+    # Plugin / callback activity
+    try:
+        total_callbacks = count_callbacks()
+    except Exception:
+        total_callbacks = 0
+    lines.append(f"Callbacks active: {total_callbacks}")
+
+    # Universal Constructor
+    try:
+        from code_muse.config import get_universal_constructor_enabled
+
+        uc = get_universal_constructor_enabled()
+    except Exception:
+        uc = True
+    lines.append(f"UC enabled     : {'yes' if uc else 'no'}")
+
+    # Environment redaction hint
+    lines.append("")
+    lines.append("Secret values are redacted in logs and status displays.")
+
+    return lines
+
+
+def _render_panel(lines: list[str]) -> Panel:
+    body = "\n".join(lines)
+    return Panel(body, title="Safety Status", border_style="cyan")
+
+
+def _handle_custom_command(command: str, name: str) -> bool | None:
+    if not name:
+        return None
+
+    if name in ("safety", "status"):
+        lines = _get_status_lines()
+        panel = _render_panel(lines)
+        emit_info(panel)
+        return True
+
+    return None
+
+
+register_callback("custom_command_help", _custom_help)
+register_callback("custom_command", _handle_custom_command)

code_muse/plugins/semantic_compression/__init__.py

@@ -0,0 +1,6 @@
+"""Semantic Compression Plugin.
+
+Lossy text compression that strips predictable grammar while
+preserving semantic content. Works on tool outputs and provides
+a ``/compress`` slash command for manual use.
+"""

code_muse/plugins/semantic_compression/compressor.py

@@ -0,0 +1,295 @@
+"""Semantic Compression Engine.
+
+Lossy text compression that removes predictable grammar while preserving
+semantic payload.  LLMs reconstruct grammar from content words, so we
+strip the glue and keep the meaning.
+
+Rules are applied in tiers:
+- Tier 1 (always safe): articles, copulas, filler phrases, intensifiers,
+  complementizer "that"
+- Tier 2 (aggressive): auxiliaries, modals (except must), pronouns,
+  relative pronouns
+- Structural: passive→active, nominalization→verb, redundant pairs,
+  clause→modifier
+
+Always preserved: nouns, main verbs, meaning-bearing modifiers, numbers,
+uncertainty markers, negation, temporal markers, causality, requirements,
+proper nouns, and technical terms.
+
+Code blocks (``` fenced ```) are detected and left untouched.
+"""
+
+import re
+
+# ---------------------------------------------------------------------------
+# Tier 1 — always safe deletions
+# ---------------------------------------------------------------------------
+
+# Articles: a, an, the (standalone, word boundary)
+_RE_ARTICLES = re.compile(r"\b(a|an|the)\b", re.IGNORECASE)
+
+# Copulas: is, are, was, were, am, be, been, being
+_RE_COPULAS = re.compile(r"\b(is|are|was|were|am|be|been|being)\b", re.IGNORECASE)
+
+# Pure intensifiers: very, quite, rather, really, extremely, somewhat
+_RE_INTENSIFIERS = re.compile(
+    r"\b(very|quite|rather|really|extremely|somewhat)\b", re.IGNORECASE
+)
+
+# Filler phrase → replacement
+_FILLER_PHRASES: list[tuple[re.Pattern, str]] = [
+    (re.compile(r"\bin order to\b", re.IGNORECASE), "to"),
+    (re.compile(r"\bdue to the fact that\b", re.IGNORECASE), "because"),
+    (re.compile(r"\bin terms of\b", re.IGNORECASE), ""),
+    (re.compile(r"\bin the process of\b", re.IGNORECASE), ""),
+    (re.compile(r"\bin the context of\b", re.IGNORECASE), ""),
+    (re.compile(r"\bit is worth noting that\b", re.IGNORECASE), ""),
+    (re.compile(r"\bneedless to say\b", re.IGNORECASE), ""),
+    (re.compile(r"\bwhat is called\b", re.IGNORECASE), ""),
+    (re.compile(r"\bas a matter of fact\b", re.IGNORECASE), ""),
+]
+
+# Complementizer "that" after bridge verbs.
+# Matches stems with regular -s/-ed/-ing plus common irregulars.
+# e.g. "report/reports/reported/reporting that X" → "report X"
+_BRIDGE_STEMS = (
+    r"know|think|believe|say|see|find|show|note|ensure|suggest"
+    r"|indicate|report|state|claim|argue|feel|suspect|realize"
+    r"|learn|discover|remember|forget|understand|assume"
+)
+# Captures bridge verb (stem + optional -s/-ed/-ing, or irregular)
+# Suffix handles regular -s/-ed/-ing and e-dropping -d (e.g. assume→assumed)
+_RE_COMPLEMENTIZER = re.compile(
+    rf"\b((?:{_BRIDGE_STEMS})(?:s|e?d|ing)?"
+    r"|knew|thought|said|saw|seen|found|showed|shown"
+    r"|felt|learnt|learnt|forgot|forgotten|understood"
+    r")\s+that\b",
+    re.IGNORECASE,
+)
+
+# ---------------------------------------------------------------------------
+# Tier 2 — aggressive (only when aggressive=True)
+# ---------------------------------------------------------------------------
+
+# Auxiliary verbs: have/has/had, do/does/did, will/would
+_RE_AUXILIARIES = re.compile(
+    r"\b(have|has|had|do|does|did|will|would)\b", re.IGNORECASE
+)
+
+# Modal verbs except "must"
+_RE_MODALS = re.compile(r"\b(can|could|may|might|should)\b", re.IGNORECASE)
+
+# Pronouns (subject/object, when referent is obvious)
+_RE_PRONOUNS = re.compile(
+    r"\b(it|this|that|these|those|he|she|they|him|her|them)\b",
+    re.IGNORECASE,
+)
+
+# Relative pronouns
+_RE_RELATIVES = re.compile(r"\b(which|that|who|whom)\b", re.IGNORECASE)
+
+# ---------------------------------------------------------------------------
+# Structural compression patterns
+# ---------------------------------------------------------------------------
+
+# Passive → active: "was eaten by dog" → "dog ate"
+# Pattern captures: group 1 = past participle, group 2 = agent noun
+# Handles regular -ed/-en and irregulars like made, gone, done, known
+_PASSIVE_BY_RE = re.compile(
+    r"\b(?:is|are|was|were|be|been|being)\s+"
+    r"(\w+(?:ed|en|[dt]e?|wn|own))"
+    r"\s+by\s+(?:the\s+)?(\w+)",
+    re.IGNORECASE,
+)
+
+# Nominalization → verb (common patterns)
+_NOMINALIZATIONS: list[tuple[re.Pattern, str]] = [
+    (re.compile(r"\bmade? a decision\b", re.IGNORECASE), "decided"),
+    (re.compile(r"\bmade? an? analysis\b", re.IGNORECASE), "analyzed"),
+    (re.compile(r"\bgave? consideration\b", re.IGNORECASE), "considered"),
+    (re.compile(r"\btook? into account\b", re.IGNORECASE), "considered"),
+    (re.compile(r"\bmade? an? assessment\b", re.IGNORECASE), "assessed"),
+    (re.compile(r"\bmade? an? evaluation\b", re.IGNORECASE), "evaluated"),
+    (re.compile(r"\bmade? a recommendation\b", re.IGNORECASE), "recommended"),
+    (re.compile(r"\bmade? an? observation\b", re.IGNORECASE), "observed"),
+    (re.compile(r"\bmade? a prediction\b", re.IGNORECASE), "predicted"),
+    (re.compile(r"\bmade? a statement\b", re.IGNORECASE), "stated"),
+    (re.compile(r"\bgave? permission\b", re.IGNORECASE), "permitted"),
+    (re.compile(r"\bconducted an? investigation\b", re.IGNORECASE), "investigated"),
+    (re.compile(r"\bperformed an? analysis\b", re.IGNORECASE), "analyzed"),
+    (re.compile(r"\btook? a look\b", re.IGNORECASE), "looked"),
+    (re.compile(r"\breached a conclusion\b", re.IGNORECASE), "concluded"),
+    (re.compile(r"\bcame to the conclusion\b", re.IGNORECASE), "concluded"),
+    (re.compile(r"\bprovided an? explanation\b", re.IGNORECASE), "explained"),
+]
+
+# Redundant pairs → single
+_REDUNDANT_PAIRS: list[tuple[re.Pattern, str]] = [
+    (re.compile(r"\beach and every\b", re.IGNORECASE), "every"),
+    (re.compile(r"\bfirst and foremost\b", re.IGNORECASE), "first"),
+    (re.compile(r"\bbasic and fundamental\b", re.IGNORECASE), "fundamental"),
+    (re.compile(r"\bnull and void\b", re.IGNORECASE), "void"),
+    (re.compile(r"\btrue and accurate\b", re.IGNORECASE), "accurate"),
+    (re.compile(r"\bfull and complete\b", re.IGNORECASE), "complete"),
+    (re.compile(r"\bany and all\b", re.IGNORECASE), "all"),
+    (re.compile(r"\bvarious and sundry\b", re.IGNORECASE), "various"),
+]
+
+# Clause → modifier: "anomaly that was reported" → "reported anomaly"
+# Pattern: noun + relative pronoun + copula + past participle → past participle + noun
+_CLAUSE_TO_MODIFIER_RE = re.compile(
+    r"\b(\w+)\s+(?:that|which|who)\s+(?:is|are|was|were|be|been|being)\s+"
+    r"(\w+(?:ed|en|[dt]e?|wn|own))\b",
+    re.IGNORECASE,
+)
+
+# ---------------------------------------------------------------------------
+# Code block handling
+# ---------------------------------------------------------------------------
+
+_FENCE_RE = re.compile(r"```[\s\S]*?```")
+
+
+def _split_code_blocks(text: str) -> list[tuple[bool, str]]:
+    """Split *text* into (is_code, segment) tuples.
+
+    Code fences (``` ... ```) are marked as code and left untouched.
+    Everything else is non-code and eligible for compression.
+    """
+    segments: list[tuple[bool, str]] = []
+    pos = 0
+    for match in _FENCE_RE.finditer(text):
+        start = match.start()
+        if start > pos:
+            segments.append((False, text[pos:start]))
+        segments.append((True, match.group()))
+        pos = match.end()
+    if pos < len(text):
+        segments.append((False, text[pos:]))
+    return segments
+
+
+# ---------------------------------------------------------------------------
+# Core compression pipeline
+# ---------------------------------------------------------------------------
+
+
+def compress_semantic(text: str, aggressive: bool = False) -> str:
+    """Apply semantic compression to *text*.
+
+    Parameters
+    ----------
+    text:
+        The input text to compress.
+    aggressive:
+        If ``True``, also apply Tier 2 deletions (auxiliaries, modals,
+        pronouns, relatives) in addition to Tier 1.
+
+    Returns
+    -------
+    str
+        The compressed text with code blocks preserved.
+    """
+    if not text or not text.strip():
+        return text
+
+    # Split into code and non-code segments
+    segments = _split_code_blocks(text)
+
+    result_parts: list[str] = []
+    for is_code, segment in segments:
+        if is_code:
+            result_parts.append(segment)
+        else:
+            result_parts.append(_compress_segment(segment, aggressive))
+
+    return "".join(result_parts)
+
+
+def _compress_segment(segment: str, aggressive: bool) -> str:
+    """Compress a single non-code text segment.
+
+    Order matters: structural transformations run *before* Tier 1
+    deletions so patterns like passive→active can see the copulas
+    before they are stripped.
+    """
+    s = segment
+
+    # --- Structural compression (before Tier 1) ---
+
+    # Passive → active: "was eaten by dog" → "dog ate"
+    s = _PASSIVE_BY_RE.sub(r"\2 \1", s)
+
+    # Clause → modifier: "anomaly that was reported" → "reported anomaly"
+    s = _CLAUSE_TO_MODIFIER_RE.sub(r"\2 \1", s)
+
+    # Nominalizations → verb
+    for pattern, replacement in _NOMINALIZATIONS:
+        s = pattern.sub(replacement, s)
+
+    # Redundant pairs → single
+    for pattern, replacement in _REDUNDANT_PAIRS:
+        s = pattern.sub(replacement, s)
+
+    # --- Tier 1 (always safe deletions) ---
+
+    # Filler phrases first (they may contain articles/copulas)
+    for pattern, replacement in _FILLER_PHRASES:
+        s = pattern.sub(replacement, s)
+
+    # Complementizer "that" after bridge verbs
+    s = _RE_COMPLEMENTIZER.sub(r"\1", s)
+
+    # Articles
+    s = _RE_ARTICLES.sub("", s)
+
+    # Copulas (after structural pass, so passive→active already fired)
+    s = _RE_COPULAS.sub("", s)
+
+    # Pure intensifiers
+    s = _RE_INTENSIFIERS.sub("", s)
+
+    # --- Tier 2 (aggressive only) ---
+    if aggressive:
+        s = _RE_AUXILIARIES.sub("", s)
+        s = _RE_MODALS.sub("", s)
+        s = _RE_PRONOUNS.sub("", s)
+        s = _RE_RELATIVES.sub("", s)
+
+    # --- Post-processing ---
+
+    # Collapse multiple spaces into one
+    s = re.sub(r" {2,}", " ", s)
+
+    # Remove space before punctuation
+    s = re.sub(r" +([.,!?;:])", r"\1", s)
+
+    # Remove leading/trailing whitespace per line
+    lines = [ln.strip() for ln in s.splitlines()]
+    s = "\n".join(ln for ln in lines if ln)
+
+    # Collapse 3+ consecutive newlines into 2
+    s = re.sub(r"\n{3,}", "\n\n", s)
+
+    return s
+
+
+# ---------------------------------------------------------------------------
+# Convenience: compress known patterns in one shot
+# ---------------------------------------------------------------------------
+
+
+def compress_for_llm(text: str) -> str:
+    """Compress text intended for LLM consumption (aggressive mode).
+
+    Equivalent to ``compress_semantic(text, aggressive=True)``.
+    """
+    return compress_semantic(text, aggressive=True)
+
+
+def compress_for_display(text: str) -> str:
+    """Compress text for human display (safe mode only, Tier 1).
+
+    Equivalent to ``compress_semantic(text, aggressive=False)``.
+    """
+    return compress_semantic(text, aggressive=False)

code_muse/plugins/semantic_compression/config.py

@@ -0,0 +1,123 @@
+"""Plugin-level config helpers for semantic_compression."""
+
+import json
+import logging
+
+from code_muse.config import get_value, set_config_value
+
+logger = logging.getLogger(__name__)
+
+_CONFIG_KEY_ENABLED = "semantic_compression_enabled"
+_CONFIG_KEY_ALLOWLIST = "semantic_compression_allowlist"
+_CONFIG_KEY_BLOCKLIST = "semantic_compression_blocklist"
+_TRUTHY = ("true", "1", "yes", "on")
+
+
+def get_semantic_compression_enabled() -> bool:
+    """Check if automatic semantic compression of tool output is enabled.
+
+    Returns:
+        True if enabled, False otherwise. Default: False (opt-in).
+    """
+    cfg_val = get_value(_CONFIG_KEY_ENABLED)
+    if cfg_val is None:
+        return False
+    return str(cfg_val).strip().lower() in _TRUTHY
+
+
+def set_semantic_compression_enabled(enabled: bool) -> None:
+    """Enable or disable automatic semantic compression of tool output.
+
+    Args:
+        enabled: True to enable, False to disable.
+    """
+    set_config_value(_CONFIG_KEY_ENABLED, "true" if enabled else "false")
+    logger.info("Semantic compression %s", "enabled" if enabled else "disabled")
+
+
+def _parse_json_tool_list(config_value: str | None) -> set[str]:
+    """Parse a JSON list of tool names from config.
+
+    Returns:
+        Set of tool names. Empty set if config is missing or invalid.
+    """
+    if not config_value:
+        return set()
+    try:
+        parsed = json.loads(config_value)
+        if isinstance(parsed, list):
+            return {str(item).strip() for item in parsed if item}
+    except json.JSONDecodeError as e:
+        logger.error("Failed to parse tool list config: %s", e)
+    return set()
+
+
+def _serialize_tool_list(tool_names: set[str]) -> str:
+    """Serialize a set of tool names to a JSON list string."""
+    return json.dumps(sorted(tool_names))
+
+
+def get_compression_allowlist() -> set[str]:
+    """Get the set of tool names explicitly allowed for compression.
+
+    Returns:
+        Set of tool names. If non-empty, ONLY these tools will have
+        their output compressed (when enabled). Empty means all tools
+        are allowed unless blocked.
+    """
+    return _parse_json_tool_list(get_value(_CONFIG_KEY_ALLOWLIST))
+
+
+def set_compression_allowlist(tool_names: set[str]) -> None:
+    """Set the allowlist of tool names for compression.
+
+    Args:
+        tool_names: Set of tool names to allow. Empty set clears the allowlist.
+    """
+    set_config_value(_CONFIG_KEY_ALLOWLIST, _serialize_tool_list(tool_names))
+    logger.info("Compression allowlist updated: %s", sorted(tool_names) or "(empty)")
+
+
+def get_compression_blocklist() -> set[str]:
+    """Get the set of tool names explicitly blocked from compression.
+
+    Returns:
+        Set of tool names that will never have their output compressed,
+        even when compression is enabled.
+    """
+    return _parse_json_tool_list(get_value(_CONFIG_KEY_BLOCKLIST))
+
+
+def set_compression_blocklist(tool_names: set[str]) -> None:
+    """Set the blocklist of tool names for compression.
+
+    Args:
+        tool_names: Set of tool names to block. Empty set clears the blocklist.
+    """
+    set_config_value(_CONFIG_KEY_BLOCKLIST, _serialize_tool_list(tool_names))
+    logger.info("Compression blocklist updated: %s", sorted(tool_names) or "(empty)")
+
+
+def is_tool_allowed(tool_name: str) -> bool:
+    """Check if a specific tool's output should be compressed.
+
+    Logic:
+        1. If blocklist contains the tool name → False.
+        2. If allowlist is non-empty and does NOT contain the tool → False.
+        3. Otherwise → True.
+
+    Args:
+        tool_name: Name of the tool to check.
+
+    Returns:
+        True if the tool's output may be compressed, False otherwise.
+    """
+    blocklist = get_compression_blocklist()
+    if tool_name in blocklist:
+        return False
+
+    allowlist = get_compression_allowlist()
+    if allowlist and tool_name not in allowlist:
+        return False
+
+    return True